switchboard/core
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Releases 9 Wiki Activity

Changeset 0.28.0.3 (#175)

Browse Source
This commit is contained in:
xcaliber
2026-03-12 10:22:08 +00:00
parent 8e08f3e4b0
commit f5171d3bd3
17 changed files with 956 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
server/handlers/teams.go
View File

@@ -14,7 +14,9 @@ import (
"git.gobha.me/xcaliber/chat-switchboard/crypto"
"git.gobha.me/xcaliber/chat-switchboard/database"
"git.gobha.me/xcaliber/chat-switchboard/models"
"git.gobha.me/xcaliber/chat-switchboard/providers"
"git.gobha.me/xcaliber/chat-switchboard/store"
)
// ── Request types ───────────────────────────
@@ -43,11 +45,12 @@ type updateMemberRequest struct {
// ── Handler ─────────────────────────────────
type TeamHandler struct{
vault *crypto.KeyResolver
stores store.Stores
vault *crypto.KeyResolver
}
func NewTeamHandler(vault *crypto.KeyResolver) *TeamHandler {
return &TeamHandler{vault: vault}
func NewTeamHandler(s store.Stores, vault *crypto.KeyResolver) *TeamHandler {
return &TeamHandler{stores: s, vault: vault}
}
// ── Admin: List All Teams ───────────────────
@@ -61,59 +64,29 @@ func (h *TeamHandler) ListTeams(c *gin.Context) {
if perPage < 1 || perPage > 100 {
perPage = 50
}
offset := (page - 1) * perPage
var total int
if err := database.DB.QueryRow(database.Q(`SELECT COUNT(*) FROM teams`)).Scan(&total); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count teams"})
return
}
rows, err := database.DB.Query(database.Q(`
SELECT t.id, t.name, t.description, t.created_by, t.is_active,
COALESCE(t.settings, '{}'), t.created_at, t.updated_at,
COALESCE(mc.cnt, 0) AS member_count
FROM teams t
LEFT JOIN (
SELECT team_id, COUNT(*) AS cnt FROM team_members GROUP BY team_id
) mc ON mc.team_id = t.id
ORDER BY t.name ASC
LIMIT $1 OFFSET $2
`), perPage, offset)
all, err := h.stores.Teams.List(c.Request.Context())
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
return
}
defer rows.Close()
var teams []gin.H
for rows.Next() {
var id, name, desc, createdBy, settings string
var isActive bool
var memberCount int
var createdAt, updatedAt time.Time
if err := rows.Scan(&id, &name, &desc, &createdBy, &isActive, &settings,
database.ST(&createdAt), database.ST(&updatedAt), &memberCount); err != nil {
continue
}
teams = append(teams, gin.H{
"id": id,
"name": name,
"description": desc,
"created_by": createdBy,
"is_active": isActive,
"settings": settings,
"member_count": memberCount,
"created_at": createdAt,
"updated_at": updatedAt,
})
if all == nil {
all = []models.Team{}
}
if teams == nil {
teams = []gin.H{}
total := len(all)
// In-memory pagination (teams are low-cardinality)
offset := (page - 1) * perPage
end := offset + perPage
if offset > total {
offset = total
}
if end > total {
end = total
}
c.JSON(http.StatusOK, gin.H{
"data": teams,
"data": all[offset:end],
"total": total,
"page": page,
"per_page": perPage,
@@ -131,12 +104,13 @@ func (h *TeamHandler) CreateTeam(c *gin.Context) {
return
}
id, err := database.InsertReturningID(`
INSERT INTO teams (name, description, created_by)
VALUES ($1, $2, $3)
RETURNING id
`, req.Name, req.Description, adminID)
if err != nil {
team := &models.Team{
Name: req.Name,
Description: req.Description,
CreatedBy: adminID,
IsActive: true,
}
if err := h.stores.Teams.Create(c.Request.Context(), team); err != nil {
if database.IsUniqueViolation(err) {
c.JSON(http.StatusConflict, gin.H{"error": "team name already exists"})
return
@@ -145,8 +119,8 @@ func (h *TeamHandler) CreateTeam(c *gin.Context) {
return
}
c.JSON(http.StatusCreated, gin.H{"id": id, "name": req.Name})
AuditLog(c, "team.create", "team", id, map[string]interface{}{"name": req.Name})
c.JSON(http.StatusCreated, gin.H{"id": team.ID, "name": team.Name})
AuditLog(c, "team.create", "team", team.ID, map[string]interface{}{"name": team.Name})
}
// ── Admin: Get Team ─────────────────────────
@@ -154,18 +128,7 @@ func (h *TeamHandler) CreateTeam(c *gin.Context) {
func (h *TeamHandler) GetTeam(c *gin.Context) {
teamID := c.Param("id")
var name, desc, createdBy, settings string
var isActive bool
var memberCount int
var createdAt, updatedAt time.Time
err := database.DB.QueryRow(database.Q(`
SELECT t.name, t.description, t.created_by, t.is_active,
COALESCE(t.settings, '{}'), t.created_at, t.updated_at,
(SELECT COUNT(*) FROM team_members WHERE team_id = t.id)
FROM teams t WHERE t.id = $1
`), teamID).Scan(&name, &desc, &createdBy, &isActive, &settings,
database.ST(&createdAt), database.ST(&updatedAt), &memberCount)
team, err := h.stores.Teams.GetByID(c.Request.Context(), teamID)
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "team not found"})
return
@@ -175,17 +138,7 @@ func (h *TeamHandler) GetTeam(c *gin.Context) {
return
}
c.JSON(http.StatusOK, gin.H{
"id": teamID,
"name": name,
"description": desc,
"created_by": createdBy,
"is_active": isActive,
"settings": settings,
"member_count": memberCount,
"created_at": createdAt,
"updated_at": updatedAt,
})
c.JSON(http.StatusOK, team)
}
// ── Admin: Update Team ──────────────────────
@@ -271,14 +224,20 @@ func (h *TeamHandler) UpdateTeam(c *gin.Context) {
func (h *TeamHandler) DeleteTeam(c *gin.Context) {
teamID := c.Param("id")
ctx := c.Request.Context()
res, err := database.DB.Exec(database.Q(`DELETE FROM teams WHERE id = $1`), teamID)
if err != nil {
// Verify existence
if _, err := h.stores.Teams.GetByID(ctx, teamID); err != nil {
if err == sql.ErrNoRows {
c.JSON(http.StatusNotFound, gin.H{"error": "team not found"})
return
}
c.JSON(http.StatusInternalServerError, gin.H{"error": "delete failed"})
return
}
if n, _ := res.RowsAffected(); n == 0 {
c.JSON(http.StatusNotFound, gin.H{"error": "team not found"})
if err := h.stores.Teams.Delete(ctx, teamID); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "delete failed"})
return
}
@@ -291,38 +250,13 @@ func (h *TeamHandler) DeleteTeam(c *gin.Context) {
func (h *TeamHandler) ListMembers(c *gin.Context) {
teamID := getTeamID(c)
rows, err := database.DB.Query(database.Q(`
SELECT tm.id, tm.user_id, tm.role, tm.joined_at,
u.email, COALESCE(u.display_name, '') AS display_name, u.role AS user_role
FROM team_members tm
JOIN users u ON u.id = tm.user_id
WHERE tm.team_id = $1
ORDER BY tm.role ASC, u.email ASC
`), teamID)
members, err := h.stores.Teams.ListMembers(c.Request.Context(), teamID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
return
}
defer rows.Close()
var members []gin.H
for rows.Next() {
var id, userID, role, email, displayName, userRole, joinedAt string
if err := rows.Scan(&id, &userID, &role, &joinedAt, &email, &displayName, &userRole); err != nil {
continue
}
members = append(members, gin.H{
"id": id,
"user_id": userID,
"role": role,
"joined_at": joinedAt,
"email": email,
"display_name": displayName,
"user_role": userRole,
})
}
if members == nil {
members = []gin.H{}
members = []models.TeamMember{}
}
c.JSON(http.StatusOK, gin.H{"data": members})
@@ -377,6 +311,7 @@ func (h *TeamHandler) AddMember(c *gin.Context) {
// ── Members: Update Role ────────────────────
func (h *TeamHandler) UpdateMember(c *gin.Context) {
teamID := getTeamID(c)
memberID := c.Param("memberId")
var req updateMemberRequest
@@ -386,8 +321,8 @@ func (h *TeamHandler) UpdateMember(c *gin.Context) {
}
res, err := database.DB.Exec(database.Q(`
UPDATE team_members SET role = $1 WHERE id = $2
`), req.Role, memberID)
UPDATE team_members SET role = $1 WHERE id = $2 AND team_id = $3
`), req.Role, memberID, teamID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
return
@@ -406,9 +341,10 @@ func (h *TeamHandler) UpdateMember(c *gin.Context) {
// ── Members: Remove ─────────────────────────
func (h *TeamHandler) RemoveMember(c *gin.Context) {
teamID := getTeamID(c)
memberID := c.Param("memberId")
res, err := database.DB.Exec(database.Q(`DELETE FROM team_members WHERE id = $1`), memberID)
res, err := database.DB.Exec(database.Q(`DELETE FROM team_members WHERE id = $1 AND team_id = $2`), memberID, teamID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "remove failed"})
return
@@ -429,42 +365,13 @@ func (h *TeamHandler) RemoveMember(c *gin.Context) {
func (h *TeamHandler) MyTeams(c *gin.Context) {
userID := getUserID(c)
rows, err := database.DB.Query(database.Q(`
SELECT t.id, t.name, t.description, t.is_active,
COALESCE(t.settings, '{}'),
tm.role AS my_role,
(SELECT COUNT(*) FROM team_members WHERE team_id = t.id) AS member_count
FROM teams t
JOIN team_members tm ON tm.team_id = t.id AND tm.user_id = $1
WHERE t.is_active = true
ORDER BY t.name ASC
`), userID)
teams, err := h.stores.Teams.ListForUser(c.Request.Context(), userID)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
return
}
defer rows.Close()
var teams []gin.H
for rows.Next() {
var id, name, desc, settings, myRole string
var isActive bool
var memberCount int
if err := rows.Scan(&id, &name, &desc, &isActive, &settings, &myRole, &memberCount); err != nil {
continue
}
teams = append(teams, gin.H{
"id": id,
"name": name,
"description": desc,
"is_active": isActive,
"settings": settings,
"my_role": myRole,
"member_count": memberCount,
})
}
if teams == nil {
teams = []gin.H{}
teams = []models.Team{}
}
c.JSON(http.StatusOK, gin.H{"data": teams})
@@ -581,11 +488,6 @@ func getTeamID(c *gin.Context) string {
return c.Param("id")
}
// isUniqueViolation checks if a PG/SQLite error is a unique constraint violation.
func isUniqueViolation(err error) bool {
return database.IsUniqueViolation(err)
}
// IsTeamAdmin checks if a user is an admin of the given team.
func IsTeamAdmin(userID, teamID string) bool {
var role string
@@ -706,11 +608,6 @@ func (h *TeamHandler) ListTeamAuditLog(c *gin.Context) {
ORDER BY al.created_at DESC
` + limitOffset
if database.IsPostgres() {
// Re-convert placeholders for the full query
query = convertPlaceholders(query)
}
rows, err := database.DB.Query(query, args...)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "query failed"})
@@ -719,15 +616,15 @@ func (h *TeamHandler) ListTeamAuditLog(c *gin.Context) {
defer rows.Close()
type entry struct {
ID string `json:"id"`
ActorID *string `json:"actor_id"`
ActorName *string `json:"actor_name"`
Action string `json:"action"`
ResourceType string `json:"resource_type"`
ResourceID *string `json:"resource_id"`
Metadata string `json:"metadata"`
IPAddress *string `json:"ip_address"`
CreatedAt string `json:"created_at"`
ID string `json:"id"`
ActorID *string `json:"actor_id"`
ActorName *string `json:"actor_name"`
Action string `json:"action"`
ResourceType string `json:"resource_type"`
ResourceID *string `json:"resource_id"`
Metadata string `json:"metadata"`
IPAddress *string `json:"ip_address"`
CreatedAt time.Time `json:"created_at"`
}
entries := make([]entry, 0)
@@ -735,7 +632,7 @@ func (h *TeamHandler) ListTeamAuditLog(c *gin.Context) {
var e entry
var actorName sql.NullString
if err := rows.Scan(&e.ID, &e.ActorID, &actorName, &e.Action,
&e.ResourceType, &e.ResourceID, &e.Metadata, &e.IPAddress, &e.CreatedAt); err != nil {
&e.ResourceType, &e.ResourceID, &e.Metadata, &e.IPAddress, database.ST(&e.CreatedAt)); err != nil {
continue
}
if actorName.Valid {