ListClients()

server/api/handler/api.go

@@ -96,7 +96,7 @@ func (h APIHandler) CreateUser(g *gin.Context) ginresp.HTTPResponse {
 
 // GetUser swaggerdoc
 //
-// @Summary Get a user (only self is allowed)
+// @Summary Get a user
 // @ID      api-user-get
 //
 // @Param   uid path     int true "UserID"
@@ -137,7 +137,7 @@ func (h APIHandler) GetUser(g *gin.Context) ginresp.HTTPResponse {
 
 // UpdateUser swaggerdoc
 //
-// @Summary     (Partially) update a user (only self allowed)
+// @Summary     (Partially) update a user
 // @Description The body-values are optional, only send the ones you want to update
 // @ID          api-user-update
 //
@@ -212,8 +212,47 @@ func (h APIHandler) UpdateUser(g *gin.Context) ginresp.HTTPResponse {
 	return ctx.FinishSuccess(ginresp.JSON(http.StatusOK, user.JSON()))
 }
 
+// ListClients swaggerdoc
+//
+// @Summary List all clients
+// @ID      api-clients-list
+//
+// @Param   uid path     int true "UserID"
+//
+// @Success 200 {object} handler.ListClients.result
+// @Failure 400 {object} ginresp.apiError
+// @Failure 401 {object} ginresp.apiError
+// @Failure 404 {object} ginresp.apiError
+// @Failure 500 {object} ginresp.apiError
+//
+// @Router  /api-v2/user/{uid}/clients [GET]
 func (h APIHandler) ListClients(g *gin.Context) ginresp.HTTPResponse {
-	return ginresp.NotImplemented()
+	type uri struct {
+		UserID int64 `uri:"uid"`
+	}
+	type result struct {
+		Clients []models.ClientJSON `json:"clients"`
+	}
+
+	var u uri
+	ctx, errResp := h.app.StartRequest(g, &u, nil, nil)
+	if errResp != nil {
+		return *errResp
+	}
+	defer ctx.Cancel()
+
+	if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
+		return *permResp
+	}
+
+	clients, err := h.app.Database.ListClients(ctx, u.UserID)
+	if err != nil {
+		return ginresp.InternAPIError(500, apierr.DATABASE_ERROR, "Failed to query user", err)
+	}
+
+	res := langext.ArrMap(clients, func(v models.Client) models.ClientJSON { return v.JSON() })
+
+	return ctx.FinishSuccess(ginresp.JSON(http.StatusOK, result{Clients: res}))
 }
 
 func (h APIHandler) GetClient(g *gin.Context) ginresp.HTTPResponse {

server/api/models/channel.go

@@ -3,6 +3,7 @@ package models
 import (
 	"database/sql"
 	"github.com/blockloop/scan"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
@@ -71,10 +72,19 @@ func (c ChannelDB) Model() Channel {
 }
 
 func DecodeChannel(r *sql.Rows) (Channel, error) {
-	var udb ChannelDB
-	err := scan.RowStrict(&udb, r)
+	var data ChannelDB
+	err := scan.RowStrict(&data, r)
 	if err != nil {
 		return Channel{}, err
 	}
-	return udb.Model(), nil
+	return data.Model(), nil
+}
+
+func DecodeChannels(r *sql.Rows) ([]Channel, error) {
+	var data []ChannelDB
+	err := scan.RowsStrict(&data, r)
+	if err != nil {
+		return nil, err
+	}
+	return langext.ArrMap(data, func(v ChannelDB) Channel { return v.Model() }), nil
 }

server/api/models/client.go

@@ -1,6 +1,11 @@
 package models
 
-import "time"
+import (
+	"database/sql"
+	"github.com/blockloop/scan"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"time"
+)
 
 type ClientType string
 
@@ -19,5 +24,64 @@ type Client struct {
 	AgentVersion     string
 }
 
-type ClientJSON struct {
+func (c Client) JSON() ClientJSON {
+	return ClientJSON{
+		ClientID:         c.ClientID,
+		UserID:           c.UserID,
+		Type:             c.Type,
+		FCMToken:         c.FCMToken,
+		TimestampCreated: c.TimestampCreated.Format(time.RFC3339Nano),
+		AgentModel:       c.AgentModel,
+		AgentVersion:     c.AgentVersion,
+	}
+}
+
+type ClientJSON struct {
+	ClientID         int64      `json:"client_id"`
+	UserID           int64      `json:"user_id"`
+	Type             ClientType `json:"type"`
+	FCMToken         *string    `json:"fcm_token"`
+	TimestampCreated string     `json:"timestamp_created"`
+	AgentModel       string     `json:"agent_model"`
+	AgentVersion     string     `json:"agent_version"`
+}
+
+type ClientDB struct {
+	ClientID         int64      `db:"client_id"`
+	UserID           int64      `db:"user_id"`
+	Type             ClientType `db:"type"`
+	FCMToken         *string    `db:"fcm_token"`
+	TimestampCreated int64      `db:"timestamp_created"`
+	AgentModel       string     `db:"agent_model"`
+	AgentVersion     string     `db:"agent_version"`
+}
+
+func (c ClientDB) Model() Client {
+	return Client{
+		ClientID:         c.ClientID,
+		UserID:           c.UserID,
+		Type:             c.Type,
+		FCMToken:         c.FCMToken,
+		TimestampCreated: time.UnixMilli(c.TimestampCreated),
+		AgentModel:       c.AgentModel,
+		AgentVersion:     c.AgentVersion,
+	}
+}
+
+func DecodeClient(r *sql.Rows) (Client, error) {
+	var data ClientDB
+	err := scan.RowStrict(&data, r)
+	if err != nil {
+		return Client{}, err
+	}
+	return data.Model(), nil
+}
+
+func DecodeClients(r *sql.Rows) ([]Client, error) {
+	var data []ClientDB
+	err := scan.RowsStrict(&data, r)
+	if err != nil {
+		return nil, err
+	}
+	return langext.ArrMap(data, func(v ClientDB) Client { return v.Model() }), nil
 }

server/api/models/user.go

@@ -3,6 +3,7 @@ package models
 import (
 	"database/sql"
 	"github.com/blockloop/scan"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
@@ -88,10 +89,19 @@ func (u UserDB) Model() User {
 }
 
 func DecodeUser(r *sql.Rows) (User, error) {
-	var udb UserDB
-	err := scan.RowStrict(&udb, r)
+	var data UserDB
+	err := scan.RowStrict(&data, r)
 	if err != nil {
 		return User{}, err
 	}
-	return udb.Model(), nil
+	return data.Model(), nil
+}
+
+func DecodeUsers(r *sql.Rows) ([]User, error) {
+	var data []UserDB
+	err := scan.RowsStrict(&data, r)
+	if err != nil {
+		return nil, err
+	}
+	return langext.ArrMap(data, func(v UserDB) User { return v.Model() }), nil
 }