Add discord integration

Author: AchoArnold

api/cmd/fcm/main.go

@@ -5,7 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"math/rand"
 	"net/http"
@@ -83,7 +83,7 @@ func createSmsMessage() error {
 		return stacktrace.Propagate(err, "cannot do http request")
 	}
 
-	body, err := ioutil.ReadAll(response.Body)
+	body, err := io.ReadAll(response.Body)
 	if err != nil {
 		return stacktrace.Propagate(err, "cannot read response body")
 	}

api/pkg/di/container.go

@@ -115,7 +115,9 @@ func NewContainer(projectID string, version string) (container *Container) {
 	container.RegisterWebhookListeners()
 
 	container.RegisterLemonsqueezyRoutes()
+
 	container.RegisterDiscordRoutes()
+	container.RegisterDiscordListeners()
 
 	// this has to be last since it registers the /* route
 	container.RegisterSwaggerRoutes()
@@ -641,6 +643,7 @@ func (container *Container) DiscordService() (service *services.DiscordService)
 		container.Tracer(),
 		container.DiscordClient(),
 		container.DiscordRepository(),
+		container.EventDispatcher(),
 	)
 }
 
@@ -860,6 +863,9 @@ func (container *Container) DiscordHandler() (handler *handlers.DiscordHandler)
 		container.Tracer(),
 		container.DiscordHandlerValidator(),
 		container.DiscordService(),
+		container.MessageService(),
+		container.BillingService(),
+		container.MessageHandlerValidator(),
 	)
 }
 
@@ -976,6 +982,20 @@ func (container *Container) RegisterBillingListeners() {
 	}
 }
 
