SimpleCloudNotifier/scnserver/api/handler/message.go

323 lines
13 KiB
Go
Raw Normal View History

2022-11-18 21:25:40 +01:00
package handler
import (
2022-11-19 15:13:47 +01:00
"blackforestbytes.com/simplecloudnotifier/api/apierr"
2022-11-30 17:58:04 +01:00
hl "blackforestbytes.com/simplecloudnotifier/api/apihighlight"
2022-12-20 13:55:09 +01:00
"blackforestbytes.com/simplecloudnotifier/api/ginresp"
primarydb "blackforestbytes.com/simplecloudnotifier/db/impl/primary"
2022-11-18 21:25:40 +01:00
"blackforestbytes.com/simplecloudnotifier/logic"
2022-11-20 22:18:24 +01:00
"blackforestbytes.com/simplecloudnotifier/models"
2022-11-19 15:13:47 +01:00
"database/sql"
"fmt"
2022-11-18 21:25:40 +01:00
"github.com/gin-gonic/gin"
2022-11-19 15:13:47 +01:00
"gogs.mikescher.com/BlackForestBytes/goext/dataext"
"gogs.mikescher.com/BlackForestBytes/goext/langext"
"gogs.mikescher.com/BlackForestBytes/goext/mathext"
"gogs.mikescher.com/BlackForestBytes/goext/timeext"
"net/http"
"strings"
"time"
2022-11-18 21:25:40 +01:00
)
type MessageHandler struct {
2022-11-19 15:13:47 +01:00
app *logic.Application
database *primarydb.Database
2022-11-18 21:25:40 +01:00
}
2022-11-19 15:13:47 +01:00
func NewMessageHandler(app *logic.Application) MessageHandler {
return MessageHandler{
app: app,
database: app.Database.Primary,
2022-11-19 15:13:47 +01:00
}
}
2022-11-20 03:06:08 +01:00
// SendMessageCompat swaggerdoc
//
// @Deprecated
//
// @Summary Send a new message (compatibility)
// @Description All parameter can be set via query-parameter or form-data body. Only UserID, UserKey and Title are required
2022-11-23 19:32:23 +01:00
// @Tags External
2022-11-20 03:06:08 +01:00
//
2022-11-30 17:58:04 +01:00
// @Param query_data query handler.SendMessageCompat.combined false " "
// @Param form_data formData handler.SendMessageCompat.combined false " "
2022-11-20 03:06:08 +01:00
//
// @Success 200 {object} handler.sendMessageInternal.response
// @Failure 400 {object} ginresp.apiError
// @Failure 401 {object} ginresp.apiError
// @Failure 403 {object} ginresp.apiError
// @Failure 500 {object} ginresp.apiError
//
// @Router /send.php [POST]
func (h MessageHandler) SendMessageCompat(g *gin.Context) ginresp.HTTPResponse {
2022-11-30 17:58:04 +01:00
type combined struct {
UserID *models.UserID `json:"user_id" form:"user_id"`
UserKey *string `json:"user_key" form:"user_key"`
Title *string `json:"title" form:"title"`
Content *string `json:"content" form:"content"`
Priority *int `json:"priority" form:"priority"`
UserMessageID *string `json:"msg_id" form:"msg_id"`
SendTimestamp *float64 `json:"timestamp" form:"timestamp"`
2022-11-20 03:06:08 +01:00
}
2022-11-30 17:58:04 +01:00
var f combined
var q combined
2022-11-20 03:06:08 +01:00
ctx, errResp := h.app.StartRequest(g, nil, &q, nil, &f)
if errResp != nil {
return *errResp
}
defer ctx.Cancel()
data := dataext.ObjectMerge(f, q)
return h.sendMessageInternal(g, ctx, data.UserID, data.UserKey, nil, nil, data.Title, data.Content, data.Priority, data.UserMessageID, data.SendTimestamp, nil)
2022-11-20 03:06:08 +01:00
}
2022-11-19 15:13:47 +01:00
// SendMessage swaggerdoc
//
// @Summary Send a new message
// @Description All parameter can be set via query-parameter or the json body. Only UserID, UserKey and Title are required
2022-11-23 19:32:23 +01:00
// @Tags External
2022-11-19 15:13:47 +01:00
//
2022-11-30 17:58:04 +01:00
// @Param query_data query handler.SendMessage.combined false " "
// @Param post_body body handler.SendMessage.combined false " "
// @Param form_body formData handler.SendMessage.combined false " "
2022-11-19 15:13:47 +01:00
//
2022-11-20 03:06:08 +01:00
// @Success 200 {object} handler.sendMessageInternal.response
2022-11-19 15:13:47 +01:00
// @Failure 400 {object} ginresp.apiError
2022-11-21 22:52:44 +01:00
// @Failure 401 {object} ginresp.apiError "The user_id was not found or the user_key is wrong"
// @Failure 403 {object} ginresp.apiError "The user has exceeded its daily quota - wait 24 hours or upgrade your account"
// @Failure 500 {object} ginresp.apiError "An internal server error occurred - try again later"
2022-11-19 15:13:47 +01:00
//
// @Router / [POST]
// @Router /send [POST]
2022-11-18 21:25:40 +01:00
func (h MessageHandler) SendMessage(g *gin.Context) ginresp.HTTPResponse {
2022-11-30 17:58:04 +01:00
type combined struct {
UserID *models.UserID `json:"user_id" form:"user_id" example:"7725" `
UserKey *string `json:"user_key" form:"user_key" example:"P3TNH8mvv14fm" `
Channel *string `json:"channel" form:"channel" example:"test" `
ChanKey *string `json:"chan_key" form:"chan_key" example:"qhnUbKcLgp6tg" `
Title *string `json:"title" form:"title" example:"Hello World" `
Content *string `json:"content" form:"content" example:"This is a message" `
Priority *int `json:"priority" form:"priority" example:"1" enums:"0,1,2" `
UserMessageID *string `json:"msg_id" form:"msg_id" example:"db8b0e6a-a08c-4646" `
SendTimestamp *float64 `json:"timestamp" form:"timestamp" example:"1669824037" `
SenderName *string `json:"sender_name" form:"sender_name" example:"example-server" `
}
var b combined
var q combined
var f combined
2022-11-20 20:34:18 +01:00
ctx, errResp := h.app.StartRequest(g, nil, &q, &b, &f)
2022-11-20 03:06:08 +01:00
if errResp != nil {
return *errResp
}
defer ctx.Cancel()
// query has highest prio, then form, then json
2022-11-20 20:34:18 +01:00
data := dataext.ObjectMerge(dataext.ObjectMerge(b, f), q)
2022-11-20 03:06:08 +01:00
return h.sendMessageInternal(g, ctx, data.UserID, data.UserKey, data.Channel, data.ChanKey, data.Title, data.Content, data.Priority, data.UserMessageID, data.SendTimestamp, data.SenderName)
2022-11-20 03:06:08 +01:00
}
func (h MessageHandler) sendMessageInternal(g *gin.Context, ctx *logic.AppContext, UserID *models.UserID, UserKey *string, Channel *string, ChanKey *string, Title *string, Content *string, Priority *int, UserMessageID *string, SendTimestamp *float64, SenderName *string) ginresp.HTTPResponse {
2022-11-19 15:13:47 +01:00
type response struct {
2022-11-20 22:18:24 +01:00
Success bool `json:"success"`
ErrorID apierr.APIError `json:"error"`
ErrorHighlight int `json:"errhighlight"`
Message string `json:"message"`
SuppressSend bool `json:"suppress_send"`
MessageCount int `json:"messagecount"`
Quota int `json:"quota"`
IsPro bool `json:"is_pro"`
QuotaMax int `json:"quota_max"`
SCNMessageID models.SCNMessageID `json:"scn_msg_id"`
2022-11-19 15:13:47 +01:00
}
2022-11-20 12:59:43 +01:00
if Title != nil {
Title = langext.Ptr(strings.TrimSpace(*Title))
}
if UserMessageID != nil {
UserMessageID = langext.Ptr(strings.TrimSpace(*UserMessageID))
}
2022-11-20 03:06:08 +01:00
if UserID == nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.MISSING_UID, hl.USER_ID, "Missing parameter [[user_id]]", nil)
2022-11-19 15:13:47 +01:00
}
2022-11-20 03:06:08 +01:00
if UserKey == nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.MISSING_TOK, hl.USER_KEY, "Missing parameter [[user_token]]", nil)
2022-11-19 15:13:47 +01:00
}
2022-11-20 03:06:08 +01:00
if Title == nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.MISSING_TITLE, hl.TITLE, "Missing parameter [[title]]", nil)
2022-11-19 15:13:47 +01:00
}
2022-11-20 03:06:08 +01:00
if Priority != nil && (*Priority != 0 && *Priority != 1 && *Priority != 2) {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.INVALID_PRIO, hl.PRIORITY, "Invalid priority", nil)
2022-11-19 15:13:47 +01:00
}
2022-11-20 12:59:43 +01:00
if len(*Title) == 0 {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.NO_TITLE, hl.TITLE, "No title specified", nil)
2022-11-19 15:13:47 +01:00
}
2022-11-20 03:06:08 +01:00
user, err := h.database.GetUser(ctx, *UserID)
2022-11-19 15:13:47 +01:00
if err == sql.ErrNoRows {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.USER_NOT_FOUND, hl.USER_ID, "User not found", nil)
2022-11-19 15:13:47 +01:00
}
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to query user", err)
2022-11-19 15:13:47 +01:00
}
channelDisplayName := user.DefaultChannel()
channelInternalName := user.DefaultChannel()
2022-11-20 22:18:24 +01:00
if Channel != nil {
channelDisplayName = h.app.NormalizeChannelDisplayName(*Channel)
channelInternalName = h.app.NormalizeChannelInternalName(*Channel)
2022-11-20 22:18:24 +01:00
}
2022-11-20 20:34:18 +01:00
if len(*Title) > user.MaxTitleLength() {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.TITLE_TOO_LONG, hl.TITLE, fmt.Sprintf("Title too long (max %d characters)", user.MaxTitleLength()), nil)
2022-11-19 15:13:47 +01:00
}
2022-11-20 12:59:43 +01:00
if Content != nil && len(*Content) > user.MaxContentLength() {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.CONTENT_TOO_LONG, hl.CONTENT, fmt.Sprintf("Content too long (%d characters; max := %d characters)", len(*Content), user.MaxContentLength()), nil)
2022-11-19 15:13:47 +01:00
}
if len(channelDisplayName) > user.MaxChannelNameLength() {
return ginresp.SendAPIError(g, 400, apierr.CHANNEL_TOO_LONG, hl.CHANNEL, fmt.Sprintf("Channel too long (max %d characters)", user.MaxChannelNameLength()), nil)
}
if len(channelInternalName) > user.MaxChannelNameLength() {
2022-12-14 16:57:08 +01:00
return ginresp.SendAPIError(g, 400, apierr.CHANNEL_TOO_LONG, hl.CHANNEL, fmt.Sprintf("Channel too long (max %d characters)", user.MaxChannelNameLength()), nil)
2022-11-21 22:52:44 +01:00
}
if SenderName != nil && len(*SenderName) > user.MaxSenderName() {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.SENDERNAME_TOO_LONG, hl.SENDER_NAME, fmt.Sprintf("SenderName too long (max %d characters)", user.MaxSenderName()), nil)
}
if UserMessageID != nil && len(*UserMessageID) > user.MaxUserMessageID() {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 400, apierr.USR_MSG_ID_TOO_LONG, hl.USER_MESSAGE_ID, fmt.Sprintf("MessageID too long (max %d characters)", user.MaxUserMessageID()), nil)
}
if SendTimestamp != nil && mathext.Abs(*SendTimestamp-float64(time.Now().Unix())) > timeext.FromHours(user.MaxTimestampDiffHours()).Seconds() {
return ginresp.SendAPIError(g, 400, apierr.TIMESTAMP_OUT_OF_RANGE, hl.NONE, fmt.Sprintf("The timestamp mus be within %d hours of now()", user.MaxTimestampDiffHours()), nil)
}
2022-11-19 15:13:47 +01:00
2022-11-20 03:06:08 +01:00
if UserMessageID != nil {
msg, err := h.database.GetMessageByUserMessageID(ctx, *UserMessageID)
2022-11-19 15:13:47 +01:00
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to query existing message", err)
2022-11-19 15:13:47 +01:00
}
if msg != nil {
2022-12-14 12:29:55 +01:00
//the found message can be deleted (!), but we still return NO_ERROR here...
2022-11-20 03:06:08 +01:00
return ctx.FinishSuccess(ginresp.JSON(http.StatusOK, response{
2022-11-19 15:13:47 +01:00
Success: true,
ErrorID: apierr.NO_ERROR,
ErrorHighlight: -1,
2022-11-19 15:13:47 +01:00
Message: "Message already sent",
SuppressSend: true,
MessageCount: user.MessagesSent,
Quota: user.QuotaUsedToday(),
IsPro: user.IsPro,
QuotaMax: user.QuotaPerDay(),
SCNMessageID: msg.SCNMessageID,
2022-11-20 03:06:08 +01:00
}))
2022-11-19 15:13:47 +01:00
}
}
if user.QuotaRemainingToday() <= 0 {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 403, apierr.QUOTA_REACHED, hl.NONE, fmt.Sprintf("Daily quota reached (%d)", user.QuotaPerDay()), nil)
2022-11-19 15:13:47 +01:00
}
2022-11-30 17:58:04 +01:00
var channel models.Channel
if ChanKey != nil {
// foreign channel (+ channel send-key)
foreignChan, err := h.database.GetChannelByNameAndSendKey(ctx, channelInternalName, *ChanKey)
2022-11-30 17:58:04 +01:00
if err != nil {
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to query (foreign) channel", err)
}
if foreignChan == nil {
return ginresp.SendAPIError(g, 400, apierr.CHANNEL_NOT_FOUND, hl.CHANNEL, "(Foreign) Channel not found", err)
}
channel = *foreignChan
} else {
// own channel
channel, err = h.app.GetOrCreateChannel(ctx, *UserID, channelDisplayName, channelInternalName)
2022-11-30 17:58:04 +01:00
if err != nil {
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to query/create (owned) channel", err)
}
2022-11-19 15:13:47 +01:00
}
2022-11-20 03:06:08 +01:00
selfChanAdmin := *UserID == channel.OwnerUserID && *UserKey == user.AdminKey
selfChanSend := *UserID == channel.OwnerUserID && *UserKey == user.SendKey
forgChanSend := *UserID != channel.OwnerUserID && ChanKey != nil && *ChanKey == channel.SendKey
2022-11-19 15:13:47 +01:00
if !selfChanAdmin && !selfChanSend && !forgChanSend {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 401, apierr.USER_AUTH_FAILED, hl.USER_KEY, "You are not authorized for this action", nil)
2022-11-19 15:13:47 +01:00
}
var sendTimestamp *time.Time = nil
2022-11-20 03:06:08 +01:00
if SendTimestamp != nil {
sendTimestamp = langext.Ptr(timeext.UnixFloatSeconds(*SendTimestamp))
2022-11-19 15:13:47 +01:00
}
2022-11-30 21:39:14 +01:00
priority := langext.Coalesce(Priority, user.DefaultPriority())
2022-11-19 15:13:47 +01:00
clientIP := g.ClientIP()
msg, err := h.database.CreateMessage(ctx, *UserID, channel, sendTimestamp, *Title, Content, priority, UserMessageID, clientIP, SenderName)
2022-11-19 15:13:47 +01:00
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to create message in db", err)
2022-11-19 15:13:47 +01:00
}
subscriptions, err := h.database.ListSubscriptionsByChannel(ctx, channel.ChannelID)
2022-11-19 15:13:47 +01:00
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to query subscriptions", err)
2022-11-19 15:13:47 +01:00
}
err = h.database.IncUserMessageCounter(ctx, user)
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to inc user msg-counter", err)
}
err = h.database.IncChannelMessageCounter(ctx, channel)
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to inc channel msg-counter", err)
}
2022-11-19 15:13:47 +01:00
for _, sub := range subscriptions {
clients, err := h.database.ListClients(ctx, sub.SubscriberUserID)
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to query clients", err)
2022-11-19 15:13:47 +01:00
}
if !sub.Confirmed {
continue
}
2022-11-19 15:13:47 +01:00
for _, client := range clients {
2022-11-20 15:40:19 +01:00
fcmDelivID, err := h.app.DeliverMessage(ctx, client, msg)
2022-11-19 15:13:47 +01:00
if err != nil {
_, err = h.database.CreateRetryDelivery(ctx, client, msg)
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to create delivery", err)
2022-11-19 15:13:47 +01:00
}
} else {
_, err = h.database.CreateSuccessDelivery(ctx, client, msg, *fcmDelivID)
if err != nil {
2022-11-30 17:58:04 +01:00
return ginresp.SendAPIError(g, 500, apierr.DATABASE_ERROR, hl.NONE, "Failed to create delivery", err)
2022-11-19 15:13:47 +01:00
}
}
}
}
2022-11-20 03:06:08 +01:00
return ctx.FinishSuccess(ginresp.JSON(http.StatusOK, response{
Success: true,
ErrorID: apierr.NO_ERROR,
ErrorHighlight: -1,
Message: "Message sent",
SuppressSend: false,
MessageCount: user.MessagesSent + 1,
Quota: user.QuotaUsedToday() + 1,
IsPro: user.IsPro,
QuotaMax: user.QuotaPerDay(),
SCNMessageID: msg.SCNMessageID,
2022-11-20 03:06:08 +01:00
}))
2022-11-18 21:25:40 +01:00
}