Mikescher/SimpleCloudNotifier
1
0
Fork 0
Code Pull Requests Actions Releases Activity

Refactor models to use single struct per entity

Browse Source
This commit is contained in:
Mike Schwörer 2024-09-15 21:07:46 +02:00
parent 6d432b9de4
commit 527a659a1b
Signed by: Mikescher
GPG Key ID: D3C7172E0A70F8CF
41 changed files with 778 additions and 1576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
scnserver/api/handler/apiChannel.go
View File

@ -46,7 +46,7 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
Selector *string `json:"selector" form:"selector" enums:"owned,subscribed_any,all_any,subscribed,all"` Selector *string `json:"selector" form:"selector" enums:"owned,subscribed_any,all_any,subscribed,all"`
} }
type response struct { type response struct {
Channels []models.ChannelWithSubscriptionJSON `json:"channels"` Channels []models.ChannelWithSubscription `json:"channels"`
} }
var u uri var u uri
@ -65,15 +65,13 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
sel := strings.ToLower(langext.Coalesce(q.Selector, "owned")) sel := strings.ToLower(langext.Coalesce(q.Selector, "owned"))
var res []models.ChannelWithSubscriptionJSON
if sel == "owned" { if sel == "owned" {
channels, err := h.database.ListChannelsByOwner(ctx, u.UserID, u.UserID) channels, err := h.database.ListChannelsByOwner(ctx, u.UserID, u.UserID)
if err != nil { if err != nil {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err)
} }
res = langext.ArrMap(channels, func(v models.ChannelWithSubscription) models.ChannelWithSubscriptionJSON { return v.JSON(true) }) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, response{Channels: channels}, "INCLUDE_KEY"))
} else if sel == "subscribed_any" { } else if sel == "subscribed_any" {
@ -81,7 +79,7 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
if err != nil { if err != nil {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err)
} }
res = langext.ArrMap(channels, func(v models.ChannelWithSubscription) models.ChannelWithSubscriptionJSON { return v.JSON(false) }) return finishSuccess(ginext.JSON(http.StatusOK, response{Channels: channels}))
} else if sel == "all_any" { } else if sel == "all_any" {
@ -89,7 +87,7 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
if err != nil { if err != nil {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err)
} }
res = langext.ArrMap(channels, func(v models.ChannelWithSubscription) models.ChannelWithSubscriptionJSON { return v.JSON(false) }) return finishSuccess(ginext.JSON(http.StatusOK, response{Channels: channels}))
} else if sel == "subscribed" { } else if sel == "subscribed" {
@ -97,7 +95,7 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
if err != nil { if err != nil {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err)
} }
res = langext.ArrMap(channels, func(v models.ChannelWithSubscription) models.ChannelWithSubscriptionJSON { return v.JSON(false) }) return finishSuccess(ginext.JSON(http.StatusOK, response{Channels: channels}))
} else if sel == "all" { } else if sel == "all" {
@ -105,7 +103,7 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
if err != nil { if err != nil {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channels", err)
} }
res = langext.ArrMap(channels, func(v models.ChannelWithSubscription) models.ChannelWithSubscriptionJSON { return v.JSON(false) }) return finishSuccess(ginext.JSON(http.StatusOK, response{Channels: channels}))
} else { } else {
@ -113,8 +111,6 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
} }
return finishSuccess(ginext.JSON(http.StatusOK, response{Channels: res}))
}) })
} }
@ -127,7 +123,7 @@ func (h APIHandler) ListChannels(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param cid path string true "ChannelID" // @Param cid path string true "ChannelID"
// //
// @Success 200 {object} models.ChannelWithSubscriptionJSON // @Success 200 {object} models.ChannelWithSubscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "channel not found" // @Failure 404 {object} ginresp.apiError "channel not found"
@ -161,7 +157,7 @@ func (h APIHandler) GetChannel(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, channel.JSON(true))) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, channel, "INCLUDE_KEY"))
}) })
} }
@ -175,7 +171,7 @@ func (h APIHandler) GetChannel(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param post_body body handler.CreateChannel.body false " " // @Param post_body body handler.CreateChannel.body false " "
// //
// @Success 200 {object} models.ChannelWithSubscriptionJSON // @Success 200 {object} models.ChannelWithSubscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 409 {object} ginresp.apiError "channel already exists" // @Failure 409 {object} ginresp.apiError "channel already exists"
@ -258,11 +254,11 @@ func (h APIHandler) CreateChannel(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create subscription", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create subscription", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, channel.WithSubscription(langext.Ptr(sub)).JSON(true))) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, channel.WithSubscription(langext.Ptr(sub)), "INCLUDE_KEY"))
} else { } else {
return finishSuccess(ginext.JSON(http.StatusOK, channel.WithSubscription(nil).JSON(true))) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, channel.WithSubscription(nil), "INCLUDE_KEY"))
} }
@ -282,7 +278,7 @@ func (h APIHandler) CreateChannel(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param send_key body string false "Send `true` to create a new send_key" // @Param send_key body string false "Send `true` to create a new send_key"
// @Param display_name body string false "Change the cahnnel display-name (only chnages to lowercase/uppercase are allowed - internal_name must stay the same)" // @Param display_name body string false "Change the cahnnel display-name (only chnages to lowercase/uppercase are allowed - internal_name must stay the same)"
// //
// @Success 200 {object} models.ChannelWithSubscriptionJSON // @Success 200 {object} models.ChannelWithSubscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "channel not found" // @Failure 404 {object} ginresp.apiError "channel not found"
@ -381,7 +377,7 @@ func (h APIHandler) UpdateChannel(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query (updated) channel", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query (updated) channel", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, channel.JSON(true))) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, channel, "INCLUDE_KEY"))
}) })
} }
@ -419,9 +415,9 @@ func (h APIHandler) ListChannelMessages(pctx ginext.PreContext) ginext.HTTPRespo
Trimmed *bool `json:"trimmed" form:"trimmed"` Trimmed *bool `json:"trimmed" form:"trimmed"`
} }
type response struct { type response struct {
Messages []models.MessageJSON `json:"messages"` Messages []models.Message `json:"messages"`
NextPageToken string `json:"next_page_token"` NextPageToken string `json:"next_page_token"`
PageSize int `json:"page_size"` PageSize int `json:"page_size"`
} }
var u uri var u uri
@ -466,14 +462,12 @@ func (h APIHandler) ListChannelMessages(pctx ginext.PreContext) ginext.HTTPRespo
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query messages", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query messages", err)
} }
var res []models.MessageJSON
if trimmed { if trimmed {
res = langext.ArrMap(messages, func(v models.Message) models.MessageJSON { return v.TrimmedJSON() }) res := langext.ArrMap(messages, func(v models.Message) models.Message { return v.Trim() })
return finishSuccess(ginext.JSON(http.StatusOK, response{Messages: res, NextPageToken: npt.Token(), PageSize: pageSize}))
} else { } else {
res = langext.ArrMap(messages, func(v models.Message) models.MessageJSON { return v.FullJSON() }) return finishSuccess(ginext.JSON(http.StatusOK, response{Messages: messages, NextPageToken: npt.Token(), PageSize: pageSize}))
} }
return finishSuccess(ginext.JSON(http.StatusOK, response{Messages: res, NextPageToken: npt.Token(), PageSize: pageSize}))
}) })
} }

22
scnserver/api/handler/apiClient.go
View File

@ -31,7 +31,7 @@ func (h APIHandler) ListClients(pctx ginext.PreContext) ginext.HTTPResponse {
UserID models.UserID `uri:"uid" binding:"entityid"` UserID models.UserID `uri:"uid" binding:"entityid"`
} }
type response struct { type response struct {
Clients []models.ClientJSON `json:"clients"` Clients []models.Client `json:"clients"`
} }
var u uri var u uri
@ -52,9 +52,7 @@ func (h APIHandler) ListClients(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query clients", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query clients", err)
} }
res := langext.ArrMap(clients, func(v models.Client) models.ClientJSON { return v.JSON() }) return finishSuccess(ginext.JSON(http.StatusOK, response{Clients: clients}))
return finishSuccess(ginext.JSON(http.StatusOK, response{Clients: res}))
}) })
} }
@ -68,7 +66,7 @@ func (h APIHandler) ListClients(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param cid path string true "ClientID" // @Param cid path string true "ClientID"
// //
// @Success 200 {object} models.ClientJSON // @Success 200 {object} models.Client
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "client not found" // @Failure 404 {object} ginresp.apiError "client not found"
@ -102,7 +100,7 @@ func (h APIHandler) GetClient(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, client.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, client))
}) })
} }
@ -117,7 +115,7 @@ func (h APIHandler) GetClient(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param post_body body handler.AddClient.body false " " // @Param post_body body handler.AddClient.body false " "
// //
// @Success 200 {object} models.ClientJSON // @Success 200 {object} models.Client
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 500 {object} ginresp.apiError "internal server error" // @Failure 500 {object} ginresp.apiError "internal server error"
@ -164,7 +162,7 @@ func (h APIHandler) AddClient(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create client in db", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create client in db", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, client.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, client))
}) })
} }
@ -178,7 +176,7 @@ func (h APIHandler) AddClient(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param cid path string true "ClientID" // @Param cid path string true "ClientID"
// //
// @Success 200 {object} models.ClientJSON // @Success 200 {object} models.Client
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "client not found" // @Failure 404 {object} ginresp.apiError "client not found"
@ -217,7 +215,7 @@ func (h APIHandler) DeleteClient(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, client.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, client))
}) })
} }
@ -235,7 +233,7 @@ func (h APIHandler) DeleteClient(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param clientname body string false "Change the clientname (send an empty string to clear it)" // @Param clientname body string false "Change the clientname (send an empty string to clear it)"
// @Param pro_token body string false "Send a verification of premium purchase" // @Param pro_token body string false "Send a verification of premium purchase"
// //
// @Success 200 {object} models.ClientJSON // @Success 200 {object} models.Client
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "client is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "client is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "client not found" // @Failure 404 {object} ginresp.apiError "client not found"
@ -322,7 +320,7 @@ func (h APIHandler) UpdateClient(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query (updated) client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query (updated) client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, client.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, client))
}) })
} }

26
scnserver/api/handler/apiKeyToken.go
View File

@ -33,7 +33,7 @@ func (h APIHandler) ListUserKeys(pctx ginext.PreContext) ginext.HTTPResponse {
UserID models.UserID `uri:"uid" binding:"entityid"` UserID models.UserID `uri:"uid" binding:"entityid"`
} }
type response struct { type response struct {
Keys []models.KeyTokenJSON `json:"keys"` Keys []models.KeyToken `json:"keys"`
} }
var u uri var u uri
@ -54,9 +54,7 @@ func (h APIHandler) ListUserKeys(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query keys", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query keys", err)
} }
res := langext.ArrMap(toks, func(v models.KeyToken) models.KeyTokenJSON { return v.JSON() }) return finishSuccess(ginext.JSON(http.StatusOK, response{Keys: toks}))
return finishSuccess(ginext.JSON(http.StatusOK, response{Keys: res}))
}) })
} }
@ -71,7 +69,7 @@ func (h APIHandler) ListUserKeys(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param kid path string true "TokenKeyID" // @Param kid path string true "TokenKeyID"
// //
// @Success 200 {object} models.KeyTokenWithTokenJSON // @Success 200 {object} models.KeyToken
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -109,7 +107,7 @@ func (h APIHandler) GetCurrentUserKey(pctx ginext.PreContext) ginext.HTTPRespons
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, keytoken.JSON().WithToken(keytoken.Token))) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, keytoken, "INCLUDE_TOKEN"))
}) })
} }
@ -124,7 +122,7 @@ func (h APIHandler) GetCurrentUserKey(pctx ginext.PreContext) ginext.HTTPRespons
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param kid path string true "TokenKeyID" // @Param kid path string true "TokenKeyID"
// //
// @Success 200 {object} models.KeyTokenJSON // @Success 200 {object} models.KeyToken
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -158,7 +156,7 @@ func (h APIHandler) GetUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, keytoken.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, keytoken))
}) })
} }
@ -174,7 +172,7 @@ func (h APIHandler) GetUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param post_body body handler.UpdateUserKey.body false " " // @Param post_body body handler.UpdateUserKey.body false " "
// //
// @Success 200 {object} models.KeyTokenJSON // @Success 200 {object} models.KeyToken
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -260,7 +258,7 @@ func (h APIHandler) UpdateUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
keytoken.Channels = *b.Channels keytoken.Channels = *b.Channels
} }
return finishSuccess(ginext.JSON(http.StatusOK, keytoken.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, keytoken))
}) })
} }
@ -275,7 +273,7 @@ func (h APIHandler) UpdateUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param post_body body handler.CreateUserKey.body false " " // @Param post_body body handler.CreateUserKey.body false " "
// //
// @Success 200 {object} models.KeyTokenJSON // @Success 200 {object} models.KeyToken
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -333,7 +331,7 @@ func (h APIHandler) CreateUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create keytoken in db", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create keytoken in db", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, keytok.JSON().WithToken(token))) return finishSuccess(ginext.JSONWithFilter(http.StatusOK, keytok, "INCLUDE_TOKEN"))
}) })
} }
@ -348,7 +346,7 @@ func (h APIHandler) CreateUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param kid path string true "TokenKeyID" // @Param kid path string true "TokenKeyID"
// //
// @Success 200 {object} models.KeyTokenJSON // @Success 200 {object} models.KeyToken
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -391,7 +389,7 @@ func (h APIHandler) DeleteUserKey(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, client.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, client))
}) })
} }

26
scnserver/api/handler/apiMessage.go
View File

@ -50,9 +50,9 @@ func (h APIHandler) ListMessages(pctx ginext.PreContext) ginext.HTTPResponse {
KeyTokens []string `json:"used_key" form:"used_key"` KeyTokens []string `json:"used_key" form:"used_key"`
} }
type response struct { type response struct {
Messages []models.MessageJSON `json:"messages"` Messages []models.Message `json:"messages"`
NextPageToken string `json:"next_page_token"` NextPageToken string `json:"next_page_token"`
PageSize int `json:"page_size"` PageSize int `json:"page_size"`
} }
var q query var q query
@ -151,15 +151,13 @@ func (h APIHandler) ListMessages(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query messages", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query messages", err)
} }
var res []models.MessageJSON
if trimmed { if trimmed {
res = langext.ArrMap(messages, func(v models.Message) models.MessageJSON { return v.TrimmedJSON() }) res := langext.ArrMap(messages, func(v models.Message) models.Message { return v.PreMarshal().Trim() })
return finishSuccess(ginext.JSON(http.StatusOK, response{Messages: res, NextPageToken: npt.Token(), PageSize: pageSize}))
} else { } else {
res = langext.ArrMap(messages, func(v models.Message) models.MessageJSON { return v.FullJSON() }) res := langext.ArrMap(messages, func(v models.Message) models.Message { return v.PreMarshal() })
return finishSuccess(ginext.JSON(http.StatusOK, response{Messages: res, NextPageToken: npt.Token(), PageSize: pageSize}))
} }
return finishSuccess(ginext.JSON(http.StatusOK, response{Messages: res, NextPageToken: npt.Token(), PageSize: pageSize}))
}) })
} }
@ -174,7 +172,7 @@ func (h APIHandler) ListMessages(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param mid path string true "MessageID" // @Param mid path string true "MessageID"
// //
// @Success 200 {object} models.MessageJSON // @Success 200 {object} models.Message
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -211,7 +209,7 @@ func (h APIHandler) GetMessage(pctx ginext.PreContext) ginext.HTTPResponse {
// or we subscribe (+confirmed) to the channel and have read/admin key // or we subscribe (+confirmed) to the channel and have read/admin key
if ctx.CheckPermissionMessageRead(msg) { if ctx.CheckPermissionMessageRead(msg) {
return finishSuccess(ginext.JSON(http.StatusOK, msg.FullJSON())) return finishSuccess(ginext.JSON(http.StatusOK, msg.PreMarshal()))
} }
if uid := ctx.GetPermissionUserID(); uid != nil && ctx.CheckPermissionUserRead(*uid) == nil { if uid := ctx.GetPermissionUserID(); uid != nil && ctx.CheckPermissionUserRead(*uid) == nil {
@ -229,7 +227,7 @@ func (h APIHandler) GetMessage(pctx ginext.PreContext) ginext.HTTPResponse {
} }
// => perm okay // => perm okay
return finishSuccess(ginext.JSON(http.StatusOK, msg.FullJSON())) return finishSuccess(ginext.JSON(http.StatusOK, msg.PreMarshal()))
} }
return ginresp.APIError(g, 401, apierr.USER_AUTH_FAILED, "You are not authorized for this action", nil) return ginresp.APIError(g, 401, apierr.USER_AUTH_FAILED, "You are not authorized for this action", nil)
@ -246,7 +244,7 @@ func (h APIHandler) GetMessage(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param mid path string true "MessageID" // @Param mid path string true "MessageID"
// //
// @Success 200 {object} models.MessageJSON // @Success 200 {object} models.Message
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -293,7 +291,7 @@ func (h APIHandler) DeleteMessage(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to cancel deliveries", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to cancel deliveries", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, msg.FullJSON())) return finishSuccess(ginext.JSON(http.StatusOK, msg.PreMarshal()))
}) })
} }

10
scnserver/api/handler/apiPreview.go
View File

@ -19,7 +19,7 @@ import (
// //
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// //
// @Success 200 {object} models.UserPreviewJSON // @Success 200 {object} models.UserPreview
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "user not found" // @Failure 404 {object} ginresp.apiError "user not found"
@ -65,7 +65,7 @@ func (h APIHandler) GetUserPreview(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param cid path string true "ChannelID" // @Param cid path string true "ChannelID"
// //
// @Success 200 {object} models.ChannelPreviewJSON // @Success 200 {object} models.ChannelPreview
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "channel not found" // @Failure 404 {object} ginresp.apiError "channel not found"
@ -98,7 +98,7 @@ func (h APIHandler) GetChannelPreview(pctx ginext.PreContext) ginext.HTTPRespons
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, channel.JSONPreview())) return finishSuccess(ginext.JSON(http.StatusOK, channel.Preview()))
}) })
} }
@ -111,7 +111,7 @@ func (h APIHandler) GetChannelPreview(pctx ginext.PreContext) ginext.HTTPRespons
// //
// @Param kid path string true "TokenKeyID" // @Param kid path string true "TokenKeyID"
// //
// @Success 200 {object} models.KeyTokenPreviewJSON // @Success 200 {object} models.KeyTokenPreview
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "message not found" // @Failure 404 {object} ginresp.apiError "message not found"
@ -144,7 +144,7 @@ func (h APIHandler) GetUserKeyPreview(pctx ginext.PreContext) ginext.HTTPRespons
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query client", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, keytoken.JSONPreview())) return finishSuccess(ginext.JSON(http.StatusOK, keytoken.Preview()))
}) })
} }

