Work on implementing search filter in app [WIP]

scnserver/api/handler/apiSenderNames.go

@@ -0,0 +1,87 @@
+package handler
+
+import (
+	"blackforestbytes.com/simplecloudnotifier/logic"
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"gogs.mikescher.com/BlackForestBytes/goext/ginext"
+)
+
+// ListUserSenderNames swaggerdoc
+//
+//	@Summary		List sender-names (of allthe messages of this user)
+//	@ID				api-usersendernames-list
+//	@Tags			API-v2
+//
+//	@Param			uid	path		string	true	"UserID"
+//
+//	@Success		200	{object}	handler.ListUserKeys.response
+//	@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		404	{object}	ginresp.apiError	"message not found"
+//	@Failure		500	{object}	ginresp.apiError	"internal server error"
+//
+//	@Router			/api/v2/users/{uid}/keys [GET]
+func (h APIHandler) ListUserSenderNames(pctx ginext.PreContext) ginext.HTTPResponse {
+	type uri struct {
+		UserID models.UserID `uri:"uid" binding:"entityid"`
+	}
+	type response struct {
+	}
+
+	var u uri
+	ctx, g, errResp := pctx.URI(&u).Start()
+	if errResp != nil {
+		return *errResp
+	}
+	defer ctx.Cancel()
+
+	return h.app.DoRequest(ctx, g, models.TLockRead, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
+
+		if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
+			return *permResp
+		}
+
+		return nil //TODO
+
+	})
+}
+
+// ListSenderNames swaggerdoc
+//
+//	@Summary		List sender-names (of all messages this user can view, eitehr own or foreign-subscribed)
+//	@ID				api-sendernames-list
+//	@Tags			API-v2
+//
+//	@Success		200	{object}	handler.ListSenderNames.response
+//	@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		404	{object}	ginresp.apiError	"message not found"
+//	@Failure		500	{object}	ginresp.apiError	"internal server error"
+//
+//	@Router			/api/v2/sender-names [GET]
+func (h APIHandler) ListSenderNames(pctx ginext.PreContext) ginext.HTTPResponse {
+	type response struct {
+	}
+
+	ctx, g, errResp := pctx.Start()
+	if errResp != nil {
+		return *errResp
+	}
+	defer ctx.Cancel()
+
+	return h.app.DoRequest(ctx, g, models.TLockRead, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
+
+		if permResp := ctx.CheckPermissionAny(); permResp != nil {
+			return *permResp
+		}
+
+		userid := *ctx.GetPermissionUserID()
+
+		if permResp := ctx.CheckPermissionUserRead(userid); permResp != nil {
+			return *permResp
+		}
+
+		return nil //TODO
+
+	})
+}

scnserver/api/router.go