+// RegisterDiscordListeners registers event listeners for listeners.DiscordListener
+func (container *Container) RegisterDiscordListeners() {
+	container.logger.Debug(fmt.Sprintf("registering listeners for %T", listeners.DiscordListener{}))
+	_, routes := listeners.NewDiscordListener(
+		container.Logger(),
+		container.Tracer(),
+		container.DiscordService(),
+	)
+
+	for event, handler := range routes {
+		container.EventDispatcher().Subscribe(event, handler)
+	}
+}
+
 // RegisterWebhookListeners registers event listeners for listeners.WebhookListener
 func (container *Container) RegisterWebhookListeners() {
 	container.logger.Debug(fmt.Sprintf("registering listeners for %T", listeners.WebhookListener{}))

api/pkg/discord/channel_service.go

@@ -13,7 +13,7 @@ type ChannelService service
 // CreateMessage sends a message to a guild text or DM channel.
 //
 // API Docs: https://discord.com/developers/docs/resources/channel#create-message
-func (service *ChannelService) CreateMessage(ctx context.Context, channelID string, payload map[string]any) (*map[string]any, *Response, error) {
+func (service *ChannelService) CreateMessage(ctx context.Context, channelID string, payload map[string]any) (map[string]any, *Response, error) {
 	request, err := service.client.newRequest(ctx, http.MethodPost, fmt.Sprintf("/channels/%s/messages", channelID), payload)
 	if err != nil {
 		return nil, nil, err
@@ -24,8 +24,8 @@ func (service *ChannelService) CreateMessage(ctx context.Context, channelID stri
 		return nil, response, err
 	}
 
-	message := new(map[string]any)
-	if err = json.Unmarshal(*response.Body, message); err != nil {
+	message := map[string]any{}
+	if err = json.Unmarshal(*response.Body, &message); err != nil {
 		return nil, response, err
 	}
 
@@ -35,7 +35,7 @@ func (service *ChannelService) CreateMessage(ctx context.Context, channelID stri
 // Get a channel by ID
 //
 // API Docs: https://discord.com/developers/docs/resources/channel#get-channel
-func (service *ChannelService) Get(ctx context.Context, channelID string) (*map[string]any, *Response, error) {
+func (service *ChannelService) Get(ctx context.Context, channelID string) (map[string]any, *Response, error) {
 	request, err := service.client.newRequest(ctx, http.MethodGet, fmt.Sprintf("/channels/%s", channelID), nil)
 	if err != nil {
 		return nil, nil, err
@@ -46,8 +46,8 @@ func (service *ChannelService) Get(ctx context.Context, channelID string) (*map[
 		return nil, response, err
 	}
 
-	channel := new(map[string]any)
-	if err = json.Unmarshal(*response.Body, channel); err != nil {
+	channel := map[string]any{}
+	if err = json.Unmarshal(*response.Body, &channel); err != nil {
 		return nil, response, err
 	}
 

api/pkg/events/discord_message_failed_event.go

@@ -0,0 +1,20 @@
+package events
+
+import (
+	"github.com/NdoleStudio/httpsms/pkg/entities"
+	"github.com/google/uuid"
+)
+
+// EventTypeDiscordMessageFailed is emitted when we can't send a discord message
+const EventTypeDiscordMessageFailed = "discord.message.failed"
+
+// DiscordMessageFailedPayload is the payload of the EventTypeDiscordMessageFailed event
+type DiscordMessageFailedPayload struct {
+	DiscordID        uuid.UUID       `json:"discord_id"`
+	UserID           entities.UserID `json:"user_id"`
+	MessageID        uuid.UUID       `json:"message_id"`
+	EventType        string          `json:"event_type"`
+	HTTPStatusCode   int             `json:"http_status_code"`
+	ErrorMessage     string          `json:"error_message"`
+	DiscordChannelID string          `json:"discord_channel_id"`
+}

api/pkg/handlers/discord_handler.go

@@ -2,12 +2,15 @@ package handlers
 
 import (
 	"bytes"
+	"context"
 	"crypto/ed25519"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"os"
 
+	"github.com/NdoleStudio/httpsms/pkg/entities"
+
 	"github.com/google/uuid"
 
 	"github.com/NdoleStudio/httpsms/pkg/repositories"
@@ -23,10 +26,13 @@ import (
 // DiscordHandler handles discord events
 type DiscordHandler struct {
 	handler
-	logger    telemetry.Logger
-	tracer    telemetry.Tracer
-	validator *validators.DiscordHandlerValidator
-	service   *services.DiscordService
+	logger           telemetry.Logger
+	tracer           telemetry.Tracer
+	billingService   *services.BillingService
+	messageValidator *validators.MessageHandlerValidator
+	validator        *validators.DiscordHandlerValidator
+	service          *services.DiscordService
+	messageService   *services.MessageService
 }
 
 // NewDiscordHandler creates a new DiscordHandler
@@ -35,12 +41,18 @@ func NewDiscordHandler(
 	tracer telemetry.Tracer,
 	validator *validators.DiscordHandlerValidator,
 	service *services.DiscordService,
+	messageService *services.MessageService,
+	billingService *services.BillingService,
+	messageValidator *validators.MessageHandlerValidator,
 ) (h *DiscordHandler) {
 	return &DiscordHandler{
-		logger:    logger.WithService(fmt.Sprintf("%T", h)),
-		tracer:    tracer,
-		validator: validator,
-		service:   service,
+		logger:           logger.WithService(fmt.Sprintf("%T", h)),
+		tracer:           tracer,
+		validator:        validator,
+		service:          service,
+		messageService:   messageService,
+		billingService:   billingService,
+		messageValidator: messageValidator,
 	}
 }
 
@@ -244,7 +256,7 @@ func (h *DiscordHandler) Store(c *fiber.Ctx) error {
 // @Failure      500		{object}	responses.InternalServerError
 // @Router       /discord/event [post]
 func (h *DiscordHandler) Event(c *fiber.Ctx) error {
-	_, span, ctxLogger := h.tracer.StartFromFiberCtxWithLogger(c, h.logger)
+	ctx, span, ctxLogger := h.tracer.StartFromFiberCtxWithLogger(c, h.logger)
 	defer span.End()
 
 	if verified := h.verifyInteraction(ctxLogger, c); !verified {
@@ -265,48 +277,147 @@ func (h *DiscordHandler) Event(c *fiber.Ctx) error {
 	}
 
 	if payload["type"].(float64) == 2 {
+		return h.sendSMS(ctx, c, payload)
+	}
+
+	return h.responseBadRequest(c, stacktrace.NewError(fmt.Sprintf("unknown type [%d]", payload["type"])))
+}
+
+func (h *DiscordHandler) createRequest(payload map[string]any) requests.MessageSend {
+	getOption := func(name string) string {
+		for _, option := range payload["data"].(map[string]any)["options"].([]any) {
+			if option.(map[string]any)["name"].(string) == name {
+				return option.(map[string]any)["value"].(string)
+			}
+		}
+		return ""
+	}
+	return requests.MessageSend{
+		From:    getOption("from"),
+		To:      getOption("to"),
+		Content: getOption("message"),
+		SIM:     entities.SIMDefault,
+	}
+}
+
+func (h *DiscordHandler) sendSMS(ctx context.Context, c *fiber.Ctx, payload map[string]any) error {
+	_, span, ctxLogger := h.tracer.StartWithLogger(ctx, h.logger)
+	defer span.End()
+
+	discord, err := h.service.GetByServerID(ctx, payload["guild_id"].(string))
+	if err != nil {
+		msg := fmt.Sprintf("cannot get discord integration by server ID [%s]", payload["guild_id"].(string))
+		ctxLogger.Error(h.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg)))
 		return c.JSON(
 			fiber.Map{
 				"type": 4,
-				//"data": fiber.Map{
-				//	"content": "✔ sending sms*",
-				//},
 				"data": fiber.Map{
-					"content": "*⚠ could not send SMS message*",
+					"content": "**⚠️ error while sending message**",
 					"embeds": []fiber.Map{
 						{
-							"title": "The to field is not a valid phone number",
+							"title": "We cannot find the link to your discord server to an account on [httpsms.com](https://httpsms.com/settings).",
 							"color": 14681092,
 						},
+					},
+				},
+			},
+		)
+	}
+
+	request := h.createRequest(payload)
+	messageEmbed := fiber.Map{
+		"fields": []fiber.Map{
+			{
+				"name":   "From:",
+				"value":  request.From,
+				"inline": true,
+			},
+			{
+				"name":   "To:",
+				"value":  request.To,
+				"inline": true,
+			},
+			{
+				"name":  "Content:",
+				"value": request.Content,
+			},
+		},
+	}
+
+	if errors := h.messageValidator.ValidateMessageSend(ctx, discord.UserID, request.Sanitize()); len(errors) != 0 {
+		msg := fmt.Sprintf("validation errors [%s], while sending payload [%s]", spew.Sdump(errors), c.Body())
+		ctxLogger.Warn(stacktrace.NewError(msg))
+
+		var embeds []fiber.Map
+		for _, value := range errors {
+			embeds = append(embeds, fiber.Map{
+				"title": value[0],
+				"color": 14681092,
+			})
+		}
+
+		return c.JSON(
+			fiber.Map{
+				"type": 4,
+				"data": fiber.Map{
+					"content": "**⚠️ error while sending message**",
+					"embeds":  append(embeds, messageEmbed),
+				},
+			},
+		)
+	}
+
+	if msg := h.billingService.IsEntitled(ctx, discord.UserID); msg != nil {
+		ctxLogger.Warn(stacktrace.NewError(fmt.Sprintf("user with ID [%s] can't send a message", discord.UserID)))
+		return c.JSON(
+			fiber.Map{
+				"type": 4,
+				"data": fiber.Map{
+					"content": "**⚠️ error while sending message**",
+					"embeds": append([]fiber.Map{
 						{
-							"title": "The from field is not a valid phone number",
+							"title": msg,
 							"color": 14681092,
 						},
+					}, messageEmbed),
+				},
+			},
+		)
+	}
+
+	message, err := h.messageService.SendMessage(ctx, request.ToMessageSendParams(discord.UserID, c.OriginalURL()))
+	if err != nil {
+		msg := fmt.Sprintf("cannot send message with paylod [%s] from discord server [%s]", c.Body(), discord.ServerID)
+		ctxLogger.Error(stacktrace.Propagate(err, msg))
+		return c.JSON(
+			fiber.Map{
+				"type": 4,
+				"data": fiber.Map{
+					"content": "**Could not send the message⚠️**",
+					"embeds": append([]fiber.Map{
 						{
-							"fields": []fiber.Map{
-								{
-									"name":   "From:",
-									"value":  "+37259139660",
-									"inline": true,
-								},
-								{
-									"name":   "To:",
-									"value":  "+37259139661",
-									"inline": true,
-								},
-								{
-									"name":  "Content:",
-									"value": "Hello World",
-								},
-							},
+							"title": "Internal server error while sending SMS. Please try again later or contact support.",
+							"color": 14681092,
 						},
-					},
+					}, messageEmbed),
 				},
 			},
 		)
 	}
 
-	return h.responseBadRequest(c, stacktrace.NewError(fmt.Sprintf("unknown type [%d]", payload["type"])))
+	messageEmbed["fields"] = append(messageEmbed["fields"].([]fiber.Map), fiber.Map{
+		"name":  "MessageID:",
+		"value": message.ID,
+	})
+	return c.JSON(
+		fiber.Map{
+			"type": 4,
+			"data": fiber.Map{
+				"content": "✔ sending sms",
+				"embeds":  []fiber.Map{messageEmbed},
+			},
+		},
+	)
 }
 
 // verifyInteraction implements message verification of the discord interactions api