32
scnserver/api/handler/apiSubscription.go
View File

@ -60,7 +60,7 @@ func (h APIHandler) ListUserSubscriptions(pctx ginext.PreContext) ginext.HTTPRes
ChannelOwnerUserID *models.UserID `json:"channel_owner_user_id" form:"channel_owner_user_id"` ChannelOwnerUserID *models.UserID `json:"channel_owner_user_id" form:"channel_owner_user_id"`
} }
type response struct { type response struct {
Subscriptions []models.SubscriptionJSON `json:"subscriptions"` Subscriptions []models.Subscription `json:"subscriptions"`
} }
var u uri var u uri
@ -129,9 +129,7 @@ func (h APIHandler) ListUserSubscriptions(pctx ginext.PreContext) ginext.HTTPRes
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err)
} }
jsonres := langext.ArrMap(res, func(v models.Subscription) models.SubscriptionJSON { return v.JSON() }) return finishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: res}))
return finishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: jsonres}))
}) })
} }
@ -158,7 +156,7 @@ func (h APIHandler) ListChannelSubscriptions(pctx ginext.PreContext) ginext.HTTP
ChannelID models.ChannelID `uri:"cid" binding:"entityid"` ChannelID models.ChannelID `uri:"cid" binding:"entityid"`
} }
type response struct { type response struct {
Subscriptions []models.SubscriptionJSON `json:"subscriptions"` Subscriptions []models.Subscription `json:"subscriptions"`
} }
var u uri var u uri
@ -182,14 +180,12 @@ func (h APIHandler) ListChannelSubscriptions(pctx ginext.PreContext) ginext.HTTP
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
} }
clients, err := h.database.ListSubscriptions(ctx, models.SubscriptionFilter{AnyUserID: langext.Ptr(u.UserID), ChannelID: langext.Ptr([]models.ChannelID{u.ChannelID})}) subs, err := h.database.ListSubscriptions(ctx, models.SubscriptionFilter{AnyUserID: langext.Ptr(u.UserID), ChannelID: langext.Ptr([]models.ChannelID{u.ChannelID})})
if err != nil { if err != nil {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err)
} }
res := langext.ArrMap(clients, func(v models.Subscription) models.SubscriptionJSON { return v.JSON() }) return finishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: subs}))
return finishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: res}))
}) })
} }
@ -203,7 +199,7 @@ func (h APIHandler) ListChannelSubscriptions(pctx ginext.PreContext) ginext.HTTP
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param sid path string true "SubscriptionID" // @Param sid path string true "SubscriptionID"
// //
// @Success 200 {object} models.SubscriptionJSON // @Success 200 {object} models.Subscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "subscription not found" // @Failure 404 {object} ginresp.apiError "subscription not found"
@ -240,7 +236,7 @@ func (h APIHandler) GetSubscription(pctx ginext.PreContext) ginext.HTTPResponse
return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil) return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
} }
return finishSuccess(ginext.JSON(http.StatusOK, subscription.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, subscription))
}) })
} }
@ -254,7 +250,7 @@ func (h APIHandler) GetSubscription(pctx ginext.PreContext) ginext.HTTPResponse
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// @Param sid path string true "SubscriptionID" // @Param sid path string true "SubscriptionID"
// //
// @Success 200 {object} models.SubscriptionJSON // @Success 200 {object} models.Subscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "subscription not found" // @Failure 404 {object} ginresp.apiError "subscription not found"
@ -296,7 +292,7 @@ func (h APIHandler) CancelSubscription(pctx ginext.PreContext) ginext.HTTPRespon
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete subscription", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete subscription", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, subscription.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, subscription))
}) })
} }
@ -312,7 +308,7 @@ func (h APIHandler) CancelSubscription(pctx ginext.PreContext) ginext.HTTPRespon
// @Param query_data query handler.CreateSubscription.query false " " // @Param query_data query handler.CreateSubscription.query false " "
// @Param post_data body handler.CreateSubscription.body false " " // @Param post_data body handler.CreateSubscription.body false " "
// //
// @Success 200 {object} models.SubscriptionJSON // @Success 200 {object} models.Subscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 500 {object} ginresp.apiError "internal server error" // @Failure 500 {object} ginresp.apiError "internal server error"
@ -397,7 +393,7 @@ func (h APIHandler) CreateSubscription(pctx ginext.PreContext) ginext.HTTPRespon
existingSub.Confirmed = true existingSub.Confirmed = true
} }
return finishSuccess(ginext.JSON(http.StatusOK, existingSub.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, existingSub))
} }
sub, err := h.database.CreateSubscription(ctx, u.UserID, channel, channel.OwnerUserID == u.UserID) sub, err := h.database.CreateSubscription(ctx, u.UserID, channel, channel.OwnerUserID == u.UserID)
@ -405,7 +401,7 @@ func (h APIHandler) CreateSubscription(pctx ginext.PreContext) ginext.HTTPRespon
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create subscription", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create subscription", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, sub.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, sub))
}) })
} }
@ -420,7 +416,7 @@ func (h APIHandler) CreateSubscription(pctx ginext.PreContext) ginext.HTTPRespon
// @Param sid path string true "SubscriptionID" // @Param sid path string true "SubscriptionID"
// @Param post_data body handler.UpdateSubscription.body false " " // @Param post_data body handler.UpdateSubscription.body false " "
// //
// @Success 200 {object} models.SubscriptionJSON // @Success 200 {object} models.Subscription
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "subscription not found" // @Failure 404 {object} ginresp.apiError "subscription not found"
@ -478,7 +474,7 @@ func (h APIHandler) UpdateSubscription(pctx ginext.PreContext) ginext.HTTPRespon
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, subscription.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, subscription))
}) })
} }

14
scnserver/api/handler/apiUser.go
View File

@ -22,7 +22,7 @@ import (
// //
// @Param post_body body handler.CreateUser.body false " " // @Param post_body body handler.CreateUser.body false " "
// //
// @Success 200 {object} models.UserJSONWithClientsAndKeys // @Success 200 {object} models.UserWithClientsAndKeys
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 500 {object} ginresp.apiError "internal server error" // @Failure 500 {object} ginresp.apiError "internal server error"
// //
@ -120,7 +120,7 @@ func (h APIHandler) CreateUser(pctx ginext.PreContext) ginext.HTTPResponse {
log.Info().Msg(fmt.Sprintf("Sucessfully created new user %s (client: %v)", userobj.UserID, b.NoClient)) log.Info().Msg(fmt.Sprintf("Sucessfully created new user %s (client: %v)", userobj.UserID, b.NoClient))
if b.NoClient { if b.NoClient {
return finishSuccess(ginext.JSON(http.StatusOK, userobj.JSONWithClients(make([]models.Client, 0), adminKey, sendKey, readKey))) return finishSuccess(ginext.JSON(http.StatusOK, userobj.PreMarshal().WithClients(make([]models.Client, 0), adminKey, sendKey, readKey)))
} else { } else {
err := h.database.DeleteClientsByFCM(ctx, b.FCMToken) err := h.database.DeleteClientsByFCM(ctx, b.FCMToken)
if err != nil { if err != nil {
@ -132,7 +132,7 @@ func (h APIHandler) CreateUser(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create client in db", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create client in db", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, userobj.JSONWithClients([]models.Client{client}, adminKey, sendKey, readKey))) return finishSuccess(ginext.JSON(http.StatusOK, userobj.PreMarshal().WithClients([]models.Client{client}, adminKey, sendKey, readKey)))
} }
}) })
} }
@ -145,7 +145,7 @@ func (h APIHandler) CreateUser(pctx ginext.PreContext) ginext.HTTPResponse {
// //
// @Param uid path string true "UserID" // @Param uid path string true "UserID"
// //
// @Success 200 {object} models.UserJSON // @Success 200 {object} models.User
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "user not found" // @Failure 404 {object} ginresp.apiError "user not found"
@ -178,7 +178,7 @@ func (h APIHandler) GetUser(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query user", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query user", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, user.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, user.PreMarshal()))
}) })
@ -196,7 +196,7 @@ func (h APIHandler) GetUser(pctx ginext.PreContext) ginext.HTTPResponse {
// @Param username body string false "Change the username (send an empty string to clear it)" // @Param username body string false "Change the username (send an empty string to clear it)"
// @Param pro_token body string false "Send a verification of premium purchase" // @Param pro_token body string false "Send a verification of premium purchase"
// //
// @Success 200 {object} models.UserJSON // @Success 200 {object} models.User
// @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid" // @Failure 400 {object} ginresp.apiError "supplied values/parameters cannot be parsed / are invalid"
// @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions" // @Failure 401 {object} ginresp.apiError "user is not authorized / has missing permissions"
// @Failure 404 {object} ginresp.apiError "user not found" // @Failure 404 {object} ginresp.apiError "user not found"
@ -271,6 +271,6 @@ func (h APIHandler) UpdateUser(pctx ginext.PreContext) ginext.HTTPResponse {
return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query (updated) user", err) return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query (updated) user", err)
} }
return finishSuccess(ginext.JSON(http.StatusOK, user.JSON())) return finishSuccess(ginext.JSON(http.StatusOK, user.PreMarshal()))
}) })
} }

4
scnserver/db/impl/logs/database.go
View File