@@ -152,10 +152,14 @@ func (r *Router) Init(e *ginext.GinWrapper) error {
 		apiv2.DELETE("/users/:uid/subscriptions/:sid").Handle(r.apiHandler.CancelSubscription)
 		apiv2.PATCH("/users/:uid/subscriptions/:sid").Handle(r.apiHandler.UpdateSubscription)
 
+		apiv2.GET("/users/:uid/sender-names").Handle(r.apiHandler.ListUserSenderNames)
+
 		apiv2.GET("/messages").Handle(r.apiHandler.ListMessages)
 		apiv2.GET("/messages/:mid").Handle(r.apiHandler.GetMessage)
 		apiv2.DELETE("/messages/:mid").Handle(r.apiHandler.DeleteMessage)
 
+		apiv2.GET("/sender-names").Handle(r.apiHandler.ListSenderNames)
+
 		apiv2.GET("/preview/users/:uid").Handle(r.apiHandler.GetUserPreview)
 		apiv2.GET("/preview/keys/:kid").Handle(r.apiHandler.GetUserKeyPreview)
 		apiv2.GET("/preview/channels/:cid").Handle(r.apiHandler.GetChannelPreview)

scnserver/models/channel.go

@@ -3,9 +3,9 @@ package models
 type Channel struct {
 	ChannelID         ChannelID `db:"channel_id"         json:"channel_id"`
 	OwnerUserID       UserID    `db:"owner_user_id"      json:"owner_user_id"`
-	InternalName      string    `db:"internal_name"      json:"internal_name"`
-	DisplayName       string    `db:"display_name"       json:"display_name"`
-	DescriptionName   *string   `db:"description_name"   json:"description_name"`
+	InternalName      string    `db:"internal_name"      json:"internal_name"`                               // = InternalName, used for sending, normalized, cannot be changed
+	DisplayName       string    `db:"display_name"       json:"display_name"`                                // = DisplayName, used for display purposes, can be changed, initially equals InternalName
+	DescriptionName   *string   `db:"description_name"   json:"description_name"`                            // = DescriptionName, (optional), longer description text, initally nil
 	SubscribeKey      string    `db:"subscribe_key"      json:"subscribe_key"      jsonfilter:"INCLUDE_KEY"` // can be nil, depending on endpoint
 	TimestampCreated  SCNTime   `db:"timestamp_created"  json:"timestamp_created"`
 	TimestampLastSent *SCNTime  `db:"timestamp_lastsent" json:"timestamp_lastsent"`

scnserver/test/message_test.go

@@ -698,3 +698,163 @@ func TestListMessagesZeroPagesize(t *testing.T) {
 	tt.AssertEqual(t, "msgList.PageSize", 1, msgList1.PageSize)
 	tt.AssertEqual(t, "msgList[0]", "Lorem Ipsum 23", msgList1.Messages[0].Title)
 }
+
+func TestListMessagesFilterChannel(t *testing.T) {
+	ws, baseUrl, stop := tt.StartSimpleWebserver(t)
+	defer stop()
+
+	data := tt.InitDefaultData(t, ws)
+
+	type msg struct {
+		ChannelId           string `json:"channel_id"`
+		ChannelInternalName string `json:"channel_internal_name"`
+		Content             string `json:"content"`
+		MessageId           string `json:"message_id"`
+		OwnerUserId         string `json:"owner_user_id"`
+		Priority            int    `json:"priority"`
+		SenderIp            string `json:"sender_ip"`
+		SenderName          string `json:"sender_name"`
+		SenderUserId        string `json:"sender_user_id"`
+		Timestamp           string `json:"timestamp"`
+		Title               string `json:"title"`
+		Trimmed             bool   `json:"trimmed"`
+		UsrMessageId        string `json:"usr_message_id"`
+	}
+	type mglist struct {
+		Messages []msg `json:"messages"`
+	}
+
+	cid1 := ""
+	for _, channel := range data.User[0].Channels {
+		if channel.InternalName == "Reminders" {
+			cid1 = channel.ChannelID
+		}
+	}
+
+	cid2 := ""
+	for _, channel := range data.User[0].Channels {
+		if channel.InternalName == "Chatting Chamber" {
+			cid2 = channel.ChannelID
+		}
+	}
+
+	skey := ""
+	for _, key := range data.User[0].Keys {
+		if key.Name == "SendKey (default)" {
+			skey = key.KeyID
+		}
+	}
+
+	akey := ""
+	for _, key := range data.User[0].Keys {
+		if key.Name == "AdminKey (default)" {
+			akey = key.KeyID
+		}
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?channel=%s", "Reminders,Promotions"))
+		tt.AssertEqual(t, "msgList.len", 9, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?channel=%s", "Reminders"))
+		tt.AssertEqual(t, "msgList.len", 6, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?channel_id=%s", cid1))
+		tt.AssertEqual(t, "msgList.len", 6, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?channel_id=%s,%s", cid1, cid2))
+		tt.AssertEqual(t, "msgList.len", 9, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?filter=%s", "unusual"))
+		tt.AssertEqual(t, "msgList.len", 1, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?filter=%s", "your"))
+		tt.AssertEqual(t, "msgList.len", 7, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?priority=%s", "1"))
+		tt.AssertEqual(t, "msgList.len", 4, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?priority=%s", "2"))
+		tt.AssertEqual(t, "msgList.len", 6, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?priority=%s", "0"))
+		tt.AssertEqual(t, "msgList.len", 5, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?priority=%s", "0,2"))
+		tt.AssertEqual(t, "msgList.len", 11, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?used_key_id=%s", akey))
+		tt.AssertEqual(t, "msgList.len", 11, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?used_key_id=%s", skey))
+		tt.AssertEqual(t, "msgList.len", 11, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?used_key_id=%s,%s", akey, skey))
+		tt.AssertEqual(t, "msgList.len", 22, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?used_key_id=%s&priority=%d", akey, 0))
+		tt.AssertEqual(t, "msgList.len", 5, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?sender=%s", "Mobile Mate"))
+		tt.AssertEqual(t, "msgList.len", 3, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?sender=%s", "Pocket Pal"))
+		tt.AssertEqual(t, "msgList.len", 3, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?sender=%s,%s", "Pocket Pal", "Mobile Mate"))
+		tt.AssertEqual(t, "msgList.len", 6, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?sender=%s", ""))
+		tt.AssertEqual(t, "msgList.len", 12, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?before=%s", time.Now().Add(-time.Hour)))
+		tt.AssertEqual(t, "msgList.len", 2, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?after=%s", time.Now().Add(-time.Hour)))
+		tt.AssertEqual(t, "msgList.len", 20, len(msgList.Messages))
+	}
+
+	{
+		msgList := tt.RequestAuthGet[mglist](t, data.User[0].AdminKey, baseUrl, fmt.Sprintf("/api/v2/messages?after=%s", time.Now().Add(5*time.Minute)))
+		tt.AssertEqual(t, "msgList.len", 3, len(msgList.Messages))
+	}
+
+}

scnserver/test/sendername_test.go

@@ -0,0 +1,11 @@
+package test
+
+import "testing"
+
+func TestListSenderNames(t *testing.T) {
+	t.Fail()
+}
+
+func TestListUserSenderNames(t *testing.T) {
+	t.Fail()
+}

scnserver/test/util/factory.go

@@ -59,15 +59,25 @@ type clientex struct {
 	FCMTok       string
 }
 
+type ChanData struct {
+	ChannelID    string
+	InternalName string
+}
+
+type KeyDat struct {
+	KeyID string
+	Name  string
+}
+
 type Userdat struct {
 	UID           string
 	SendKey       string
 	AdminKey      string
 	ReadKey       string
 	Clients       []string
-	Channels      []string
+	Channels      []ChanData
 	Messages      []string
-	Keys          []string
+	Keys          []KeyDat
 	Subscriptions []string
 }
 
@@ -419,26 +429,28 @@ func InitDefaultData(t *testing.T, ws *logic.Application) DefData {
 
 	for i, usr := range users {
 		type schan struct {
-			ID string `json:"channel_id"`
+			ID           string `json:"channel_id"`
+			InternalName string `json:"internal_name"`
 		}
 		type chanlist struct {
 			Channels []schan `json:"channels"`
 		}
 		r0 := RequestAuthGet[chanlist](t, usr.AdminKey, baseUrl, fmt.Sprintf("/api/v2/users/%s/channels?selector=%s", usr.UID, "owned"))
-		users[i].Channels = langext.ArrMap(r0.Channels, func(v schan) string { return v.ID })
+		users[i].Channels = langext.ArrMap(r0.Channels, func(v schan) ChanData { return ChanData{ChannelID: v.ID, InternalName: v.InternalName} })
 	}
 
 	// list keys
 
 	for i, usr := range users {
 		type skey struct {
-			ID string `json:"keytoken_id"`
+			ID   string `json:"keytoken_id"`
+			Name string `json:"name"`
 		}
 		type keylist struct {
 			Keys []skey `json:"keys"`
 		}
 		r0 := RequestAuthGet[keylist](t, usr.AdminKey, baseUrl, fmt.Sprintf("/api/v2/users/%s/keys", usr.UID))
-		users[i].Keys = langext.ArrMap(r0.Keys, func(v skey) string { return v.ID })
+		users[i].Keys = langext.ArrMap(r0.Keys, func(v skey) KeyDat { return KeyDat{KeyID: v.ID, KeyName: v.Name} })
 	}
 
 	// list subscriptions