@ -5,6 +5,7 @@ import (
"blackforestbytes.com/simplecloudnotifier/db/dbtools" "blackforestbytes.com/simplecloudnotifier/db/dbtools"
"blackforestbytes.com/simplecloudnotifier/db/schema" "blackforestbytes.com/simplecloudnotifier/db/schema"
"blackforestbytes.com/simplecloudnotifier/db/simplectx" "blackforestbytes.com/simplecloudnotifier/db/simplectx"
"blackforestbytes.com/simplecloudnotifier/models"
"context" "context"
"database/sql" "database/sql"
"errors" "errors"
@ -51,7 +52,8 @@ func NewLogsDatabase(cfg server.Config) (*Database, error) {
xdb.SetConnMaxIdleTime(60 * time.Minute) xdb.SetConnMaxIdleTime(60 * time.Minute)
} }
qqdb := sq.NewDB(xdb, sq.DBOptions{}) qqdb := sq.NewDB(xdb, sq.DBOptions{RegisterDefaultConverter: langext.PTrue, RegisterCommentTrimmer: langext.PTrue})
models.RegisterConverter(qqdb)
if conf.EnableLogger { if conf.EnableLogger {
qqdb.AddListener(dbtools.DBLogger{}) qqdb.AddListener(dbtools.DBLogger{})

99
scnserver/db/impl/primary/channels.go
View File

@ -3,8 +3,6 @@ package primary
import ( import (
"blackforestbytes.com/simplecloudnotifier/db" "blackforestbytes.com/simplecloudnotifier/db"
"blackforestbytes.com/simplecloudnotifier/models" "blackforestbytes.com/simplecloudnotifier/models"
"database/sql"
"errors"
"gogs.mikescher.com/BlackForestBytes/goext/sq" "gogs.mikescher.com/BlackForestBytes/goext/sq"
"time" "time"
) )
@ -15,23 +13,7 @@ func (db *Database) GetChannelByName(ctx db.TxContext, userid models.UserID, cha
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM channels WHERE owner_user_id = :uid AND internal_name = :nam LIMIT 1", sq.PP{ return sq.QuerySingleOpt[models.Channel](ctx, tx, "SELECT * FROM channels WHERE owner_user_id = :uid AND internal_name = :nam LIMIT 1", sq.PP{"uid": userid, "nam": chanName}, sq.SModeExtended, sq.Safe)
"uid": userid,
"nam": chanName,
})
if err != nil {
return nil, err
}
channel, err := models.DecodeChannel(ctx, tx, rows)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return &channel, nil
} }
func (db *Database) GetChannelByID(ctx db.TxContext, chanid models.ChannelID) (*models.Channel, error) { func (db *Database) GetChannelByID(ctx db.TxContext, chanid models.ChannelID) (*models.Channel, error) {
@ -40,22 +22,7 @@ func (db *Database) GetChannelByID(ctx db.TxContext, chanid models.ChannelID) (*
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM channels WHERE channel_id = :cid LIMIT 1", sq.PP{ return sq.QuerySingleOpt[models.Channel](ctx, tx, "SELECT * FROM channels WHERE channel_id = :cid LIMIT 1", sq.PP{"cid": chanid}, sq.SModeExtended, sq.Safe)
"cid": chanid,
})
if err != nil {
return nil, err
}
channel, err := models.DecodeChannel(ctx, tx, rows)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return &channel, nil
} }
type CreateChanel struct { type CreateChanel struct {
@ -72,14 +39,14 @@ func (db *Database) CreateChannel(ctx db.TxContext, userid models.UserID, dispNa
return models.Channel{}, err return models.Channel{}, err
} }
entity := models.ChannelDB{ entity := models.Channel{
ChannelID: models.NewChannelID(), ChannelID: models.NewChannelID(),
OwnerUserID: userid, OwnerUserID: userid,
DisplayName: dispName, DisplayName: dispName,
InternalName: intName, InternalName: intName,
SubscribeKey: subscribeKey, SubscribeKey: subscribeKey,
DescriptionName: description, DescriptionName: description,
TimestampCreated: time2DB(time.Now()), TimestampCreated: models.NowSCNTime(),
TimestampLastSent: nil, TimestampLastSent: nil,
MessagesSent: 0, MessagesSent: 0,
} }
@ -89,7 +56,7 @@ func (db *Database) CreateChannel(ctx db.TxContext, userid models.UserID, dispNa
return models.Channel{}, err return models.Channel{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) ListChannelsByOwner(ctx db.TxContext, userid models.UserID, subUserID models.UserID) ([]models.ChannelWithSubscription, error) { func (db *Database) ListChannelsByOwner(ctx db.TxContext, userid models.UserID, subUserID models.UserID) ([]models.ChannelWithSubscription, error) {
@ -100,20 +67,14 @@ func (db *Database) ListChannelsByOwner(ctx db.TxContext, userid models.UserID,
order := " ORDER BY channels.timestamp_created ASC, channels.channel_id ASC " order := " ORDER BY channels.timestamp_created ASC, channels.channel_id ASC "
rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub ON channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid"+order, sq.PP{ sql := "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub ON channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid" + order
pp := sq.PP{
"ouid": userid, "ouid": userid,
"subuid": subUserID, "subuid": subUserID,
})
if err != nil {
return nil, err
} }
data, err := models.DecodeChannelsWithSubscription(ctx, tx, rows) return sq.QueryAll[models.ChannelWithSubscription](ctx, tx, sql, pp, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) ListChannelsBySubscriber(ctx db.TxContext, userid models.UserID, confirmed *bool) ([]models.ChannelWithSubscription, error) { func (db *Database) ListChannelsBySubscriber(ctx db.TxContext, userid models.UserID, confirmed *bool) ([]models.ChannelWithSubscription, error) {
@ -131,19 +92,13 @@ func (db *Database) ListChannelsBySubscriber(ctx db.TxContext, userid models.Use
order := " ORDER BY channels.timestamp_created ASC, channels.channel_id ASC " order := " ORDER BY channels.timestamp_created ASC, channels.channel_id ASC "
rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE sub.subscription_id IS NOT NULL "+confCond+order, sq.PP{ sql := "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE sub.subscription_id IS NOT NULL " + confCond + order
pp := sq.PP{
"subuid": userid, "subuid": userid,
})
if err != nil {
return nil, err
} }
data, err := models.DecodeChannelsWithSubscription(ctx, tx, rows) return sq.QueryAll[models.ChannelWithSubscription](ctx, tx, sql, pp, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) ListChannelsByAccess(ctx db.TxContext, userid models.UserID, confirmed *bool) ([]models.ChannelWithSubscription, error) { func (db *Database) ListChannelsByAccess(ctx db.TxContext, userid models.UserID, confirmed *bool) ([]models.ChannelWithSubscription, error) {
@ -161,20 +116,14 @@ func (db *Database) ListChannelsByAccess(ctx db.TxContext, userid models.UserID,
order := " ORDER BY channels.timestamp_created ASC, channels.channel_id ASC " order := " ORDER BY channels.timestamp_created ASC, channels.channel_id ASC "
rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid "+confCond+order, sq.PP{ sql := "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid " + confCond + order
pp := sq.PP{
"ouid": userid, "ouid": userid,
"subuid": userid, "subuid": userid,
})
if err != nil {
return nil, err
} }
data, err := models.DecodeChannelsWithSubscription(ctx, tx, rows) return sq.QueryAll[models.ChannelWithSubscription](ctx, tx, sql, pp, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) GetChannel(ctx db.TxContext, userid models.UserID, channelid models.ChannelID, enforceOwner bool) (models.ChannelWithSubscription, error) { func (db *Database) GetChannel(ctx db.TxContext, userid models.UserID, channelid models.ChannelID, enforceOwner bool) (models.ChannelWithSubscription, error) {
@ -198,17 +147,9 @@ func (db *Database) GetChannel(ctx db.TxContext, userid models.UserID, channelid
params["ouid"] = userid params["ouid"] = userid
} }
rows, err := tx.Query(ctx, "SELECT "+selectors+" FROM channels "+join+" WHERE "+cond+" LIMIT 1", params) sql := "SELECT " + selectors + " FROM channels " + join + " WHERE " + cond + " LIMIT 1"
if err != nil {
return models.ChannelWithSubscription{}, err
}
channel, err := models.DecodeChannelWithSubscription(ctx, tx, rows) return sq.QuerySingle[models.ChannelWithSubscription](ctx, tx, sql, params, sq.SModeExtended, sq.Safe)
if err != nil {
return models.ChannelWithSubscription{}, err
}
return channel, nil
} }
func (db *Database) IncChannelMessageCounter(ctx db.TxContext, channel *models.Channel) error { func (db *Database) IncChannelMessageCounter(ctx db.TxContext, channel *models.Channel) error {
@ -228,7 +169,7 @@ func (db *Database) IncChannelMessageCounter(ctx db.TxContext, channel *models.C
} }
channel.MessagesSent += 1 channel.MessagesSent += 1
channel.TimestampLastSent = &now channel.TimestampLastSent = models.NewSCNTimePtr(&now)
return nil return nil
} }

33
scnserver/db/impl/primary/clients.go
View File

@ -4,7 +4,6 @@ import (
"blackforestbytes.com/simplecloudnotifier/db" "blackforestbytes.com/simplecloudnotifier/db"
"blackforestbytes.com/simplecloudnotifier/models" "blackforestbytes.com/simplecloudnotifier/models"
"gogs.mikescher.com/BlackForestBytes/goext/sq" "gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
) )
func (db *Database) CreateClient(ctx db.TxContext, userid models.UserID, ctype models.ClientType, fcmToken string, agentModel string, agentVersion string, name *string) (models.Client, error) { func (db *Database) CreateClient(ctx db.TxContext, userid models.UserID, ctype models.ClientType, fcmToken string, agentModel string, agentVersion string, name *string) (models.Client, error) {
@ -13,12 +12,12 @@ func (db *Database) CreateClient(ctx db.TxContext, userid models.UserID, ctype m
return models.Client{}, err return models.Client{}, err
} }
entity := models.ClientDB{ entity := models.Client{
ClientID: models.NewClientID(), ClientID: models.NewClientID(),
UserID: userid, UserID: userid,
Type: ctype, Type: ctype,
FCMToken: fcmToken, FCMToken: fcmToken,
TimestampCreated: time2DB(time.Now()), TimestampCreated: models.NowSCNTime(),
AgentModel: agentModel, AgentModel: agentModel,
AgentVersion: agentVersion, AgentVersion: agentVersion,
Name: name, Name: name,
@ -29,7 +28,7 @@ func (db *Database) CreateClient(ctx db.TxContext, userid models.UserID, ctype m
return models.Client{}, err return models.Client{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) ClearFCMTokens(ctx db.TxContext, fcmtoken string) error { func (db *Database) ClearFCMTokens(ctx db.TxContext, fcmtoken string) error {
@ -52,17 +51,7 @@ func (db *Database) ListClients(ctx db.TxContext, userid models.UserID) ([]model
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM clients WHERE user_id = :uid ORDER BY clients.timestamp_created DESC, clients.client_id ASC", sq.PP{"uid": userid}) return sq.QueryAll[models.Client](ctx, tx, "SELECT * FROM clients WHERE user_id = :uid ORDER BY clients.timestamp_created DESC, clients.client_id ASC", sq.PP{"uid": userid}, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
data, err := models.DecodeClients(ctx, tx, rows)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) GetClient(ctx db.TxContext, userid models.UserID, clientid models.ClientID) (models.Client, error) { func (db *Database) GetClient(ctx db.TxContext, userid models.UserID, clientid models.ClientID) (models.Client, error) {
@ -71,20 +60,10 @@ func (db *Database) GetClient(ctx db.TxContext, userid models.UserID, clientid m
return models.Client{}, err return models.Client{}, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM clients WHERE user_id = :uid AND client_id = :cid LIMIT 1", sq.PP{ return sq.QuerySingle[models.Client](ctx, tx, "SELECT * FROM clients WHERE user_id = :uid AND client_id = :cid LIMIT 1", sq.PP{
"uid": userid, "uid": userid,
"cid": clientid, "cid": clientid,
}) }, sq.SModeExtended, sq.Safe)
if err != nil {
return models.Client{}, err
}
client, err := models.DecodeClient(ctx, tx, rows)
if err != nil {
return models.Client{}, err
}
return client, nil
} }
func (db *Database) DeleteClient(ctx db.TxContext, clientid models.ClientID) error { func (db *Database) DeleteClient(ctx db.TxContext, clientid models.ClientID) error {

4
scnserver/db/impl/primary/database.go
View File

@ -5,6 +5,7 @@ import (
"blackforestbytes.com/simplecloudnotifier/db/dbtools" "blackforestbytes.com/simplecloudnotifier/db/dbtools"
"blackforestbytes.com/simplecloudnotifier/db/schema" "blackforestbytes.com/simplecloudnotifier/db/schema"
"blackforestbytes.com/simplecloudnotifier/db/simplectx" "blackforestbytes.com/simplecloudnotifier/db/simplectx"
"blackforestbytes.com/simplecloudnotifier/models"
"context" "context"
"database/sql" "database/sql"
"errors" "errors"
@ -51,7 +52,8 @@ func NewPrimaryDatabase(cfg server.Config) (*Database, error) {
xdb.SetConnMaxIdleTime(60 * time.Minute) xdb.SetConnMaxIdleTime(60 * time.Minute)
} }
qqdb := sq.NewDB(xdb, sq.DBOptions{}) qqdb := sq.NewDB(xdb, sq.DBOptions{RegisterDefaultConverter: langext.PTrue, RegisterCommentTrimmer: langext.PTrue})
models.RegisterConverter(qqdb)
if conf.EnableLogger { if conf.EnableLogger {
qqdb.AddListener(dbtools.DBLogger{}) qqdb.AddListener(dbtools.DBLogger{})

30
scnserver/db/impl/primary/deliveries.go
View File

@ -18,16 +18,16 @@ func (db *Database) CreateRetryDelivery(ctx db.TxContext, client models.Client,
now := time.Now() now := time.Now()
next := scn.NextDeliveryTimestamp(now) next := scn.NextDeliveryTimestamp(now)
entity := models.DeliveryDB{ entity := models.Delivery{
DeliveryID: models.NewDeliveryID(), DeliveryID: models.NewDeliveryID(),
MessageID: msg.MessageID, MessageID: msg.MessageID,
ReceiverUserID: client.UserID, ReceiverUserID: client.UserID,
ReceiverClientID: client.ClientID, ReceiverClientID: client.ClientID,
TimestampCreated: time2DB(now), TimestampCreated: models.NewSCNTime(now),
TimestampFinalized: nil, TimestampFinalized: nil,
Status: models.DeliveryStatusRetry, Status: models.DeliveryStatusRetry,
RetryCount: 0, RetryCount: 0,
NextDelivery: langext.Ptr(time2DB(next)), NextDelivery: models.NewSCNTimePtr(&next),
FCMMessageID: nil, FCMMessageID: nil,
} }
@ -36,7 +36,7 @@ func (db *Database) CreateRetryDelivery(ctx db.TxContext, client models.Client,
return models.Delivery{}, err return models.Delivery{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) CreateSuccessDelivery(ctx db.TxContext, client models.Client, msg models.Message, fcmDelivID string) (models.Delivery, error) { func (db *Database) CreateSuccessDelivery(ctx db.TxContext, client models.Client, msg models.Message, fcmDelivID string) (models.Delivery, error) {
@ -47,13 +47,13 @@ func (db *Database) CreateSuccessDelivery(ctx db.TxContext, client models.Client
now := time.Now() now := time.Now()
entity := models.DeliveryDB{ entity := models.Delivery{
DeliveryID: models.NewDeliveryID(), DeliveryID: models.NewDeliveryID(),
MessageID: msg.MessageID, MessageID: msg.MessageID,
ReceiverUserID: client.UserID, ReceiverUserID: client.UserID,
ReceiverClientID: client.ClientID, ReceiverClientID: client.ClientID,
TimestampCreated: time2DB(now), TimestampCreated: models.NewSCNTime(now),
TimestampFinalized: langext.Ptr(time2DB(now)), TimestampFinalized: models.NewSCNTimePtr(&now),
Status: models.DeliveryStatusSuccess, Status: models.DeliveryStatusSuccess,
RetryCount: 0, RetryCount: 0,
NextDelivery: nil, NextDelivery: nil,
@ -65,7 +65,7 @@ func (db *Database) CreateSuccessDelivery(ctx db.TxContext, client models.Client
return models.Delivery{}, err return models.Delivery{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) ListRetrieableDeliveries(ctx db.TxContext, pageSize int) ([]models.Delivery, error) { func (db *Database) ListRetrieableDeliveries(ctx db.TxContext, pageSize int) ([]models.Delivery, error) {
@ -74,20 +74,10 @@ func (db *Database) ListRetrieableDeliveries(ctx db.TxContext, pageSize int) ([]
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM deliveries WHERE status = 'RETRY' AND next_delivery < :next ORDER BY next_delivery ASC LIMIT :lim", sq.PP{ return sq.QueryAll[models.Delivery](ctx, tx, "SELECT * FROM deliveries WHERE status = 'RETRY' AND next_delivery < :next ORDER BY next_delivery ASC LIMIT :lim", sq.PP{
"next": time2DB(time.Now()), "next": time2DB(time.Now()),
"lim": pageSize, "lim": pageSize,
}) }, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
data, err := models.DecodeDeliveries(ctx, tx, rows)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) SetDeliverySuccess(ctx db.TxContext, delivery models.Delivery, fcmDelivID string) error { func (db *Database) SetDeliverySuccess(ctx db.TxContext, delivery models.Delivery, fcmDelivID string) error {

69
scnserver/db/impl/primary/keytokens.go
View File

@ -3,8 +3,6 @@ package primary
import ( import (
"blackforestbytes.com/simplecloudnotifier/db" "blackforestbytes.com/simplecloudnotifier/db"
"blackforestbytes.com/simplecloudnotifier/models" "blackforestbytes.com/simplecloudnotifier/models"
"database/sql"
"errors"
"gogs.mikescher.com/BlackForestBytes/goext/langext" "gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq" "gogs.mikescher.com/BlackForestBytes/goext/sq"
"strings" "strings"
@ -17,16 +15,16 @@ func (db *Database) CreateKeyToken(ctx db.TxContext, name string, owner models.U
return models.KeyToken{}, err return models.KeyToken{}, err
} }
entity := models.KeyTokenDB{ entity := models.KeyToken{
KeyTokenID: models.NewKeyTokenID(), KeyTokenID: models.NewKeyTokenID(),
Name: name, Name: name,
TimestampCreated: time2DB(time.Now()), TimestampCreated: models.NowSCNTime(),
TimestampLastUsed: nil, TimestampLastUsed: nil,
OwnerUserID: owner, OwnerUserID: owner,
AllChannels: allChannels, AllChannels: allChannels,
Channels: strings.Join(langext.ArrMap(channels, func(v models.ChannelID) string { return v.String() }), ";"), Channels: channels,
Token: token, Token: token,
Permissions: permissions.String(), Permissions: permissions,
MessagesSent: 0, MessagesSent: 0,
} }
@ -35,7 +33,7 @@ func (db *Database) CreateKeyToken(ctx db.TxContext, name string, owner models.U
return models.KeyToken{}, err return models.KeyToken{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) ListKeyTokens(ctx db.TxContext, ownerID models.UserID) ([]models.KeyToken, error) { func (db *Database) ListKeyTokens(ctx db.TxContext, ownerID models.UserID) ([]models.KeyToken, error) {
@ -44,17 +42,7 @@ func (db *Database) ListKeyTokens(ctx db.TxContext, ownerID models.UserID) ([]mo
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM keytokens WHERE owner_user_id = :uid ORDER BY keytokens.timestamp_created DESC, keytokens.keytoken_id ASC", sq.PP{"uid": ownerID}) return sq.QueryAll[models.KeyToken](ctx, tx, "SELECT * FROM keytokens WHERE owner_user_id = :uid ORDER BY keytokens.timestamp_created DESC, keytokens.keytoken_id ASC", sq.PP{"uid": ownerID}, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
data, err := models.DecodeKeyTokens(ctx, tx, rows)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) GetKeyToken(ctx db.TxContext, userid models.UserID, keyTokenid models.KeyTokenID) (models.KeyToken, error) { func (db *Database) GetKeyToken(ctx db.TxContext, userid models.UserID, keyTokenid models.KeyTokenID) (models.KeyToken, error) {
@ -63,20 +51,10 @@ func (db *Database) GetKeyToken(ctx db.TxContext, userid models.UserID, keyToken
return models.KeyToken{}, err return models.KeyToken{}, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM keytokens WHERE owner_user_id = :uid AND keytoken_id = :cid LIMIT 1", sq.PP{ return sq.QuerySingle[models.KeyToken](ctx, tx, "SELECT * FROM keytokens WHERE owner_user_id = :uid AND keytoken_id = :cid LIMIT 1", sq.PP{
"uid": userid, "uid": userid,
"cid": keyTokenid, "cid": keyTokenid,
}) }, sq.SModeExtended, sq.Safe)
if err != nil {
return models.KeyToken{}, err
}
keyToken, err := models.DecodeKeyToken(ctx, tx, rows)
if err != nil {
return models.KeyToken{}, err
}
return keyToken, nil
} }
func (db *Database) GetKeyTokenByID(ctx db.TxContext, keyTokenid models.KeyTokenID) (models.KeyToken, error) { func (db *Database) GetKeyTokenByID(ctx db.TxContext, keyTokenid models.KeyTokenID) (models.KeyToken, error) {
@ -85,19 +63,7 @@ func (db *Database) GetKeyTokenByID(ctx db.TxContext, keyTokenid models.KeyToken
return models.KeyToken{}, err return models.KeyToken{}, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM keytokens WHERE keytoken_id = :cid LIMIT 1", sq.PP{ return sq.QuerySingle[models.KeyToken](ctx, tx, "SELECT * FROM keytokens WHERE keytoken_id = :cid LIMIT 1", sq.PP{"cid": keyTokenid}, sq.SModeExtended, sq.Safe)
"cid": keyTokenid,
})
if err != nil {
return models.KeyToken{}, err
}
keyToken, err := models.DecodeKeyToken(ctx, tx, rows)
if err != nil {
return models.KeyToken{}, err
}
return keyToken, nil
} }
func (db *Database) GetKeyTokenByToken(ctx db.TxContext, key string) (*models.KeyToken, error) { func (db *Database) GetKeyTokenByToken(ctx db.TxContext, key string) (*models.KeyToken, error) {
@ -106,20 +72,7 @@ func (db *Database) GetKeyTokenByToken(ctx db.TxContext, key string) (*models.Ke
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM keytokens WHERE token = :key LIMIT 1", sq.PP{"key": key}) return sq.QuerySingleOpt[models.KeyToken](ctx, tx, "SELECT * FROM keytokens WHERE token = :key LIMIT 1", sq.PP{"key": key}, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
user, err := models.DecodeKeyToken(ctx, tx, rows)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return &user, nil
} }
func (db *Database) DeleteKeyToken(ctx db.TxContext, keyTokenid models.KeyTokenID) error { func (db *Database) DeleteKeyToken(ctx db.TxContext, keyTokenid models.KeyTokenID) error {
@ -220,7 +173,7 @@ func (db *Database) IncKeyTokenMessageCounter(ctx db.TxContext, keyToken *models
return err return err
} }
keyToken.TimestampLastUsed = &now keyToken.TimestampLastUsed = models.NewSCNTimePtr(&now)
keyToken.MessagesSent += 1 keyToken.MessagesSent += 1
return nil return nil

46
scnserver/db/impl/primary/messages.go
View File

@ -4,7 +4,6 @@ import (
"blackforestbytes.com/simplecloudnotifier/db" "blackforestbytes.com/simplecloudnotifier/db"
ct "blackforestbytes.com/simplecloudnotifier/db/cursortoken" ct "blackforestbytes.com/simplecloudnotifier/db/cursortoken"
"blackforestbytes.com/simplecloudnotifier/models" "blackforestbytes.com/simplecloudnotifier/models"
"database/sql"
"errors" "errors"
"gogs.mikescher.com/BlackForestBytes/goext/sq" "gogs.mikescher.com/BlackForestBytes/goext/sq"
"time" "time"
@ -16,20 +15,7 @@ func (db *Database) GetMessageByUserMessageID(ctx db.TxContext, usrMsgId string)
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM messages WHERE usr_message_id = :umid LIMIT 1", sq.PP{"umid": usrMsgId}) return sq.QuerySingleOpt[models.Message](ctx, tx, "SELECT * FROM messages WHERE usr_message_id = :umid LIMIT 1", sq.PP{"umid": usrMsgId}, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
msg, err := models.DecodeMessage(ctx, tx, rows)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return &msg, nil
} }
func (db *Database) GetMessage(ctx db.TxContext, scnMessageID models.MessageID, allowDeleted bool) (models.Message, error) { func (db *Database) GetMessage(ctx db.TxContext, scnMessageID models.MessageID, allowDeleted bool) (models.Message, error) {
@ -45,17 +31,7 @@ func (db *Database) GetMessage(ctx db.TxContext, scnMessageID models.MessageID,
sqlcmd = "SELECT * FROM messages WHERE message_id = :mid AND deleted=0 LIMIT 1" sqlcmd = "SELECT * FROM messages WHERE message_id = :mid AND deleted=0 LIMIT 1"
} }
rows, err := tx.Query(ctx, sqlcmd, sq.PP{"mid": scnMessageID}) return sq.QuerySingle[models.Message](ctx, tx, sqlcmd, sq.PP{"mid": scnMessageID}, sq.SModeExtended, sq.Safe)
if err != nil {
return models.Message{}, err
}
msg, err := models.DecodeMessage(ctx, tx, rows)
if err != nil {
return models.Message{}, err
}
return msg, nil
} }
func (db *Database) CreateMessage(ctx db.TxContext, senderUserID models.UserID, channel models.Channel, timestampSend *time.Time, title string, content *string, priority int, userMsgId *string, senderIP string, senderName *string, usedKeyID models.KeyTokenID) (models.Message, error) { func (db *Database) CreateMessage(ctx db.TxContext, senderUserID models.UserID, channel models.Channel, timestampSend *time.Time, title string, content *string, priority int, userMsgId *string, senderIP string, senderName *string, usedKeyID models.KeyTokenID) (models.Message, error) {
@ -64,21 +40,22 @@ func (db *Database) CreateMessage(ctx db.TxContext, senderUserID models.UserID,
return models.Message{}, err return models.Message{}, err
} }
entity := models.MessageDB{ entity := models.Message{
MessageID: models.NewMessageID(), MessageID: models.NewMessageID(),
SenderUserID: senderUserID, SenderUserID: senderUserID,
ChannelInternalName: channel.InternalName, ChannelInternalName: channel.InternalName,
ChannelID: channel.ChannelID, ChannelID: channel.ChannelID,
SenderIP: senderIP, SenderIP: senderIP,
SenderName: senderName, SenderName: senderName,
TimestampReal: time2DB(time.Now()), TimestampReal: models.NowSCNTime(),
TimestampClient: time2DBOpt(timestampSend), TimestampClient: models.NewSCNTimePtr(timestampSend),
Title: title, Title: title,
Content: content, Content: content,
Priority: priority, Priority: priority,
UserMessageID: userMsgId, UserMessageID: userMsgId,
UsedKeyID: usedKeyID, UsedKeyID: usedKeyID,
Deleted: bool2DB(false), Deleted: false,
MessageExtra: models.MessageExtra{},
} }
_, err = sq.InsertSingle(ctx, tx, "messages", entity) _, err = sq.InsertSingle(ctx, tx, "messages", entity)
@ -86,7 +63,7 @@ func (db *Database) CreateMessage(ctx db.TxContext, senderUserID models.UserID,
return models.Message{}, err return models.Message{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) DeleteMessage(ctx db.TxContext, messageID models.MessageID) error { func (db *Database) DeleteMessage(ctx db.TxContext, messageID models.MessageID) error {
@ -133,12 +110,7 @@ func (db *Database) ListMessages(ctx db.TxContext, filter models.MessageFilter,
prepParams["tokts"] = inTok.Timestamp prepParams["tokts"] = inTok.Timestamp
prepParams["tokid"] = inTok.Id prepParams["tokid"] = inTok.Id
rows, err := tx.Query(ctx, sqlQuery, prepParams) data, err := sq.QueryAll[models.Message](ctx, tx, sqlQuery, prepParams, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, ct.CursorToken{}, err
}
data, err := models.DecodeMessages(ctx, tx, rows)
if err != nil { if err != nil {
return nil, ct.CursorToken{}, err return nil, ct.CursorToken{}, err
} }

52
scnserver/db/impl/primary/subscriptions.go
View File

@ -3,10 +3,7 @@ package primary
import ( import (
"blackforestbytes.com/simplecloudnotifier/db" "blackforestbytes.com/simplecloudnotifier/db"
"blackforestbytes.com/simplecloudnotifier/models" "blackforestbytes.com/simplecloudnotifier/models"
"database/sql"
"errors"
"gogs.mikescher.com/BlackForestBytes/goext/sq" "gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
) )
func (db *Database) CreateSubscription(ctx db.TxContext, subscriberUID models.UserID, channel models.Channel, confirmed bool) (models.Subscription, error) { func (db *Database) CreateSubscription(ctx db.TxContext, subscriberUID models.UserID, channel models.Channel, confirmed bool) (models.Subscription, error) {
@ -15,14 +12,14 @@ func (db *Database) CreateSubscription(ctx db.TxContext, subscriberUID models.Us
return models.Subscription{}, err return models.Subscription{}, err
} }
entity := models.SubscriptionDB{ entity := models.Subscription{
SubscriptionID: models.NewSubscriptionID(), SubscriptionID: models.NewSubscriptionID(),
SubscriberUserID: subscriberUID, SubscriberUserID: subscriberUID,
ChannelOwnerUserID: channel.OwnerUserID, ChannelOwnerUserID: channel.OwnerUserID,
ChannelID: channel.ChannelID, ChannelID: channel.ChannelID,
ChannelInternalName: channel.InternalName, ChannelInternalName: channel.InternalName,
TimestampCreated: time2DB(time.Now()), TimestampCreated: models.NowSCNTime(),
Confirmed: bool2DB(confirmed), Confirmed: confirmed,
} }
_, err = sq.InsertSingle(ctx, tx, "subscriptions", entity) _, err = sq.InsertSingle(ctx, tx, "subscriptions", entity)
@ -30,7 +27,7 @@ func (db *Database) CreateSubscription(ctx db.TxContext, subscriberUID models.Us
return models.Subscription{}, err return models.Subscription{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) ListSubscriptions(ctx db.TxContext, filter models.SubscriptionFilter) ([]models.Subscription, error) { func (db *Database) ListSubscriptions(ctx db.TxContext, filter models.SubscriptionFilter) ([]models.Subscription, error) {
@ -45,17 +42,7 @@ func (db *Database) ListSubscriptions(ctx db.TxContext, filter models.Subscripti
sqlQuery := "SELECT " + "subscriptions.*" + " FROM subscriptions " + filterJoin + " WHERE ( " + filterCond + " ) " + orderClause sqlQuery := "SELECT " + "subscriptions.*" + " FROM subscriptions " + filterJoin + " WHERE ( " + filterCond + " ) " + orderClause
rows, err := tx.Query(ctx, sqlQuery, prepParams) return sq.QueryAll[models.Subscription](ctx, tx, sqlQuery, prepParams, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
data, err := models.DecodeSubscriptions(ctx, tx, rows)
if err != nil {
return nil, err
}
return data, nil
} }
func (db *Database) GetSubscription(ctx db.TxContext, subid models.SubscriptionID) (models.Subscription, error) { func (db *Database) GetSubscription(ctx db.TxContext, subid models.SubscriptionID) (models.Subscription, error) {
@ -64,17 +51,7 @@ func (db *Database) GetSubscription(ctx db.TxContext, subid models.SubscriptionI
return models.Subscription{}, err return models.Subscription{}, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE subscription_id = :sid LIMIT 1", sq.PP{"sid": subid}) return sq.QuerySingle[models.Subscription](ctx, tx, "SELECT * FROM subscriptions WHERE subscription_id = :sid LIMIT 1", sq.PP{"sid": subid}, sq.SModeExtended, sq.Safe)
if err != nil {
return models.Subscription{}, err
}
sub, err := models.DecodeSubscription(ctx, tx, rows)
if err != nil {
return models.Subscription{}, err
}
return sub, nil
} }
func (db *Database) GetSubscriptionBySubscriber(ctx db.TxContext, subscriberId models.UserID, channelId models.ChannelID) (*models.Subscription, error) { func (db *Database) GetSubscriptionBySubscriber(ctx db.TxContext, subscriberId models.UserID, channelId models.ChannelID) (*models.Subscription, error) {
@ -83,23 +60,10 @@ func (db *Database) GetSubscriptionBySubscriber(ctx db.TxContext, subscriberId m
return nil, err return nil, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE subscriber_user_id = :suid AND channel_id = :cid LIMIT 1", sq.PP{ return sq.QuerySingleOpt[models.Subscription](ctx, tx, "SELECT * FROM subscriptions WHERE subscriber_user_id = :suid AND channel_id = :cid LIMIT 1", sq.PP{
"suid": subscriberId, "suid": subscriberId,
"cid": channelId, "cid": channelId,
}) }, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, err
}
user, err := models.DecodeSubscription(ctx, tx, rows)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return &user, nil
} }
func (db *Database) DeleteSubscription(ctx db.TxContext, subid models.SubscriptionID) error { func (db *Database) DeleteSubscription(ctx db.TxContext, subid models.SubscriptionID) error {

23
scnserver/db/impl/primary/users.go
View File

@ -15,10 +15,10 @@ func (db *Database) CreateUser(ctx db.TxContext, protoken *string, username *str
return models.User{}, err return models.User{}, err
} }
entity := models.UserDB{ entity := models.User{
UserID: models.NewUserID(), UserID: models.NewUserID(),
Username: username, Username: username,
TimestampCreated: time2DB(time.Now()), TimestampCreated: models.NowSCNTime(),
TimestampLastRead: nil, TimestampLastRead: nil,
TimestampLastSent: nil, TimestampLastSent: nil,
MessagesSent: 0, MessagesSent: 0,
@ -26,14 +26,17 @@ func (db *Database) CreateUser(ctx db.TxContext, protoken *string, username *str
QuotaUsedDay: nil, QuotaUsedDay: nil,
IsPro: protoken != nil, IsPro: protoken != nil,
ProToken: protoken, ProToken: protoken,
UserExtra: models.UserExtra{},
} }
entity.PreMarshal()
_, err = sq.InsertSingle(ctx, tx, "users", entity) _, err = sq.InsertSingle(ctx, tx, "users", entity)
if err != nil { if err != nil {
return models.User{}, err return models.User{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) ClearProTokens(ctx db.TxContext, protoken string) error { func (db *Database) ClearProTokens(ctx db.TxContext, protoken string) error {
@ -56,17 +59,7 @@ func (db *Database) GetUser(ctx db.TxContext, userid models.UserID) (models.User
return models.User{}, err return models.User{}, err
} }
rows, err := tx.Query(ctx, "SELECT * FROM users WHERE user_id = :uid LIMIT 1", sq.PP{"uid": userid}) return sq.QuerySingle[models.User](ctx, tx, "SELECT * FROM users WHERE user_id = :uid LIMIT 1", sq.PP{"uid": userid}, sq.SModeExtended, sq.Safe)
if err != nil {
return models.User{}, err
}
user, err := models.DecodeUser(ctx, tx, rows)
if err != nil {
return models.User{}, err
}
return user, nil
} }
func (db *Database) UpdateUserUsername(ctx db.TxContext, userid models.UserID, username *string) error { func (db *Database) UpdateUserUsername(ctx db.TxContext, userid models.UserID, username *string) error {
@ -127,7 +120,7 @@ func (db *Database) IncUserMessageCounter(ctx db.TxContext, user *models.User) e
return err return err
} }
user.TimestampLastSent = &now user.TimestampLastSent = models.NewSCNTimePtr(&now)
user.MessagesSent = user.MessagesSent + 1 user.MessagesSent = user.MessagesSent + 1
return nil return nil

4
scnserver/db/impl/requests/database.go
View File

@ -5,6 +5,7 @@ import (
"blackforestbytes.com/simplecloudnotifier/db/dbtools" "blackforestbytes.com/simplecloudnotifier/db/dbtools"
"blackforestbytes.com/simplecloudnotifier/db/schema" "blackforestbytes.com/simplecloudnotifier/db/schema"
"blackforestbytes.com/simplecloudnotifier/db/simplectx" "blackforestbytes.com/simplecloudnotifier/db/simplectx"
"blackforestbytes.com/simplecloudnotifier/models"
"context" "context"
"database/sql" "database/sql"
"errors" "errors"
@ -51,7 +52,8 @@ func NewRequestsDatabase(cfg server.Config) (*Database, error) {
xdb.SetConnMaxIdleTime(60 * time.Minute) xdb.SetConnMaxIdleTime(60 * time.Minute)
} }
qqdb := sq.NewDB(xdb, sq.DBOptions{}) qqdb := sq.NewDB(xdb, sq.DBOptions{RegisterDefaultConverter: langext.PTrue, RegisterCommentTrimmer: langext.PTrue})
models.RegisterConverter(qqdb)
if conf.EnableLogger { if conf.EnableLogger {
qqdb.AddListener(dbtools.DBLogger{}) qqdb.AddListener(dbtools.DBLogger{})

16
scnserver/db/impl/requests/requestlogs.go
View File

@ -8,18 +8,17 @@ import (
"time" "time"
) )
func (db *Database) InsertRequestLog(ctx context.Context, requestid models.RequestID, data models.RequestLog) (models.RequestLog, error) { func (db *Database) InsertRequestLog(ctx context.Context, requestid models.RequestID, entity models.RequestLog) (models.RequestLog, error) {
entity := data.DB()
entity.RequestID = requestid entity.RequestID = requestid
entity.TimestampCreated = time2DB(time.Now()) entity.TimestampCreated = models.NowSCNTime()
_, err := sq.InsertSingle(ctx, db.db, "requests", entity) _, err := sq.InsertSingle(ctx, db.db, "requests", entity)
if err != nil { if err != nil {
return models.RequestLog{}, err return models.RequestLog{}, err
} }
return entity.Model(), nil return entity, nil
} }
func (db *Database) Cleanup(ctx context.Context, count int, duration time.Duration) (int64, error) { func (db *Database) Cleanup(ctx context.Context, count int, duration time.Duration) (int64, error) {
@ -73,12 +72,7 @@ func (db *Database) ListRequestLogs(ctx context.Context, filter models.RequestLo
prepParams["tokts"] = inTok.Timestamp prepParams["tokts"] = inTok.Timestamp
prepParams["tokid"] = inTok.Id prepParams["tokid"] = inTok.Id
rows, err := db.db.Query(ctx, sqlQuery, prepParams) data, err := sq.QueryAll[models.RequestLog](ctx, db.db, sqlQuery, prepParams, sq.SModeExtended, sq.Safe)
if err != nil {
return nil, ct.CursorToken{}, err
}
data, err := models.DecodeRequestLogs(ctx, db.db, rows)
if err != nil { if err != nil {
return nil, ct.CursorToken{}, err return nil, ct.CursorToken{}, err
} }
@ -86,7 +80,7 @@ func (db *Database) ListRequestLogs(ctx context.Context, filter models.RequestLo
if pageSize == nil || len(data) <= *pageSize { if pageSize == nil || len(data) <= *pageSize {
return data, ct.End(), nil return data, ct.End(), nil
} else { } else {
outToken := ct.Normal(data[*pageSize-1].TimestampCreated, data[*pageSize-1].RequestID.String(), "DESC", filter.Hash()) outToken := ct.Normal(data[*pageSize-1].TimestampCreated.Time(), data[*pageSize-1].RequestID.String(), "DESC", filter.Hash())
return data[0:*pageSize], outToken, nil return data[0:*pageSize], outToken, nil
} }
} }

32
scnserver/go.mod
View File

@ -7,23 +7,23 @@ toolchain go1.22.3
require ( require (
github.com/gin-gonic/gin v1.10.0 github.com/gin-gonic/gin v1.10.0
github.com/glebarez/go-sqlite v1.22.0 github.com/glebarez/go-sqlite v1.22.0
github.com/go-playground/validator/v10 v10.22.0 github.com/go-playground/validator/v10 v10.22.1
github.com/go-sql-driver/mysql v1.8.1 github.com/go-sql-driver/mysql v1.8.1
github.com/jmoiron/sqlx v1.4.0 github.com/jmoiron/sqlx v1.4.0
github.com/mattn/go-sqlite3 v1.14.22 github.com/mattn/go-sqlite3 v1.14.22
github.com/rs/zerolog v1.33.0 github.com/rs/zerolog v1.33.0
gogs.mikescher.com/BlackForestBytes/goext v0.0.485 gogs.mikescher.com/BlackForestBytes/goext v0.0.512
gopkg.in/loremipsum.v1 v1.1.2 gopkg.in/loremipsum.v1 v1.1.2
) )
require ( require (
filippo.io/edwards25519 v1.1.0 // indirect filippo.io/edwards25519 v1.1.0 // indirect
github.com/bytedance/sonic v1.11.9 // indirect github.com/bytedance/sonic v1.12.2 // indirect
github.com/bytedance/sonic/loader v0.1.1 // indirect github.com/bytedance/sonic/loader v0.2.0 // indirect
github.com/cloudwego/base64x v0.1.4 // indirect github.com/cloudwego/base64x v0.1.4 // indirect
github.com/cloudwego/iasm v0.2.0 // indirect github.com/cloudwego/iasm v0.2.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect github.com/dustin/go-humanize v1.0.1 // indirect
github.com/gabriel-vasile/mimetype v1.4.4 // indirect github.com/gabriel-vasile/mimetype v1.4.5 // indirect
github.com/gin-contrib/sse v0.1.0 // indirect github.com/gin-contrib/sse v0.1.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect
@ -39,23 +39,23 @@ require (
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/montanaflynn/stats v0.7.1 // indirect github.com/montanaflynn/stats v0.7.1 // indirect
github.com/pelletier/go-toml/v2 v2.2.2 // indirect github.com/pelletier/go-toml/v2 v2.2.3 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
github.com/rs/xid v1.5.0 // indirect github.com/rs/xid v1.6.0 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.2.12 // indirect github.com/ugorji/go/codec v1.2.12 // indirect
github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect
github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/scram v1.1.2 // indirect
github.com/xdg-go/stringprep v1.0.4 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect
github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 // indirect github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
go.mongodb.org/mongo-driver v1.16.0 // indirect go.mongodb.org/mongo-driver v1.16.1 // indirect
golang.org/x/arch v0.8.0 // indirect golang.org/x/arch v0.10.0 // indirect
golang.org/x/crypto v0.25.0 // indirect golang.org/x/crypto v0.27.0 // indirect
golang.org/x/net v0.27.0 // indirect golang.org/x/net v0.29.0 // indirect
golang.org/x/sync v0.7.0 // indirect golang.org/x/sync v0.8.0 // indirect
golang.org/x/sys v0.22.0 // indirect golang.org/x/sys v0.25.0 // indirect
golang.org/x/term v0.22.0 // indirect golang.org/x/term v0.24.0 // indirect
golang.org/x/text v0.16.0 // indirect golang.org/x/text v0.18.0 // indirect
google.golang.org/protobuf v1.34.2 // indirect google.golang.org/protobuf v1.34.2 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect
modernc.org/libc v1.37.6 // indirect modernc.org/libc v1.37.6 // indirect

74
scnserver/go.sum
View File

@ -1,9 +1,10 @@
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/bytedance/sonic v1.11.9 h1:LFHENlIY/SLzDWverzdOvgMztTxcfcF+cqNsz9pK5zg= github.com/bytedance/sonic v1.12.2 h1:oaMFuRTpMHYLpCntGca65YWt5ny+wAceDERTkT2L9lg=
github.com/bytedance/sonic v1.11.9/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4= github.com/bytedance/sonic v1.12.2/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU= github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y= github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w= github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg= github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
@ -14,8 +15,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/gabriel-vasile/mimetype v1.4.4 h1:QjV6pZ7/XZ7ryI2KuyeEDE8wnh7fHP9YnQy+R0LnH8I= github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4=
github.com/gabriel-vasile/mimetype v1.4.4/go.mod h1:JwLei5XPtWdGiMFB5Pjle1oEeoSeEuJfJE+TtfvdB/s= github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4=
github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU= github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
@ -28,8 +29,8 @@ github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/o
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.22.0 h1:k6HsTZ0sTnROkhS//R0O+55JgM8C4Bx7ia+JlgcnOao= github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA=
github.com/go-playground/validator/v10 v10.22.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM= github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y= github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA= github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
@ -73,27 +74,26 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE= github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
@ -106,36 +106,31 @@ github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4= github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8= github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM= github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 h1:tBiBTKHnIjovYoLX/TPkcf+OjqqKGQrPtGT3Foz+Pgo= github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76/go.mod h1:SQliXeA7Dhkt//vS29v3zpbEwoa+zb2Cn5xj5uO4K5U= github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
go.mongodb.org/mongo-driver v1.16.0 h1:tpRsfBJMROVHKpdGyc1BBEzzjDUWjItxbVSZ8Ls4BQ4= go.mongodb.org/mongo-driver v1.16.1 h1:rIVLL3q0IHM39dvE+z2ulZLp9ENZKThVfuvN/IiN4l8=
go.mongodb.org/mongo-driver v1.16.0/go.mod h1:oB6AhJQvFQL4LEHyXi6aJzQJtBiTQHiAd83l0GdFaiw= go.mongodb.org/mongo-driver v1.16.1/go.mod h1:oB6AhJQvFQL4LEHyXi6aJzQJtBiTQHiAd83l0GdFaiw=
gogs.mikescher.com/BlackForestBytes/goext v0.0.482 h1:veU8oJdGZ9rjLB8sluagBduiBs3BbEDf60sGmEEv8lk= gogs.mikescher.com/BlackForestBytes/goext v0.0.511 h1:vAEhXdexKlLTNf/mGHzemp/4rzmv7n2jf5l4NK38tIw=
gogs.mikescher.com/BlackForestBytes/goext v0.0.482/go.mod h1:GxqLkJwPWQB5lVgWhmBPnx9RC+F0Dvi2xHKwfCmCQgM= gogs.mikescher.com/BlackForestBytes/goext v0.0.511/go.mod h1:9Q9EjraeE3yih7EXgBlnwLLJXWuRZNsl7s5TVTh3aOU=
gogs.mikescher.com/BlackForestBytes/goext v0.0.483 h1:fxhe3U5bpkv1SvSae7F/ixPp7DUiRxga4Zvg82iQSsI= gogs.mikescher.com/BlackForestBytes/goext v0.0.512 h1:cdLUi1bSnGujtx8/K0fPql142aOvUyNPt+8aWMKKDFk=
gogs.mikescher.com/BlackForestBytes/goext v0.0.483/go.mod h1:GxqLkJwPWQB5lVgWhmBPnx9RC+F0Dvi2xHKwfCmCQgM= gogs.mikescher.com/BlackForestBytes/goext v0.0.512/go.mod h1:9Q9EjraeE3yih7EXgBlnwLLJXWuRZNsl7s5TVTh3aOU=
gogs.mikescher.com/BlackForestBytes/goext v0.0.484 h1:fu60J83OBtnUkXCIt+dycHrin5OUmL1B46IY6GTQosw= golang.org/x/arch v0.10.0 h1:S3huipmSclq3PJMNe76NGwkBR504WFkQ5dhzWzP8ZW8=
gogs.mikescher.com/BlackForestBytes/goext v0.0.484/go.mod h1:GxqLkJwPWQB5lVgWhmBPnx9RC+F0Dvi2xHKwfCmCQgM= golang.org/x/arch v0.10.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
gogs.mikescher.com/BlackForestBytes/goext v0.0.485 h1:hjXxl7bwHkzYBpfsX81UZj929bKUDIoNFl0XQSvt4Qk=
gogs.mikescher.com/BlackForestBytes/goext v0.0.485/go.mod h1:GxqLkJwPWQB5lVgWhmBPnx9RC+F0Dvi2xHKwfCmCQgM=
golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30= golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A=
golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M= golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys= golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo=
golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE= golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@ -145,18 +140,18 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk= golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4= golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
@ -179,4 +174,3 @@ modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ= modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ=
modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0= modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0=
nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50= nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

6
scnserver/logic/request.go
View File

@ -185,9 +185,9 @@ func createRequestLog(g *gin.Context, t0 time.Time, ctr int, resp ginext.HTTPRes
RetryCount: int64(ctr), RetryCount: int64(ctr),
Panicked: panicstr != nil, Panicked: panicstr != nil,
PanicStr: panicstr, PanicStr: panicstr,
ProcessingTime: t1.Sub(t0), ProcessingTime: models.SCNDuration(t1.Sub(t0)),
TimestampStart: t0, TimestampStart: models.NewSCNTime(t0),
TimestampFinish: t1, TimestampFinish: models.NewSCNTime(t1),
} }
} }

168
scnserver/models/channel.go
View File

@ -1,37 +1,28 @@
package models package models
import (
"context"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
)
type Channel struct { type Channel struct {
ChannelID ChannelID ChannelID ChannelID `db:"channel_id" json:"channel_id"`
OwnerUserID UserID OwnerUserID UserID `db:"owner_user_id" json:"owner_user_id"`
InternalName string InternalName string `db:"internal_name" json:"internal_name"`
DisplayName string DisplayName string `db:"display_name" json:"display_name"`
DescriptionName *string DescriptionName *string `db:"description_name" json:"description_name"`
SubscribeKey string SubscribeKey string `db:"subscribe_key" json:"subscribe_key" jsonfilter:"INCLUDE_KEY"` // can be nil, depending on endpoint
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
TimestampLastSent *time.Time TimestampLastSent *SCNTime `db:"timestamp_lastsent" json:"timestamp_lastsent"`
MessagesSent int MessagesSent int `db:"messages_sent" json:"messages_sent"`
} }
func (c Channel) JSON(includeKey bool) ChannelJSON { type ChannelWithSubscription struct {
return ChannelJSON{ Channel
ChannelID: c.ChannelID, Subscription *Subscription `db:"sub" json:"subscription"`
OwnerUserID: c.OwnerUserID, }
InternalName: c.InternalName,
DisplayName: c.DisplayName, type ChannelPreview struct {
DescriptionName: c.DescriptionName, ChannelID ChannelID `json:"channel_id"`
SubscribeKey: langext.Conditional(includeKey, langext.Ptr(c.SubscribeKey), nil), OwnerUserID UserID `json:"owner_user_id"`
TimestampCreated: c.TimestampCreated.Format(time.RFC3339Nano), InternalName string `json:"internal_name"`
TimestampLastSent: timeOptFmt(c.TimestampLastSent, time.RFC3339Nano), DisplayName string `json:"display_name"`
MessagesSent: c.MessagesSent, DescriptionName *string `json:"description_name"`
}
} }
func (c Channel) WithSubscription(sub *Subscription) ChannelWithSubscription { func (c Channel) WithSubscription(sub *Subscription) ChannelWithSubscription {
@ -41,8 +32,8 @@ func (c Channel) WithSubscription(sub *Subscription) ChannelWithSubscription {
} }
} }
func (c Channel) JSONPreview() ChannelPreviewJSON { func (c Channel) Preview() ChannelPreview {
return ChannelPreviewJSON{ return ChannelPreview{
ChannelID: c.ChannelID, ChannelID: c.ChannelID,
OwnerUserID: c.OwnerUserID, OwnerUserID: c.OwnerUserID,
InternalName: c.InternalName, InternalName: c.InternalName,
@ -50,118 +41,3 @@ func (c Channel) JSONPreview() ChannelPreviewJSON {
DescriptionName: c.DescriptionName, DescriptionName: c.DescriptionName,
} }
} }
type ChannelWithSubscription struct {
Channel
Subscription *Subscription
}
func (c ChannelWithSubscription) JSON(includeChannelKey bool) ChannelWithSubscriptionJSON {
var sub *SubscriptionJSON = nil
if c.Subscription != nil {
sub = langext.Ptr(c.Subscription.JSON())
}
return ChannelWithSubscriptionJSON{
ChannelJSON: c.Channel.JSON(includeChannelKey),
Subscription: sub,
}
}
type ChannelJSON struct {
ChannelID ChannelID `json:"channel_id"`
OwnerUserID UserID `json:"owner_user_id"`
InternalName string `json:"internal_name"`
DisplayName string `json:"display_name"`
DescriptionName *string `json:"description_name"`
SubscribeKey *string `json:"subscribe_key"` // can be nil, depending on endpoint
TimestampCreated string `json:"timestamp_created"`
TimestampLastSent *string `json:"timestamp_lastsent"`
MessagesSent int `json:"messages_sent"`
}
type ChannelWithSubscriptionJSON struct {
ChannelJSON
Subscription *SubscriptionJSON `json:"subscription"`
}
type ChannelPreviewJSON struct {
ChannelID ChannelID `json:"channel_id"`
OwnerUserID UserID `json:"owner_user_id"`
InternalName string `json:"internal_name"`
DisplayName string `json:"display_name"`
DescriptionName *string `json:"description_name"`
}
type ChannelDB struct {
ChannelID ChannelID `db:"channel_id"`
OwnerUserID UserID `db:"owner_user_id"`
InternalName string `db:"internal_name"`
DisplayName string `db:"display_name"`
DescriptionName *string `db:"description_name"`
SubscribeKey string `db:"subscribe_key"`
TimestampCreated int64 `db:"timestamp_created"`
TimestampLastSent *int64 `db:"timestamp_lastsent"`
MessagesSent int `db:"messages_sent"`
}
func (c ChannelDB) Model() Channel {
return Channel{
ChannelID: c.ChannelID,
OwnerUserID: c.OwnerUserID,
InternalName: c.InternalName,
DisplayName: c.DisplayName,
DescriptionName: c.DescriptionName,
SubscribeKey: c.SubscribeKey,
TimestampCreated: timeFromMilli(c.TimestampCreated),
TimestampLastSent: timeOptFromMilli(c.TimestampLastSent),
MessagesSent: c.MessagesSent,
}
}
type ChannelWithSubscriptionDB struct {
ChannelDB
Subscription *SubscriptionDB `db:"sub"`
}
func (c ChannelWithSubscriptionDB) Model() ChannelWithSubscription {
var sub *Subscription = nil
if c.Subscription != nil {
sub = langext.Ptr(c.Subscription.Model())
}
return ChannelWithSubscription{
Channel: c.ChannelDB.Model(),
Subscription: sub,
}
}
func DecodeChannel(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (Channel, error) {
data, err := sq.ScanSingle[ChannelDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return Channel{}, err
}
return data.Model(), nil
}
func DecodeChannels(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]Channel, error) {
data, err := sq.ScanAll[ChannelDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v ChannelDB) Channel { return v.Model() }), nil
}
func DecodeChannelWithSubscription(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (ChannelWithSubscription, error) {
data, err := sq.ScanSingle[ChannelWithSubscriptionDB](ctx, q, r, sq.SModeExtended, sq.Safe, true)
if err != nil {
return ChannelWithSubscription{}, err
}
return data.Model(), nil
}
func DecodeChannelsWithSubscription(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]ChannelWithSubscription, error) {
data, err := sq.ScanAll[ChannelWithSubscriptionDB](ctx, q, r, sq.SModeExtended, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v ChannelWithSubscriptionDB) ChannelWithSubscription { return v.Model() }), nil
}

88
scnserver/models/client.go
View File

@ -1,13 +1,5 @@
package models package models
import (
"context"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
)
type ClientType string //@enum:type type ClientType string //@enum:type
const ( const (
@ -19,76 +11,12 @@ const (
) )
type Client struct { type Client struct {
ClientID ClientID ClientID ClientID `db:"client_id" json:"client_id"`
UserID UserID UserID UserID `db:"user_id" json:"user_id"`
Type ClientType Type ClientType `db:"type" json:"type"`
FCMToken string FCMToken string `db:"fcm_token" json:"fcm_token"`
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
AgentModel string AgentModel string `db:"agent_model" json:"agent_model"`
AgentVersion string AgentVersion string `db:"agent_version" json:"agent_version"`
Name *string Name *string `db:"name" json:"name"`
}
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,
Name: c.Name,
}
}
type ClientJSON struct {
ClientID ClientID `json:"client_id"`
UserID UserID `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"`
Name *string `json:"name"`
}
type ClientDB struct {
ClientID ClientID `db:"client_id"`
UserID UserID `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"`
Name *string `db:"name"`
}
func (c ClientDB) Model() Client {
return Client{
ClientID: c.ClientID,
UserID: c.UserID,
Type: c.Type,
FCMToken: c.FCMToken,
TimestampCreated: timeFromMilli(c.TimestampCreated),
AgentModel: c.AgentModel,
AgentVersion: c.AgentVersion,
Name: c.Name,
}
}
func DecodeClient(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (Client, error) {
data, err := sq.ScanSingle[ClientDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return Client{}, err
}
return data.Model(), nil
}
func DecodeClients(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]Client, error) {
data, err := sq.ScanAll[ClientDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v ClientDB) Client { return v.Model() }), nil
} }

100
scnserver/models/delivery.go
View File

@ -1,13 +1,5 @@
package models package models
import (
"context"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
)
type DeliveryStatus string //@enum:type type DeliveryStatus string //@enum:type
const ( const (
@ -17,90 +9,18 @@ const (
) )
type Delivery struct { type Delivery struct {
DeliveryID DeliveryID DeliveryID DeliveryID `db:"delivery_id" json:"delivery_id"`
MessageID MessageID MessageID MessageID `db:"message_id" json:"message_id"`
ReceiverUserID UserID ReceiverUserID UserID `db:"receiver_user_id" json:"receiver_user_id"`
ReceiverClientID ClientID ReceiverClientID ClientID `db:"receiver_client_id" json:"receiver_client_id"`
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
TimestampFinalized *time.Time TimestampFinalized *SCNTime `db:"timestamp_finalized" json:"timestamp_finalized"`
Status DeliveryStatus Status DeliveryStatus `db:"status" json:"status"`
RetryCount int RetryCount int `db:"retry_count" json:"retry_count"`
NextDelivery *time.Time NextDelivery *SCNTime `db:"next_delivery" json:"next_delivery"`
FCMMessageID *string FCMMessageID *string `db:"fcm_message_id" json:"fcm_message_id"`
}
func (d Delivery) JSON() DeliveryJSON {
return DeliveryJSON{
DeliveryID: d.DeliveryID,
MessageID: d.MessageID,
ReceiverUserID: d.ReceiverUserID,
ReceiverClientID: d.ReceiverClientID,
TimestampCreated: d.TimestampCreated.Format(time.RFC3339Nano),
TimestampFinalized: timeOptFmt(d.TimestampFinalized, time.RFC3339Nano),
Status: d.Status,
RetryCount: d.RetryCount,
NextDelivery: timeOptFmt(d.NextDelivery, time.RFC3339Nano),
FCMMessageID: d.FCMMessageID,
}
} }
func (d Delivery) MaxRetryCount() int { func (d Delivery) MaxRetryCount() int {
return 5 return 5
} }
type DeliveryJSON struct {
DeliveryID DeliveryID `json:"delivery_id"`
MessageID MessageID `json:"message_id"`
ReceiverUserID UserID `json:"receiver_user_id"`
ReceiverClientID ClientID `json:"receiver_client_id"`
TimestampCreated string `json:"timestamp_created"`
TimestampFinalized *string `json:"timestamp_finalized"`
Status DeliveryStatus `json:"status"`
RetryCount int `json:"retry_count"`
NextDelivery *string `json:"next_delivery"`
FCMMessageID *string `json:"fcm_message_id"`
}
type DeliveryDB struct {
DeliveryID DeliveryID `db:"delivery_id"`
MessageID MessageID `db:"message_id"`
ReceiverUserID UserID `db:"receiver_user_id"`
ReceiverClientID ClientID `db:"receiver_client_id"`
TimestampCreated int64 `db:"timestamp_created"`
TimestampFinalized *int64 `db:"timestamp_finalized"`
Status DeliveryStatus `db:"status"`
RetryCount int `db:"retry_count"`
NextDelivery *int64 `db:"next_delivery"`
FCMMessageID *string `db:"fcm_message_id"`
}
func (d DeliveryDB) Model() Delivery {
return Delivery{
DeliveryID: d.DeliveryID,
MessageID: d.MessageID,
ReceiverUserID: d.ReceiverUserID,
ReceiverClientID: d.ReceiverClientID,
TimestampCreated: timeFromMilli(d.TimestampCreated),
TimestampFinalized: timeOptFromMilli(d.TimestampFinalized),
Status: d.Status,
RetryCount: d.RetryCount,
NextDelivery: timeOptFromMilli(d.NextDelivery),
FCMMessageID: d.FCMMessageID,
}
}
func DecodeDelivery(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (Delivery, error) {
data, err := sq.ScanSingle[DeliveryDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return Delivery{}, err
}
return data.Model(), nil
}
func DecodeDeliveries(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]Delivery, error) {
data, err := sq.ScanAll[DeliveryDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v DeliveryDB) Delivery { return v.Model() }), nil
}

35
scnserver/models/duration.go Normal file
View File

@ -0,0 +1,35 @@
package models
import (
"encoding/json"
"gogs.mikescher.com/BlackForestBytes/goext/timeext"
"time"
)
type SCNDuration time.Duration
func (t SCNDuration) MarshalToDB(v SCNDuration) (int64, error) {
return v.Duration().Milliseconds(), nil
}
func (t SCNDuration) UnmarshalToModel(v int64) (SCNDuration, error) {
return SCNDuration(timeext.FromMilliseconds(v)), nil
}
func (t SCNDuration) Duration() time.Duration {
return time.Duration(t)
}
func (t *SCNDuration) UnmarshalJSON(data []byte) error {
flt := float64(0)
if err := json.Unmarshal(data, &flt); err != nil {
return err
}
d0 := timeext.FromSeconds(flt)
*t = SCNDuration(d0)
return nil
}
func (t SCNDuration) MarshalJSON() ([]byte, error) {
return json.Marshal(t.Duration().Seconds())
}

2
scnserver/models/enums_gen.go
View File

@ -5,7 +5,7 @@ package models
import "gogs.mikescher.com/BlackForestBytes/goext/langext" import "gogs.mikescher.com/BlackForestBytes/goext/langext"
import "gogs.mikescher.com/BlackForestBytes/goext/enums" import "gogs.mikescher.com/BlackForestBytes/goext/enums"
const ChecksumEnumGenerator = "ba14f2f5d0b0357f248dcbd12933de102c80f1e61be697a37ebb723609fc0c59" // GoExtVersion: 0.0.485 const ChecksumEnumGenerator = "8ffad0d7406eb7f17cbbfeff6fee6e6fa7156470203934ebd220c824e6e15e09" // GoExtVersion: 0.0.511
// ================================ ClientType ================================ // ================================ ClientType ================================
// //

2
scnserver/models/ids_gen.go
View File

@ -15,7 +15,7 @@ import "reflect"
import "regexp" import "regexp"
import "strings" import "strings"
const ChecksumCharsetIDGenerator = "ba14f2f5d0b0357f248dcbd12933de102c80f1e61be697a37ebb723609fc0c59" // GoExtVersion: 0.0.485 const ChecksumCharsetIDGenerator = "8ffad0d7406eb7f17cbbfeff6fee6e6fa7156470203934ebd220c824e6e15e09" // GoExtVersion: 0.0.511
const idlen = 24 const idlen = 24

162
scnserver/models/keytoken.go
View File

@ -1,12 +1,9 @@
package models package models
import ( import (
"context" "encoding/json"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext" "gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"strings" "strings"
"time"
) )
type TokenPerm string //@enum:type type TokenPerm string //@enum:type
@ -45,17 +42,53 @@ func ParseTokenPermissionList(input string) TokenPermissionList {
return r return r
} }
func (e TokenPermissionList) MarshalToDB(v TokenPermissionList) (string, error) {
return v.String(), nil
}
func (e TokenPermissionList) UnmarshalToModel(v string) (TokenPermissionList, error) {
return ParseTokenPermissionList(v), nil
}
func (t TokenPermissionList) MarshalJSON() ([]byte, error) {
return json.Marshal(t.String())
}
type ChannelIDArr []ChannelID
func (t ChannelIDArr) MarshalToDB(v ChannelIDArr) (string, error) {
return strings.Join(langext.ArrMap(v, func(v ChannelID) string { return v.String() }), ";"), nil
}
func (t ChannelIDArr) UnmarshalToModel(v string) (ChannelIDArr, error) {
channels := make([]ChannelID, 0)
if strings.TrimSpace(v) != "" {
channels = langext.ArrMap(strings.Split(v, ";"), func(v string) ChannelID { return ChannelID(v) })
}
return channels, nil
}
type KeyToken struct { type KeyToken struct {
KeyTokenID KeyTokenID KeyTokenID KeyTokenID `db:"keytoken_id" json:"keytoken_id"`
Name string Name string `db:"name" json:"name"`
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
TimestampLastUsed *time.Time TimestampLastUsed *SCNTime `db:"timestamp_lastused" json:"timestamp_lastused"`
OwnerUserID UserID OwnerUserID UserID `db:"owner_user_id" json:"owner_user_id"`
AllChannels bool AllChannels bool `db:"all_channels" json:"all_channels"`
Channels []ChannelID // can also be owned by other user (needs active subscription) Channels ChannelIDArr `db:"channels" json:"channels"`
Token string Token string `db:"token" json:"token" jsonfilter:"INCLUDE_TOKEN"`
Permissions TokenPermissionList Permissions TokenPermissionList `db:"permissions" json:"permissions"`
MessagesSent int MessagesSent int `db:"messages_sent" json:"messages_sent"`
}
type KeyTokenPreview struct {
KeyTokenID KeyTokenID `json:"keytoken_id"`
Name string `json:"name"`
OwnerUserID UserID `json:"owner_user_id"`
AllChannels bool `json:"all_channels"`
Channels []ChannelID `json:"channels"`
Permissions string `json:"permissions"`
} }
func (k KeyToken) IsUserRead(uid UserID) bool { func (k KeyToken) IsUserRead(uid UserID) bool {
@ -78,22 +111,8 @@ func (k KeyToken) IsChannelMessagesSend(c Channel) bool {
return (k.AllChannels == true || langext.InArray(c.ChannelID, k.Channels)) && k.OwnerUserID == c.OwnerUserID && k.Permissions.Any(PermAdmin, PermChannelSend) return (k.AllChannels == true || langext.InArray(c.ChannelID, k.Channels)) && k.OwnerUserID == c.OwnerUserID && k.Permissions.Any(PermAdmin, PermChannelSend)
} }
func (k KeyToken) JSON() KeyTokenJSON { func (k KeyToken) Preview() KeyTokenPreview {
return KeyTokenJSON{ return KeyTokenPreview{
KeyTokenID: k.KeyTokenID,
Name: k.Name,
TimestampCreated: k.TimestampCreated,
TimestampLastUsed: k.TimestampLastUsed,
OwnerUserID: k.OwnerUserID,
AllChannels: k.AllChannels,
Channels: k.Channels,
Permissions: k.Permissions.String(),
MessagesSent: k.MessagesSent,
}
}
func (k KeyToken) JSONPreview() KeyTokenPreviewJSON {
return KeyTokenPreviewJSON{
KeyTokenID: k.KeyTokenID, KeyTokenID: k.KeyTokenID,
Name: k.Name, Name: k.Name,
OwnerUserID: k.OwnerUserID, OwnerUserID: k.OwnerUserID,
@ -102,86 +121,3 @@ func (k KeyToken) JSONPreview() KeyTokenPreviewJSON {
Permissions: k.Permissions.String(), Permissions: k.Permissions.String(),
} }
} }
type KeyTokenJSON struct {
KeyTokenID KeyTokenID `json:"keytoken_id"`
Name string `json:"name"`
TimestampCreated time.Time `json:"timestamp_created"`
TimestampLastUsed *time.Time `json:"timestamp_lastused"`
OwnerUserID UserID `json:"owner_user_id"`
AllChannels bool `json:"all_channels"`
Channels []ChannelID `json:"channels"`
Permissions string `json:"permissions"`
MessagesSent int `json:"messages_sent"`
}
type KeyTokenWithTokenJSON struct {
KeyTokenJSON
Token string `json:"token"`
}
type KeyTokenPreviewJSON struct {
KeyTokenID KeyTokenID `json:"keytoken_id"`
Name string `json:"name"`
OwnerUserID UserID `json:"owner_user_id"`
AllChannels bool `json:"all_channels"`
Channels []ChannelID `json:"channels"`
Permissions string `json:"permissions"`
}
func (j KeyTokenJSON) WithToken(tok string) KeyTokenWithTokenJSON {
return KeyTokenWithTokenJSON{
KeyTokenJSON: j,
Token: tok,
}
}
type KeyTokenDB struct {
KeyTokenID KeyTokenID `db:"keytoken_id"`
Name string `db:"name"`
TimestampCreated int64 `db:"timestamp_created"`
TimestampLastUsed *int64 `db:"timestamp_lastused"`
OwnerUserID UserID `db:"owner_user_id"`
AllChannels bool `db:"all_channels"`
Channels string `db:"channels"`
Token string `db:"token"`
Permissions string `db:"permissions"`
MessagesSent int `db:"messages_sent"`
}
func (k KeyTokenDB) Model() KeyToken {
channels := make([]ChannelID, 0)
if strings.TrimSpace(k.Channels) != "" {
channels = langext.ArrMap(strings.Split(k.Channels, ";"), func(v string) ChannelID { return ChannelID(v) })
}
return KeyToken{
KeyTokenID: k.KeyTokenID,
Name: k.Name,
TimestampCreated: timeFromMilli(k.TimestampCreated),
TimestampLastUsed: timeOptFromMilli(k.TimestampLastUsed),
OwnerUserID: k.OwnerUserID,
AllChannels: k.AllChannels,
Channels: channels,
Token: k.Token,
Permissions: ParseTokenPermissionList(k.Permissions),
MessagesSent: k.MessagesSent,
}
}
func DecodeKeyToken(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (KeyToken, error) {
data, err := sq.ScanSingle[KeyTokenDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return KeyToken{}, err
}
return data.Model(), nil
}
func DecodeKeyTokens(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]KeyToken, error) {
data, err := sq.ScanAll[KeyTokenDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v KeyTokenDB) KeyToken { return v.Model() }), nil
}

148
scnserver/models/message.go
View File

@ -1,11 +1,8 @@
package models package models
import ( import (
"context"
"fmt" "fmt"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext" "gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time" "time"
) )
@ -15,60 +12,45 @@ const (
) )
type Message struct { type Message struct {
MessageID MessageID MessageID MessageID `db:"message_id" json:"message_id"`
SenderUserID UserID // user that sent the message (this is also the owner of the channel that contains it) SenderUserID UserID `db:"sender_user_id" json:"sender_user_id"` // user that sent the message (this is also the owner of the channel that contains it)
ChannelInternalName string ChannelInternalName string `db:"channel_internal_name" json:"channel_internal_name"`
ChannelID ChannelID ChannelID ChannelID `db:"channel_id" json:"channel_id"`
SenderName *string SenderName *string `db:"sender_name" json:"sender_name"`
SenderIP string SenderIP string `db:"sender_ip" json:"sender_ip"`
TimestampReal time.Time TimestampReal SCNTime `db:"timestamp_real" json:"-"`
TimestampClient *time.Time TimestampClient *SCNTime `db:"timestamp_client" json:"-"`
Title string Title string `db:"title" json:"title"`
Content *string Content *string `db:"content" json:"content"`
Priority int Priority int `db:"priority" json:"priority"`
UserMessageID *string UserMessageID *string `db:"usr_message_id" json:"usr_message_id"`
UsedKeyID KeyTokenID UsedKeyID KeyTokenID `db:"used_key_id" json:"used_key_id"`
Deleted bool Deleted bool `db:"deleted" json:"-"`
MessageExtra `db:"-"` // fields that are not in DB and are set on PreMarshal
} }
func (m Message) FullJSON() MessageJSON { type MessageExtra struct {
return MessageJSON{ Timestamp SCNTime `db:"-" json:"timestamp"`
MessageID: m.MessageID, Trimmed bool `db:"-" json:"trimmed"`
SenderUserID: m.SenderUserID,
ChannelInternalName: m.ChannelInternalName,
ChannelID: m.ChannelID,
SenderName: m.SenderName,
SenderIP: m.SenderIP,
Timestamp: m.Timestamp().Format(time.RFC3339Nano),
Title: m.Title,
Content: m.Content,
Priority: m.Priority,
UserMessageID: m.UserMessageID,
UsedKeyID: m.UsedKeyID,
Trimmed: false,
}
} }
func (m Message) TrimmedJSON() MessageJSON { func (u *Message) PreMarshal() Message {
return MessageJSON{ u.MessageExtra.Timestamp = NewSCNTime(u.Timestamp())
MessageID: m.MessageID, return *u
SenderUserID: m.SenderUserID, }
ChannelInternalName: m.ChannelInternalName,
ChannelID: m.ChannelID, func (m Message) Trim() Message {
SenderName: m.SenderName, r := m
SenderIP: m.SenderIP, if !r.Trimmed && r.NeedsTrim() {
Timestamp: m.Timestamp().Format(time.RFC3339Nano), r.Content = r.TrimmedContent()
Title: m.Title, r.MessageExtra.Trimmed = true
Content: m.TrimmedContent(),
Priority: m.Priority,
UserMessageID: m.UserMessageID,
UsedKeyID: m.UsedKeyID,
Trimmed: m.NeedsTrim(),
} }
return r.PreMarshal()
} }
func (m Message) Timestamp() time.Time { func (m Message) Timestamp() time.Time {
return langext.Coalesce(m.TimestampClient, m.TimestampReal) return langext.Coalesce(m.TimestampClient, m.TimestampReal).Time()
} }
func (m Message) NeedsTrim() bool { func (m Message) NeedsTrim() bool {
@ -102,71 +84,3 @@ func (m Message) FormatNotificationTitle(user User, channel Channel) string {
return fmt.Sprintf("[%s] %s", channel.DisplayName, m.Title) return fmt.Sprintf("[%s] %s", channel.DisplayName, m.Title)
} }
type MessageJSON struct {
MessageID MessageID `json:"message_id"`
SenderUserID UserID `json:"sender_user_id"`
ChannelInternalName string `json:"channel_internal_name"`
ChannelID ChannelID `json:"channel_id"`
SenderName *string `json:"sender_name"`
SenderIP string `json:"sender_ip"`
Timestamp string `json:"timestamp"`
Title string `json:"title"`
Content *string `json:"content"`
Priority int `json:"priority"`
UserMessageID *string `json:"usr_message_id"`
UsedKeyID KeyTokenID `json:"used_key_id"`
Trimmed bool `json:"trimmed"`
}
type MessageDB struct {
MessageID MessageID `db:"message_id"`
SenderUserID UserID `db:"sender_user_id"`
ChannelInternalName string `db:"channel_internal_name"`
ChannelID ChannelID `db:"channel_id"`
SenderName *string `db:"sender_name"`
SenderIP string `db:"sender_ip"`
TimestampReal int64 `db:"timestamp_real"`
TimestampClient *int64 `db:"timestamp_client"`
Title string `db:"title"`
Content *string `db:"content"`
Priority int `db:"priority"`
UserMessageID *string `db:"usr_message_id"`
UsedKeyID KeyTokenID `db:"used_key_id"`
Deleted int `db:"deleted"`
}
func (m MessageDB) Model() Message {
return Message{
MessageID: m.MessageID,
SenderUserID: m.SenderUserID,
ChannelInternalName: m.ChannelInternalName,
ChannelID: m.ChannelID,
SenderName: m.SenderName,
SenderIP: m.SenderIP,
TimestampReal: timeFromMilli(m.TimestampReal),
TimestampClient: timeOptFromMilli(m.TimestampClient),
Title: m.Title,
Content: m.Content,
Priority: m.Priority,
UserMessageID: m.UserMessageID,
UsedKeyID: m.UsedKeyID,
Deleted: m.Deleted != 0,
}
}
func DecodeMessage(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (Message, error) {
data, err := sq.ScanSingle[MessageDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return Message{}, err
}
return data.Model(), nil
}
func DecodeMessages(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]Message, error) {
data, err := sq.ScanAll[MessageDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v MessageDB) Message { return v.Model() }), nil
}

207
scnserver/models/requestlog.go
View File

@ -1,188 +1,27 @@
package models package models
import (
"context"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"gogs.mikescher.com/BlackForestBytes/goext/timeext"
"time"
)
type RequestLog struct { type RequestLog struct {
RequestID RequestID RequestID RequestID `db:"request_id" json:"requestLog_id"`
Method string Method string `db:"method" json:"method"`
URI string URI string `db:"uri" json:"uri"`
UserAgent *string UserAgent *string `db:"user_agent" json:"user_agent"`
Authentication *string Authentication *string `db:"authentication" json:"authentication"`
RequestBody *string RequestBody *string `db:"request_body" json:"request_body"`
RequestBodySize int64 RequestBodySize int64 `db:"request_body_size" json:"request_body_size"`
RequestContentType string RequestContentType string `db:"request_content_type" json:"request_content_type"`
RemoteIP string RemoteIP string `db:"remote_ip" json:"remote_ip"`
KeyID *KeyTokenID KeyID *KeyTokenID `db:"key_id" json:"key_id"`
UserID *UserID UserID *UserID `db:"userid" json:"userid"`
Permissions *string Permissions *string `db:"permissions" json:"permissions"`
ResponseStatuscode *int64 ResponseStatuscode *int64 `db:"response_statuscode" json:"response_statuscode"`
ResponseBodySize *int64 ResponseBodySize *int64 `db:"response_body_size" json:"response_body_size"`
ResponseBody *string ResponseBody *string `db:"response_body" json:"response_body"`
ResponseContentType string ResponseContentType string `db:"response_content_type" json:"response_content_type"`
RetryCount int64 RetryCount int64 `db:"retry_count" json:"retry_count"`
Panicked bool Panicked bool `db:"panicked" json:"panicked"`
PanicStr *string PanicStr *string `db:"panic_str" json:"panic_str"`
ProcessingTime time.Duration ProcessingTime SCNDuration `db:"processing_time" json:"processing_time"`
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
TimestampStart time.Time TimestampStart SCNTime `db:"timestamp_start" json:"timestamp_start"`
TimestampFinish time.Time TimestampFinish SCNTime `db:"timestamp_finish" json:"timestamp_finish"`
}
func (c RequestLog) JSON() RequestLogJSON {
return RequestLogJSON{
RequestID: c.RequestID,
Method: c.Method,
URI: c.URI,
UserAgent: c.UserAgent,
Authentication: c.Authentication,
RequestBody: c.RequestBody,
RequestBodySize: c.RequestBodySize,
RequestContentType: c.RequestContentType,
RemoteIP: c.RemoteIP,
KeyID: c.KeyID,
UserID: c.UserID,
Permissions: c.Permissions,
ResponseStatuscode: c.ResponseStatuscode,
ResponseBodySize: c.ResponseBodySize,
ResponseBody: c.ResponseBody,
ResponseContentType: c.ResponseContentType,
RetryCount: c.RetryCount,
Panicked: c.Panicked,
PanicStr: c.PanicStr,
ProcessingTime: c.ProcessingTime.Seconds(),
TimestampCreated: c.TimestampCreated.Format(time.RFC3339Nano),
TimestampStart: c.TimestampStart.Format(time.RFC3339Nano),
TimestampFinish: c.TimestampFinish.Format(time.RFC3339Nano),
}
}
func (c RequestLog) DB() RequestLogDB {
return RequestLogDB{
RequestID: c.RequestID,
Method: c.Method,
URI: c.URI,
UserAgent: c.UserAgent,
Authentication: c.Authentication,
RequestBody: c.RequestBody,
RequestBodySize: c.RequestBodySize,
RequestContentType: c.RequestContentType,
RemoteIP: c.RemoteIP,
KeyID: c.KeyID,
UserID: c.UserID,
Permissions: c.Permissions,
ResponseStatuscode: c.ResponseStatuscode,
ResponseBodySize: c.ResponseBodySize,
ResponseBody: c.ResponseBody,
ResponseContentType: c.ResponseContentType,
RetryCount: c.RetryCount,
Panicked: langext.Conditional[int64](c.Panicked, 1, 0),
PanicStr: c.PanicStr,
ProcessingTime: c.ProcessingTime.Milliseconds(),
TimestampCreated: c.TimestampCreated.UnixMilli(),
TimestampStart: c.TimestampStart.UnixMilli(),
TimestampFinish: c.TimestampFinish.UnixMilli(),
}
}
type RequestLogJSON struct {
RequestID RequestID `json:"requestLog_id"`
Method string `json:"method"`
URI string `json:"uri"`
UserAgent *string `json:"user_agent"`
Authentication *string `json:"authentication"`
RequestBody *string `json:"request_body"`
RequestBodySize int64 `json:"request_body_size"`
RequestContentType string `json:"request_content_type"`
RemoteIP string `json:"remote_ip"`
KeyID *KeyTokenID `json:"key_id"`
UserID *UserID `json:"userid"`
Permissions *string `json:"permissions"`
ResponseStatuscode *int64 `json:"response_statuscode"`
ResponseBodySize *int64 `json:"response_body_size"`
ResponseBody *string `json:"response_body"`
ResponseContentType string `json:"response_content_type"`
RetryCount int64 `json:"retry_count"`
Panicked bool `json:"panicked"`
PanicStr *string `json:"panic_str"`
ProcessingTime float64 `json:"processing_time"`
TimestampCreated string `json:"timestamp_created"`
TimestampStart string `json:"timestamp_start"`
TimestampFinish string `json:"timestamp_finish"`
}
type RequestLogDB struct {
RequestID RequestID `db:"request_id"`
Method string `db:"method"`
URI string `db:"uri"`
UserAgent *string `db:"user_agent"`
Authentication *string `db:"authentication"`
RequestBody *string `db:"request_body"`
RequestBodySize int64 `db:"request_body_size"`
RequestContentType string `db:"request_content_type"`
RemoteIP string `db:"remote_ip"`
KeyID *KeyTokenID `db:"key_id"`
UserID *UserID `db:"userid"`
Permissions *string `db:"permissions"`
ResponseStatuscode *int64 `db:"response_statuscode"`
ResponseBodySize *int64 `db:"response_body_size"`
ResponseBody *string `db:"response_body"`
ResponseContentType string `db:"response_content_type"`
RetryCount int64 `db:"retry_count"`
Panicked int64 `db:"panicked"`
PanicStr *string `db:"panic_str"`
ProcessingTime int64 `db:"processing_time"`
TimestampCreated int64 `db:"timestamp_created"`
TimestampStart int64 `db:"timestamp_start"`
TimestampFinish int64 `db:"timestamp_finish"`
}
func (c RequestLogDB) Model() RequestLog {
return RequestLog{
RequestID: c.RequestID,
Method: c.Method,
URI: c.URI,
UserAgent: c.UserAgent,
Authentication: c.Authentication,
RequestBody: c.RequestBody,
RequestBodySize: c.RequestBodySize,
RequestContentType: c.RequestContentType,
RemoteIP: c.RemoteIP,
KeyID: c.KeyID,
UserID: c.UserID,
Permissions: c.Permissions,
ResponseStatuscode: c.ResponseStatuscode,
ResponseBodySize: c.ResponseBodySize,
ResponseBody: c.ResponseBody,
ResponseContentType: c.ResponseContentType,
RetryCount: c.RetryCount,
Panicked: c.Panicked != 0,
PanicStr: c.PanicStr,
ProcessingTime: timeext.FromMilliseconds(c.ProcessingTime),
TimestampCreated: timeFromMilli(c.TimestampCreated),
TimestampStart: timeFromMilli(c.TimestampStart),
TimestampFinish: timeFromMilli(c.TimestampFinish),
}
}
func DecodeRequestLog(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (RequestLog, error) {
data, err := sq.ScanSingle[RequestLogDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return RequestLog{}, err
}
return data.Model(), nil
}
func DecodeRequestLogs(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]RequestLog, error) {
data, err := sq.ScanAll[RequestLogDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v RequestLogDB) RequestLog { return v.Model() }), nil
} }

82
scnserver/models/subscription.go
View File

@ -1,13 +1,5 @@
package models package models
import (
"context"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
)
// [!] subscriptions are read-access to channels, // [!] subscriptions are read-access to channels,
// //
// The set of subscriptions specifies which messages the ListMessages() API call returns // The set of subscriptions specifies which messages the ListMessages() API call returns
@ -16,71 +8,11 @@ import (
// (use keytokens for write-access) // (use keytokens for write-access)
type Subscription struct { type Subscription struct {
SubscriptionID SubscriptionID SubscriptionID SubscriptionID `db:"subscription_id" json:"subscription_id"`
SubscriberUserID UserID SubscriberUserID UserID `db:"subscriber_user_id" json:"subscriber_user_id"`
ChannelOwnerUserID UserID ChannelOwnerUserID UserID `db:"channel_owner_user_id" json:"channel_owner_user_id"`
ChannelID ChannelID ChannelID ChannelID `db:"channel_id" json:"channel_id"`
ChannelInternalName string ChannelInternalName string `db:"channel_internal_name" json:"channel_internal_name"`
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
Confirmed bool Confirmed bool `db:"confirmed" json:"confirmed"`
}
func (s Subscription) JSON() SubscriptionJSON {
return SubscriptionJSON{
SubscriptionID: s.SubscriptionID,
SubscriberUserID: s.SubscriberUserID,
ChannelOwnerUserID: s.ChannelOwnerUserID,
ChannelID: s.ChannelID,
ChannelInternalName: s.ChannelInternalName,
TimestampCreated: s.TimestampCreated.Format(time.RFC3339Nano),
Confirmed: s.Confirmed,
}
}
type SubscriptionJSON struct {
SubscriptionID SubscriptionID `json:"subscription_id"`
SubscriberUserID UserID `json:"subscriber_user_id"`
ChannelOwnerUserID UserID `json:"channel_owner_user_id"`
ChannelID ChannelID `json:"channel_id"`
ChannelInternalName string `json:"channel_internal_name"`
TimestampCreated string `json:"timestamp_created"`
Confirmed bool `json:"confirmed"`
}
type SubscriptionDB struct {
SubscriptionID SubscriptionID `db:"subscription_id"`
SubscriberUserID UserID `db:"subscriber_user_id"`
ChannelOwnerUserID UserID `db:"channel_owner_user_id"`
ChannelID ChannelID `db:"channel_id"`
ChannelInternalName string `db:"channel_internal_name"`
TimestampCreated int64 `db:"timestamp_created"`
Confirmed int `db:"confirmed"`
}
func (s SubscriptionDB) Model() Subscription {
return Subscription{
SubscriptionID: s.SubscriptionID,
SubscriberUserID: s.SubscriberUserID,
ChannelOwnerUserID: s.ChannelOwnerUserID,
ChannelID: s.ChannelID,
ChannelInternalName: s.ChannelInternalName,
TimestampCreated: timeFromMilli(s.TimestampCreated),
Confirmed: s.Confirmed != 0,
}
}
func DecodeSubscription(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (Subscription, error) {
data, err := sq.ScanSingle[SubscriptionDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return Subscription{}, err
}
return data.Model(), nil
}
func DecodeSubscriptions(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]Subscription, error) {
data, err := sq.ScanAll[SubscriptionDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v SubscriptionDB) Subscription { return v.Model() }), nil
} }

65
scnserver/models/time.go Normal file
View File

@ -0,0 +1,65 @@
package models
import (
"encoding/json"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
"time"
)
type SCNTime time.Time
func (t SCNTime) MarshalToDB(v SCNTime) (int64, error) {
return v.Time().UnixMilli(), nil
}
func (t SCNTime) UnmarshalToModel(v int64) (SCNTime, error) {
return NewSCNTime(time.UnixMilli(v)), nil
}
func (t SCNTime) Time() time.Time {
return time.Time(t)
}
func (t *SCNTime) UnmarshalJSON(data []byte) error {
str := ""
if err := json.Unmarshal(data, &str); err != nil {
return err
}
t0, err := time.Parse(time.RFC3339Nano, str)
if err != nil {
return err
}
*t = SCNTime(t0)
return nil
}
func (t SCNTime) MarshalJSON() ([]byte, error) {
str := t.Time().Format(time.RFC3339Nano)
return json.Marshal(str)
}
func NewSCNTime(t time.Time) SCNTime {
return SCNTime(t)
}
func NewSCNTimePtr(t *time.Time) *SCNTime {
if t == nil {
return nil
}
return langext.Ptr(SCNTime(*t))
}
func NowSCNTime() SCNTime {
return SCNTime(time.Now())
}
func tt(v rfctime.AnyTime) time.Time {
if r, ok := v.(time.Time); ok {
return r
}
if r, ok := v.(rfctime.RFCTime); ok {
return r.Time()
}
return time.Unix(0, v.UnixNano()).In(v.Location())
}

167
scnserver/models/user.go
View File

@ -2,38 +2,63 @@ package models
import ( import (
scn "blackforestbytes.com/simplecloudnotifier" scn "blackforestbytes.com/simplecloudnotifier"
"context"
"github.com/jmoiron/sqlx"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time"
) )
type User struct { type User struct {
UserID UserID UserID UserID `db:"user_id" json:"user_id"`
Username *string Username *string `db:"username" json:"username"`
TimestampCreated time.Time TimestampCreated SCNTime `db:"timestamp_created" json:"timestamp_created"`
TimestampLastRead *time.Time TimestampLastRead *SCNTime `db:"timestamp_lastread" json:"timestamp_lastread"`
TimestampLastSent *time.Time TimestampLastSent *SCNTime `db:"timestamp_lastsent" json:"timestamp_lastsent"`
MessagesSent int MessagesSent int `db:"messages_sent" json:"messages_sent"`
QuotaUsed int QuotaUsed int `db:"quota_used" json:"quota_used"`
QuotaUsedDay *string QuotaUsedDay *string `db:"quota_used_day" json:"-"`
IsPro bool IsPro bool `db:"is_pro" json:"is_pro"`
ProToken *string ProToken *string `db:"pro_token" json:"-"`
UserExtra `db:"-"` // fields that are not in DB and are set on PreMarshal
} }
func (u User) JSON() UserJSON { type UserExtra struct {
return UserJSON{ QuotaRemaining int `json:"quota_remaining"`
UserID: u.UserID, QuotaPerDay int `json:"quota_max"`
Username: u.Username, DefaultChannel string `json:"default_channel"`
TimestampCreated: u.TimestampCreated.Format(time.RFC3339Nano), MaxBodySize int `json:"max_body_size"`
TimestampLastRead: timeOptFmt(u.TimestampLastRead, time.RFC3339Nano), MaxTitleLength int `json:"max_title_length"`
TimestampLastSent: timeOptFmt(u.TimestampLastSent, time.RFC3339Nano), DefaultPriority int `json:"default_priority"`
MessagesSent: u.MessagesSent, MaxChannelNameLength int `json:"max_channel_name_length"`
QuotaUsed: u.QuotaUsedToday(), MaxChannelDescriptionLength int `json:"max_channel_description_length"`
MaxSenderNameLength int `json:"max_sender_name_length"`
MaxUserMessageIDLength int `json:"max_user_message_id_length"`
}
type UserPreview struct {
UserID UserID `json:"user_id"`
Username *string `json:"username"`
}
type UserWithClientsAndKeys struct {
User
Clients []Client `json:"clients"`
SendKey string `json:"send_key"`
ReadKey string `json:"read_key"`
AdminKey string `json:"admin_key"`
}
func (u User) WithClients(clients []Client, ak string, sk string, rk string) UserWithClientsAndKeys {
return UserWithClientsAndKeys{
User: u.PreMarshal(),
Clients: clients,
SendKey: sk,
ReadKey: rk,
AdminKey: ak,
}
}
func (u *User) PreMarshal() User {
u.UserExtra = UserExtra{
QuotaPerDay: u.QuotaPerDay(), QuotaPerDay: u.QuotaPerDay(),
QuotaRemaining: u.QuotaRemainingToday(), QuotaRemaining: u.QuotaRemainingToday(),
IsPro: u.IsPro,
DefaultChannel: u.DefaultChannel(), DefaultChannel: u.DefaultChannel(),
MaxBodySize: u.MaxContentLength(), MaxBodySize: u.MaxContentLength(),
MaxTitleLength: u.MaxTitleLength(), MaxTitleLength: u.MaxTitleLength(),
@ -43,16 +68,7 @@ func (u User) JSON() UserJSON {
MaxSenderNameLength: u.MaxSenderNameLength(), MaxSenderNameLength: u.MaxSenderNameLength(),
MaxUserMessageIDLength: u.MaxUserMessageIDLength(), MaxUserMessageIDLength: u.MaxUserMessageIDLength(),
} }
} return *u
func (u User) JSONWithClients(clients []Client, ak string, sk string, rk string) UserJSONWithClientsAndKeys {
return UserJSONWithClientsAndKeys{
UserJSON: u.JSON(),
Clients: langext.ArrMap(clients, func(v Client) ClientJSON { return v.JSON() }),
SendKey: sk,
ReadKey: rk,
AdminKey: ak,
}
} }
func (u User) MaxContentLength() int { func (u User) MaxContentLength() int {
@ -116,86 +132,9 @@ func (u User) MaxTimestampDiffHours() int {
return 24 return 24
} }
func (u User) JSONPreview() UserPreviewJSON { func (u User) JSONPreview() UserPreview {
return UserPreviewJSON{ return UserPreview{
UserID: u.UserID, UserID: u.UserID,
Username: u.Username, Username: u.Username,
} }
} }
type UserJSON struct {
UserID UserID `json:"user_id"`
Username *string `json:"username"`
TimestampCreated string `json:"timestamp_created"`
TimestampLastRead *string `json:"timestamp_lastread"`
TimestampLastSent *string `json:"timestamp_lastsent"`
MessagesSent int `json:"messages_sent"`
QuotaUsed int `json:"quota_used"`
QuotaRemaining int `json:"quota_remaining"`
QuotaPerDay int `json:"quota_max"`
IsPro bool `json:"is_pro"`
DefaultChannel string `json:"default_channel"`
MaxBodySize int `json:"max_body_size"`
MaxTitleLength int `json:"max_title_length"`
DefaultPriority int `json:"default_priority"`
MaxChannelNameLength int `json:"max_channel_name_length"`
MaxChannelDescriptionLength int `json:"max_channel_description_length"`
MaxSenderNameLength int `json:"max_sender_name_length"`
MaxUserMessageIDLength int `json:"max_user_message_id_length"`
}
type UserPreviewJSON struct {
UserID UserID `json:"user_id"`
Username *string `json:"username"`
}
type UserJSONWithClientsAndKeys struct {
UserJSON
Clients []ClientJSON `json:"clients"`
SendKey string `json:"send_key"`
ReadKey string `json:"read_key"`
AdminKey string `json:"admin_key"`
}
type UserDB struct {
UserID UserID `db:"user_id"`
Username *string `db:"username"`
TimestampCreated int64 `db:"timestamp_created"`
TimestampLastRead *int64 `db:"timestamp_lastread"`
TimestampLastSent *int64 `db:"timestamp_lastsent"`
MessagesSent int `db:"messages_sent"`
QuotaUsed int `db:"quota_used"`
QuotaUsedDay *string `db:"quota_used_day"`
IsPro bool `db:"is_pro"`
ProToken *string `db:"pro_token"`
}
func (u UserDB) Model() User {
return User{
UserID: u.UserID,
Username: u.Username,
TimestampCreated: timeFromMilli(u.TimestampCreated),
TimestampLastRead: timeOptFromMilli(u.TimestampLastRead),
TimestampLastSent: timeOptFromMilli(u.TimestampLastSent),
MessagesSent: u.MessagesSent,
QuotaUsed: u.QuotaUsed,
QuotaUsedDay: u.QuotaUsedDay,
IsPro: u.IsPro,
}
}
func DecodeUser(ctx context.Context, q sq.Queryable, r *sqlx.Rows) (User, error) {
data, err := sq.ScanSingle[UserDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return User{}, err
}
return data.Model(), nil
}
func DecodeUsers(ctx context.Context, q sq.Queryable, r *sqlx.Rows) ([]User, error) {
data, err := sq.ScanAll[UserDB](ctx, q, r, sq.SModeFast, sq.Safe, true)
if err != nil {
return nil, err
}
return langext.ArrMap(data, func(v UserDB) User { return v.Model() }), nil
}

8
scnserver/models/utils.go
View File

@ -2,6 +2,7 @@ package models
import ( import (
"gogs.mikescher.com/BlackForestBytes/goext/langext" "gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/sq"
"time" "time"
) )
@ -23,3 +24,10 @@ func timeOptFromMilli(millis *int64) *time.Time {
func timeFromMilli(millis int64) time.Time { func timeFromMilli(millis int64) time.Time {
return time.UnixMilli(millis) return time.UnixMilli(millis)
} }
func RegisterConverter(db sq.DB) {
db.RegisterConverter(sq.NewAutoDBTypeConverter(SCNTime{}))
db.RegisterConverter(sq.NewAutoDBTypeConverter(SCNDuration(0)))
db.RegisterConverter(sq.NewAutoDBTypeConverter(TokenPermissionList{}))
db.RegisterConverter(sq.NewAutoDBTypeConverter(ChannelIDArr{}))
}

215
scnserver/swagger/swagger.json
View File

@ -978,7 +978,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.MessageJSON" "$ref": "#/definitions/models.Message"
} }
}, },
"400": { "400": {
@ -1027,7 +1027,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.MessageJSON" "$ref": "#/definitions/models.Message"
} }
}, },
"400": { "400": {
@ -1077,7 +1077,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ChannelPreviewJSON" "$ref": "#/definitions/models.ChannelPreview"
} }
}, },
"400": { "400": {
@ -1127,7 +1127,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.KeyTokenPreviewJSON" "$ref": "#/definitions/models.KeyTokenPreview"
} }
}, },
"400": { "400": {
@ -1177,7 +1177,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.UserPreviewJSON" "$ref": "#/definitions/models.UserPreview"
} }
}, },
"400": { "400": {
@ -1228,7 +1228,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.UserJSONWithClientsAndKeys" "$ref": "#/definitions/models.UserWithClientsAndKeys"
} }
}, },
"400": { "400": {
@ -1266,7 +1266,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.UserJSON" "$ref": "#/definitions/models.User"
} }
}, },
"400": { "400": {
@ -1331,7 +1331,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.UserJSON" "$ref": "#/definitions/models.User"
} }
}, },
"400": { "400": {
@ -1445,7 +1445,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ChannelWithSubscriptionJSON" "$ref": "#/definitions/models.ChannelWithSubscription"
} }
}, },
"400": { "400": {
@ -1502,7 +1502,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ChannelWithSubscriptionJSON" "$ref": "#/definitions/models.ChannelWithSubscription"
} }
}, },
"400": { "400": {
@ -1581,7 +1581,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ChannelWithSubscriptionJSON" "$ref": "#/definitions/models.ChannelWithSubscription"
} }
}, },
"400": { "400": {
@ -1816,7 +1816,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ClientJSON" "$ref": "#/definitions/models.Client"
} }
}, },
"400": { "400": {
@ -1867,7 +1867,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ClientJSON" "$ref": "#/definitions/models.Client"
} }
}, },
"400": { "400": {
@ -1922,7 +1922,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ClientJSON" "$ref": "#/definitions/models.Client"
} }
}, },
"400": { "400": {
@ -1994,7 +1994,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.ClientJSON" "$ref": "#/definitions/models.Client"
} }
}, },
"400": { "400": {
@ -2101,7 +2101,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.KeyTokenJSON" "$ref": "#/definitions/models.KeyToken"
} }
}, },
"400": { "400": {
@ -2159,7 +2159,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.KeyTokenWithTokenJSON" "$ref": "#/definitions/models.KeyToken"
} }
}, },
"400": { "400": {
@ -2217,7 +2217,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.KeyTokenJSON" "$ref": "#/definitions/models.KeyToken"
} }
}, },
"400": { "400": {
@ -2273,7 +2273,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.KeyTokenJSON" "$ref": "#/definitions/models.KeyToken"
} }
}, },
"400": { "400": {
@ -2336,7 +2336,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.KeyTokenJSON" "$ref": "#/definitions/models.KeyToken"
} }
}, },
"400": { "400": {
@ -2458,7 +2458,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
} }
}, },
"400": { "400": {
@ -2509,7 +2509,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
} }
}, },
"400": { "400": {
@ -2564,7 +2564,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
} }
}, },
"400": { "400": {
@ -2627,7 +2627,7 @@
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
} }
}, },
"400": { "400": {
@ -3415,7 +3415,7 @@
"messages": { "messages": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.MessageJSON" "$ref": "#/definitions/models.Message"
} }
}, },
"next_page_token": { "next_page_token": {
@ -3432,7 +3432,7 @@
"subscriptions": { "subscriptions": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
} }
} }
} }
@ -3443,7 +3443,7 @@
"channels": { "channels": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.ChannelWithSubscriptionJSON" "$ref": "#/definitions/models.ChannelWithSubscription"
} }
} }
} }
@ -3454,7 +3454,7 @@
"clients": { "clients": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.ClientJSON" "$ref": "#/definitions/models.Client"
} }
} }
} }
@ -3465,7 +3465,7 @@
"messages": { "messages": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.MessageJSON" "$ref": "#/definitions/models.Message"
} }
}, },
"next_page_token": { "next_page_token": {
@ -3482,7 +3482,7 @@
"keys": { "keys": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.KeyTokenJSON" "$ref": "#/definitions/models.KeyToken"
} }
} }
} }
@ -3493,7 +3493,7 @@
"subscriptions": { "subscriptions": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
} }
} }
} }
@ -3803,7 +3803,7 @@
} }
} }
}, },
"models.ChannelPreviewJSON": { "models.ChannelPreview": {
"type": "object", "type": "object",
"properties": { "properties": {
"channel_id": { "channel_id": {
@ -3823,7 +3823,7 @@
} }
} }
}, },
"models.ChannelWithSubscriptionJSON": { "models.ChannelWithSubscription": {
"type": "object", "type": "object",
"properties": { "properties": {
"channel_id": { "channel_id": {
@ -3849,7 +3849,7 @@
"type": "string" "type": "string"
}, },
"subscription": { "subscription": {
"$ref": "#/definitions/models.SubscriptionJSON" "$ref": "#/definitions/models.Subscription"
}, },
"timestamp_created": { "timestamp_created": {
"type": "string" "type": "string"
@ -3859,7 +3859,7 @@
} }
} }
}, },
"models.ClientJSON": { "models.Client": {
"type": "object", "type": "object",
"properties": { "properties": {
"agent_model": { "agent_model": {
@ -3931,7 +3931,7 @@
} }
} }
}, },
"models.KeyTokenJSON": { "models.KeyToken": {
"type": "object", "type": "object",
"properties": { "properties": {
"all_channels": { "all_channels": {
@ -3956,69 +3956,11 @@
"type": "string" "type": "string"
}, },
"permissions": { "permissions": {
"type": "string"
},
"timestamp_created": {
"type": "string"
},
"timestamp_lastused": {
"type": "string"
}
}
},
"models.KeyTokenPreviewJSON": {
"type": "object",
"properties": {
"all_channels": {
"type": "boolean"
},
"channels": {
"type": "array", "type": "array",
"items": { "items": {
"type": "string" "$ref": "#/definitions/models.TokenPerm"
} }
}, },
"keytoken_id": {
"type": "string"
},
"name": {
"type": "string"
},
"owner_user_id": {
"type": "string"
},
"permissions": {
"type": "string"
}
}
},
"models.KeyTokenWithTokenJSON": {
"type": "object",
"properties": {
"all_channels": {
"type": "boolean"
},
"channels": {
"type": "array",
"items": {
"type": "string"
}
},
"keytoken_id": {
"type": "string"
},
"messages_sent": {
"type": "integer"
},
"name": {
"type": "string"
},
"owner_user_id": {
"type": "string"
},
"permissions": {
"type": "string"
},
"timestamp_created": { "timestamp_created": {
"type": "string" "type": "string"
}, },
@ -4030,7 +3972,33 @@
} }
} }
}, },
"models.MessageJSON": { "models.KeyTokenPreview": {
"type": "object",
"properties": {
"all_channels": {
"type": "boolean"
},
"channels": {
"type": "array",
"items": {
"type": "string"
}
},
"keytoken_id": {
"type": "string"
},
"name": {
"type": "string"
},
"owner_user_id": {
"type": "string"
},
"permissions": {
"type": "string"
}
}
},
"models.Message": {
"type": "object", "type": "object",
"properties": { "properties": {
"channel_id": { "channel_id": {
@ -4055,6 +4023,7 @@
"type": "string" "type": "string"
}, },
"sender_user_id": { "sender_user_id": {
"description": "user that sent the message (this is also the owner of the channel that contains it)",
"type": "string" "type": "string"
}, },
"timestamp": { "timestamp": {
@ -4066,15 +4035,12 @@
"trimmed": { "trimmed": {
"type": "boolean" "type": "boolean"
}, },
"used_key_id": {
"type": "string"
},
"usr_message_id": { "usr_message_id": {
"type": "string" "type": "string"
} }
} }
}, },
"models.SubscriptionJSON": { "models.Subscription": {
"type": "object", "type": "object",
"properties": { "properties": {
"channel_id": { "channel_id": {
@ -4100,7 +4066,28 @@
} }
} }
}, },
"models.UserJSON": { "models.TokenPerm": {
"type": "string",
"enum": [
"A",
"CR",
"CS",
"UR"
],
"x-enum-comments": {
"PermAdmin": "Edit userdata (+ includes all other permissions)",
"PermChannelRead": "Read messages",
"PermChannelSend": "Send messages",
"PermUserRead": "Read userdata"
},
"x-enum-varnames": [
"PermAdmin",
"PermChannelRead",
"PermChannelSend",
"PermUserRead"
]
},
"models.User": {
"type": "object", "type": "object",
"properties": { "properties": {
"default_channel": { "default_channel": {
@ -4159,7 +4146,18 @@
} }
} }
}, },
"models.UserJSONWithClientsAndKeys": { "models.UserPreview": {
"type": "object",
"properties": {
"user_id": {
"type": "string"
},
"username": {
"type": "string"
}
}
},
"models.UserWithClientsAndKeys": {
"type": "object", "type": "object",
"properties": { "properties": {
"admin_key": { "admin_key": {
@ -4168,7 +4166,7 @@
"clients": { "clients": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/models.ClientJSON" "$ref": "#/definitions/models.Client"
} }
}, },
"default_channel": { "default_channel": {
@ -4232,17 +4230,6 @@
"type": "string" "type": "string"
} }
} }
},
"models.UserPreviewJSON": {
"type": "object",
"properties": {
"user_id": {
"type": "string"
},
"username": {
"type": "string"
}
}
} }
}, },
"tags": [ "tags": [

174
scnserver/swagger/swagger.yaml
View File

@ -244,7 +244,7 @@ definitions:
properties: properties:
messages: messages:
items: items:
$ref: '#/definitions/models.MessageJSON' $ref: '#/definitions/models.Message'
type: array type: array
next_page_token: next_page_token:
type: string type: string
@ -255,28 +255,28 @@ definitions:
properties: properties:
subscriptions: subscriptions:
items: items:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
type: array type: array
type: object type: object
handler.ListChannels.response: handler.ListChannels.response:
properties: properties:
channels: channels:
items: items:
$ref: '#/definitions/models.ChannelWithSubscriptionJSON' $ref: '#/definitions/models.ChannelWithSubscription'
type: array type: array
type: object type: object
handler.ListClients.response: handler.ListClients.response:
properties: properties:
clients: clients:
items: items:
$ref: '#/definitions/models.ClientJSON' $ref: '#/definitions/models.Client'
type: array type: array
type: object type: object
handler.ListMessages.response: handler.ListMessages.response:
properties: properties:
messages: messages:
items: items:
$ref: '#/definitions/models.MessageJSON' $ref: '#/definitions/models.Message'
type: array type: array
next_page_token: next_page_token:
type: string type: string
@ -287,14 +287,14 @@ definitions:
properties: properties:
keys: keys:
items: items:
$ref: '#/definitions/models.KeyTokenJSON' $ref: '#/definitions/models.KeyToken'
type: array type: array
type: object type: object
handler.ListUserSubscriptions.response: handler.ListUserSubscriptions.response:
properties: properties:
subscriptions: subscriptions:
items: items:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
type: array type: array
type: object type: object
handler.Register.response: handler.Register.response:
@ -499,7 +499,7 @@ definitions:
uri: uri:
type: string type: string
type: object type: object
models.ChannelPreviewJSON: models.ChannelPreview:
properties: properties:
channel_id: channel_id:
type: string type: string
@ -512,7 +512,7 @@ definitions:
owner_user_id: owner_user_id:
type: string type: string
type: object type: object
models.ChannelWithSubscriptionJSON: models.ChannelWithSubscription:
properties: properties:
channel_id: channel_id:
type: string type: string
@ -530,13 +530,13 @@ definitions:
description: can be nil, depending on endpoint description: can be nil, depending on endpoint
type: string type: string
subscription: subscription:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
timestamp_created: timestamp_created:
type: string type: string
timestamp_lastsent: timestamp_lastsent:
type: string type: string
type: object type: object
models.ClientJSON: models.Client:
properties: properties:
agent_model: agent_model:
type: string type: string
@ -586,7 +586,7 @@ definitions:
usr_msg_id: usr_msg_id:
type: string type: string
type: object type: object
models.KeyTokenJSON: models.KeyToken:
properties: properties:
all_channels: all_channels:
type: boolean type: boolean
@ -603,47 +603,9 @@ definitions:
owner_user_id: owner_user_id:
type: string type: string
permissions: permissions:
type: string
timestamp_created:
type: string
timestamp_lastused:
type: string
type: object
models.KeyTokenPreviewJSON:
properties:
all_channels:
type: boolean
channels:
items: items:
type: string $ref: '#/definitions/models.TokenPerm'
type: array type: array
keytoken_id:
type: string
name:
type: string
owner_user_id:
type: string
permissions:
type: string
type: object
models.KeyTokenWithTokenJSON:
properties:
all_channels:
type: boolean
channels:
items:
type: string
type: array
keytoken_id:
type: string
messages_sent:
type: integer
name:
type: string
owner_user_id:
type: string
permissions:
type: string
timestamp_created: timestamp_created:
type: string type: string
timestamp_lastused: timestamp_lastused:
@ -651,7 +613,24 @@ definitions:
token: token:
type: string type: string
type: object type: object
models.MessageJSON: models.KeyTokenPreview:
properties:
all_channels:
type: boolean
channels:
items:
type: string
type: array
keytoken_id:
type: string
name:
type: string
owner_user_id:
type: string
permissions:
type: string
type: object
models.Message:
properties: properties:
channel_id: channel_id:
type: string type: string
@ -668,6 +647,8 @@ definitions:
sender_name: sender_name:
type: string type: string
sender_user_id: sender_user_id:
description: user that sent the message (this is also the owner of the channel
that contains it)
type: string type: string
timestamp: timestamp:
type: string type: string
@ -675,12 +656,10 @@ definitions:
type: string type: string
trimmed: trimmed:
type: boolean type: boolean
used_key_id:
type: string
usr_message_id: usr_message_id:
type: string type: string
type: object type: object
models.SubscriptionJSON: models.Subscription:
properties: properties:
channel_id: channel_id:
type: string type: string
@ -697,7 +676,24 @@ definitions:
timestamp_created: timestamp_created:
type: string type: string
type: object type: object
models.UserJSON: models.TokenPerm:
enum:
- A
- CR
- CS
- UR
type: string
x-enum-comments:
PermAdmin: Edit userdata (+ includes all other permissions)
PermChannelRead: Read messages
PermChannelSend: Send messages
PermUserRead: Read userdata
x-enum-varnames:
- PermAdmin
- PermChannelRead
- PermChannelSend
- PermUserRead
models.User:
properties: properties:
default_channel: default_channel:
type: string type: string
@ -736,13 +732,20 @@ definitions:
username: username:
type: string type: string
type: object type: object
models.UserJSONWithClientsAndKeys: models.UserPreview:
properties:
user_id:
type: string
username:
type: string
type: object
models.UserWithClientsAndKeys:
properties: properties:
admin_key: admin_key:
type: string type: string
clients: clients:
items: items:
$ref: '#/definitions/models.ClientJSON' $ref: '#/definitions/models.Client'
type: array type: array
default_channel: default_channel:
type: string type: string
@ -785,13 +788,6 @@ definitions:
username: username:
type: string type: string
type: object type: object
models.UserPreviewJSON:
properties:
user_id:
type: string
username:
type: string
type: object
host: simplecloudnotifier.de host: simplecloudnotifier.de
info: info:
contact: {} contact: {}
@ -1460,7 +1456,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.MessageJSON' $ref: '#/definitions/models.Message'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1496,7 +1492,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.MessageJSON' $ref: '#/definitions/models.Message'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1529,7 +1525,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ChannelPreviewJSON' $ref: '#/definitions/models.ChannelPreview'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1563,7 +1559,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.KeyTokenPreviewJSON' $ref: '#/definitions/models.KeyTokenPreview'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1597,7 +1593,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.UserPreviewJSON' $ref: '#/definitions/models.UserPreview'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1631,7 +1627,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.UserJSONWithClientsAndKeys' $ref: '#/definitions/models.UserWithClientsAndKeys'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1656,7 +1652,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.UserJSON' $ref: '#/definitions/models.User'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1699,7 +1695,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.UserJSON' $ref: '#/definitions/models.User'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1782,7 +1778,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ChannelWithSubscriptionJSON' $ref: '#/definitions/models.ChannelWithSubscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1820,7 +1816,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ChannelWithSubscriptionJSON' $ref: '#/definitions/models.ChannelWithSubscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -1873,7 +1869,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ChannelWithSubscriptionJSON' $ref: '#/definitions/models.ChannelWithSubscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2032,7 +2028,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ClientJSON' $ref: '#/definitions/models.Client'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2066,7 +2062,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ClientJSON' $ref: '#/definitions/models.Client'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2103,7 +2099,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ClientJSON' $ref: '#/definitions/models.Client'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2151,7 +2147,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.ClientJSON' $ref: '#/definitions/models.Client'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2223,7 +2219,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.KeyTokenJSON' $ref: '#/definitions/models.KeyToken'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2262,7 +2258,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.KeyTokenJSON' $ref: '#/definitions/models.KeyToken'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2301,7 +2297,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.KeyTokenJSON' $ref: '#/definitions/models.KeyToken'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2343,7 +2339,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.KeyTokenJSON' $ref: '#/definitions/models.KeyToken'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2383,7 +2379,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.KeyTokenWithTokenJSON' $ref: '#/definitions/models.KeyToken'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2485,7 +2481,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2519,7 +2515,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2556,7 +2552,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:
@ -2598,7 +2594,7 @@ paths:
"200": "200":
description: OK description: OK
schema: schema:
$ref: '#/definitions/models.SubscriptionJSON' $ref: '#/definitions/models.Subscription'
"400": "400":
description: supplied values/parameters cannot be parsed / are invalid description: supplied values/parameters cannot be parsed / are invalid
schema: schema:

2
scnserver/test/keytoken_test.go
View File

@ -131,7 +131,7 @@ func TestTokenKeys(t *testing.T) {
msg1 := tt.RequestAuthGet[gin.H](t, data.AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages/%s", msg1s["scn_msg_id"])) msg1 := tt.RequestAuthGet[gin.H](t, data.AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages/%s", msg1s["scn_msg_id"]))
tt.AssertEqual(t, "AllChannels", key7.KeytokenId, msg1["used_key_id"]) tt.AssertEqual(t, "used_key_id", key7.KeytokenId, msg1["used_key_id"])
tt.RequestPostShouldFail(t, baseUrl, "/", gin.H{ tt.RequestPostShouldFail(t, baseUrl, "/", gin.H{
"key": key7.Token, "key": key7.Token,

53
scnserver/test/response_test.go
View File

@ -113,6 +113,59 @@ func TestResponseKeyToken2(t *testing.T) {
}) })
} }
func TestResponseKeyToken3(t *testing.T) {
ws, baseUrl, stop := tt.StartSimpleWebserver(t)
defer stop()
data := tt.InitSingleData(t, ws)
response := tt.RequestAuthGetRaw(t, data.AdminKey, baseUrl, fmt.Sprintf("/api/v2/users/%s/keys/current", data.UID))
tt.AssertJsonStructureMatch(t, "json[key]", response, map[string]any{
"keytoken_id": "id",
"name": "string",
"timestamp_created": "rfc3339",
"timestamp_lastused": "rfc3339|null",
"owner_user_id": "id",
"all_channels": "bool",
"channels": []any{"string"},
"permissions": "string",
"messages_sent": "int",
"token": "string",
})
}
func TestResponseKeyToken4(t *testing.T) {
ws, baseUrl, stop := tt.StartSimpleWebserver(t)
defer stop()
data := tt.InitSingleData(t, ws)
chan1 := tt.RequestAuthPost[gin.H](t, data.AdminKey, baseUrl, fmt.Sprintf("/api/v2/users/%s/channels", data.UID), gin.H{
"name": "TestChan1asdf",
})
response := tt.RequestAuthPostRaw(t, data.AdminKey, baseUrl, fmt.Sprintf("/api/v2/users/%s/keys", data.UID), gin.H{
"all_channels": false,
"channels": []string{chan1["channel_id"].(string)},
"name": "TKey1",
"permissions": "CS",
})
tt.AssertJsonStructureMatch(t, "json[key]", response, map[string]any{
"keytoken_id": "id",
"name": "string",
"timestamp_created": "rfc3339",
"timestamp_lastused": "rfc3339|null",
"owner_user_id": "id",
"all_channels": "bool",
"channels": []any{"string"},
"permissions": "string",
"messages_sent": "int",
"token": "string",
})
}
func TestResponseMessage(t *testing.T) { func TestResponseMessage(t *testing.T) {
ws, baseUrl, stop := tt.StartSimpleWebserver(t) ws, baseUrl, stop := tt.StartSimpleWebserver(t)
defer stop() defer stop()

2
scnserver/test/send_test.go
View File

@ -836,7 +836,7 @@ func TestSendWithTimestamp(t *testing.T) {
tt.AssertEqual(t, "messageCount", 1, len(pusher.Data)) tt.AssertEqual(t, "messageCount", 1, len(pusher.Data))
tt.AssertStrRepEqual(t, "msg.title", "TTT", pusher.Last().Message.Title) tt.AssertStrRepEqual(t, "msg.title", "TTT", pusher.Last().Message.Title)
tt.AssertStrRepEqual(t, "msg.TimestampClient", ts, pusher.Last().Message.TimestampClient.Unix()) tt.AssertStrRepEqual(t, "msg.TimestampClient", ts, pusher.Last().Message.TimestampClient.Time().Unix())
tt.AssertStrRepEqual(t, "msg.Timestamp", ts, pusher.Last().Message.Timestamp().Unix()) tt.AssertStrRepEqual(t, "msg.Timestamp", ts, pusher.Last().Message.Timestamp().Unix())
tt.AssertNotStrRepEqual(t, "msg.ts", pusher.Last().Message.TimestampClient, pusher.Last().Message.TimestampReal) tt.AssertNotStrRepEqual(t, "msg.ts", pusher.Last().Message.TimestampClient, pusher.Last().Message.TimestampReal)
tt.AssertStrRepEqual(t, "msg.scn_msg_id", msg1["scn_msg_id"], pusher.Last().Message.MessageID) tt.AssertStrRepEqual(t, "msg.scn_msg_id", msg1["scn_msg_id"], pusher.Last().Message.MessageID)

4
scnserver/test/util/requests.go
View File

@ -34,6 +34,10 @@ func RequestPost[TResult any](t *testing.T, baseURL string, urlSuffix string, bo
return RequestAny[TResult](t, "", "POST", baseURL, urlSuffix, body, true) return RequestAny[TResult](t, "", "POST", baseURL, urlSuffix, body, true)
} }
func RequestAuthPostRaw(t *testing.T, akey string, baseURL string, urlSuffix string, body any) string {
return RequestAny[string](t, akey, "POST", baseURL, urlSuffix, body, false)
}
func RequestAuthPost[TResult any](t *testing.T, akey string, baseURL string, urlSuffix string, body any) TResult { func RequestAuthPost[TResult any](t *testing.T, akey string, baseURL string, urlSuffix string, body any) TResult {
return RequestAny[TResult](t, akey, "POST", baseURL, urlSuffix, body, true) return RequestAny[TResult](t, akey, "POST", baseURL, urlSuffix, body, true)
} }

4
scnserver/test/util/structure.go
View File

@ -135,13 +135,13 @@ func assertjsonStructureMatchMapObject(t *testing.T, mapschema map[string]any, r
for k := range mapschema { for k := range mapschema {
if _, ok := realValue[k]; !ok { if _, ok := realValue[k]; !ok {
t.Errorf("Missing Key: < %s >", keyPath) t.Errorf("Missing Key: < %s >", keyPath+"."+k)
} }
} }
for k := range realValue { for k := range realValue {
if _, ok := mapschema[k]; !ok { if _, ok := mapschema[k]; !ok {
t.Errorf("Additional key: < %s >", keyPath) t.Errorf("Additional key: < %s >", keyPath+"."+k)
} }
} }