Add the ability to store phone call events

Author: AchoArnold

android/app/src/main/java/com/httpsms/HttpSmsApiService.kt

@@ -111,7 +111,7 @@ class HttpSmsApiService(private val apiKey: String, private val baseURL: URI) {
         """.trimIndent()
 
         val request: Request = Request.Builder()
-            .url(resolveURL("/v1/calls/missed"))
+            .url(resolveURL("/v1/messages/calls/missed"))
             .post(body.toRequestBody(jsonMediaType))
             .header(apiKeyHeader, apiKey)
             .header(clientVersionHeader, BuildConfig.VERSION_NAME)
@@ -121,7 +121,7 @@ class HttpSmsApiService(private val apiKey: String, private val baseURL: URI) {
         if (!response.isSuccessful) {
             Timber.e("error response [${response.body?.string()}] with code [${response.code}] while sending missed call event [${body}]")
             response.close()
-            return false
+            return response.code == 422
         }
 
         response.close()

api/pkg/entities/message.go

@@ -15,6 +15,9 @@ const (
 
 	// MessageTypeMobileOriginated means the message comes directly from a mobile phone
 	MessageTypeMobileOriginated = "mobile-originated"
+
+	// MessageTypeCallMissed means the message is generated when a phone call is missed by the android phone
+	MessageTypeCallMissed = "call/missed"
 )
 
 // MessageStatus is the status of the message
@@ -33,7 +36,7 @@ const (
 	// MessageStatusSent means the message has already sent by the mobile phone
 	MessageStatusSent = "sent"
 
-	// MessageStatusReceived means the message was received by tne mobile phone (MO)
+	// MessageStatusReceived means the message was received by the mobile phone (MO) or a phone call is missed by the mobile phone
 	MessageStatusReceived = "received"
 
 	// MessageStatusFailed means the mobile phone could not send the message

api/pkg/events/message_call_missed_event.go

@@ -0,0 +1,22 @@
+package events
+
+import (
+	"time"
+
+	"github.com/NdoleStudio/httpsms/pkg/entities"
+
+	"github.com/google/uuid"
+)
+
+// MessageCallMissed is emitted when a new message is sent
+const MessageCallMissed = "message.call.missed"
+
+// MessageCallMissedPayload is the payload of the MessageCallMissed event
+type MessageCallMissedPayload struct {
+	MessageID uuid.UUID       `json:"message_id"`
+	UserID    entities.UserID `json:"user_id"`
+	Owner     string          `json:"owner"`
+	Contact   string          `json:"contact"`
+	Timestamp time.Time       `json:"timestamp"`
+	SIM       entities.SIM    `json:"sim"`
+}

api/pkg/handlers/message_handler.go

@@ -52,6 +52,7 @@ func (h *MessageHandler) RegisterRoutes(router fiber.Router) {
 	router.Post("/messages/send", h.PostSend)
 	router.Post("/messages/bulk-send", h.BulkSend)
 	router.Post("/messages/receive", h.PostReceive)
+	router.Post("/messages/calls/missed", h.PostCallMissed)
 	router.Get("/messages/outstanding", h.GetOutstanding)
 	router.Get("/messages", h.Index)
 	router.Post("/messages/:messageID/events", h.PostEvent)
@@ -417,3 +418,47 @@ func (h *MessageHandler) Delete(c *fiber.Ctx) error {
 
 	return h.responseNoContent(c, "message deleted successfully")
 }
+
+// PostCallMissed registers a missed phone call
+// @Summary      Register a missed call event on the mobile phone
+// @Description  This endpoint is called by the httpSMS android app to register a missed call event on the mobile phone.
+// @Security	 ApiKeyAuth
+// @Tags         Messages
+// @Accept       json
+// @Produce      json
+// @Param        payload   	body 		requests.MessageCallMissed  	true	"Payload of the missed call event."
+// @Success      200  		{object} 	responses.MessageResponse
+// @Failure      400  		{object}  	responses.BadRequest
+// @Failure 	 401    	{object}	responses.Unauthorized
+// @Failure 	 404		{object}	responses.NotFound
+// @Failure      422  		{object} 	responses.UnprocessableEntity
+// @Failure      500  		{object}  	responses.InternalServerError
+// @Router       /messages/calls/missed [post]
+func (h *MessageHandler) PostCallMissed(c *fiber.Ctx) error {
+	ctx, span := h.tracer.StartFromFiberCtx(c)
+	defer span.End()
+
+	ctxLogger := h.tracer.CtxLogger(h.logger, span)
+
+	var request requests.MessageCallMissed
+	if err := c.BodyParser(&request); err != nil {
+		msg := fmt.Sprintf("cannot marshall [%s] into %T", c.Body(), request)
+		ctxLogger.Warn(stacktrace.Propagate(err, msg))
+		return h.responseBadRequest(c, err)
+	}
+
+	if errors := h.validator.ValidateCallMissed(ctx, request.Sanitize()); len(errors) != 0 {
+		msg := fmt.Sprintf("validation errors [%s], for missed call event [%s]", spew.Sdump(errors), c.Body())
+		ctxLogger.Warn(stacktrace.NewError(msg))
+		return h.responseUnprocessableEntity(c, errors, "validation errors while storing missed call event")
+	}
+
+	message, err := h.service.RegisterMissedCall(ctx, request.ToCallMissedParams(h.userIDFomContext(c), c.OriginalURL()))
+	if err != nil {
+		msg := fmt.Sprintf("cannot store missed call event for user [%s] with paylod [%s]", h.userIDFomContext(c), c.Body())
+		ctxLogger.Error(h.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg)))
+		return h.responseInternalServerError(c)
+	}
+
+	return h.responseOK(c, "missed call event stored successfully", message)
+}

api/pkg/requests/message_call_missed_request.go

@@ -0,0 +1,42 @@
+package requests
+
+import (
+	"time"
+
+	"github.com/NdoleStudio/httpsms/pkg/entities"
+
+	"github.com/nyaruka/phonenumbers"
+
+	"github.com/NdoleStudio/httpsms/pkg/services"
+)
+
+// MessageCallMissed is the payload for sending and missed call event
+type MessageCallMissed struct {
+	request
+	From      string    `json:"from" example:"+18005550199"`
+	To        string    `json:"to" example:"+18005550100"`
+	SIM       string    `json:"sim" example:"SIM1"`
+	Timestamp time.Time `json:"timestamp" example:"2022-06-05T14:26:09.527976+03:00"`
+}
+
+// Sanitize sets defaults to MessageReceive
+func (input *MessageCallMissed) Sanitize() MessageCallMissed {
+	input.To = input.sanitizeAddress(input.To)
+	input.From = input.sanitizeAddress(input.From)
+	input.SIM = input.sanitizeSIM(input.SIM)
+
+	return *input
+}
+
+// ToCallMissedParams converts MessageCallMissed to services.MessageSendParams
+func (input *MessageCallMissed) ToCallMissedParams(userID entities.UserID, source string) *services.MissedCallParams {
+	to, _ := phonenumbers.Parse(input.From, phonenumbers.UNKNOWN_REGION)
+	return &services.MissedCallParams{
+		Source:    source,
+		Owner:     to,
+		Timestamp: input.Timestamp,
+		SIM:       entities.SIM(input.SIM),
+		UserID:    userID,
+		Contact:   input.From,
+	}
+}

api/pkg/requests/phone_update_request.go

@@ -32,9 +32,7 @@ type PhoneUpsert struct {
 func (input *PhoneUpsert) Sanitize() PhoneUpsert {
 	input.FcmToken = strings.TrimSpace(input.FcmToken)
 	input.PhoneNumber = input.sanitizeAddress(input.PhoneNumber)
-	if input.SIM == "" {
-		input.SIM = entities.SIM1.String()
-	}
+	input.SIM = input.sanitizeSIM(input.SIM)
 	return *input
 }
 

api/pkg/requests/request.go

@@ -6,18 +6,15 @@ import (
 	"strings"
 	"unicode"
 
+	"github.com/NdoleStudio/httpsms/pkg/entities"
+
 	"github.com/nyaruka/phonenumbers"
 )
 
 type request struct{}
 
-// getLimit gets the take as a string
 func (input *request) sanitizeAddress(value string) string {
-	value = strings.TrimRight(value, " ")
-	if len(value) > 0 && value[0] == ' ' {
-		value = strings.Replace(value, " ", "+", 1)
-	}
-
+	value = strings.TrimSpace(value)
 	if !strings.HasPrefix(value, "+") && input.isDigits(value) && len(value) > 9 {
 		value = "+" + value
 	}
@@ -43,6 +40,13 @@ func (input *request) sanitizeBool(value string) string {
 	return value
 }
 
+func (input *request) sanitizeSIM(value string) string {
+	if value == entities.SIM1.String() || value == entities.SIM2.String() {
+		return value
+	}
+	return entities.SIM1.String()
+}
+
 func (input *request) sanitizeURL(value string) string {
 	value = strings.TrimSpace(value)
 	website, err := url.Parse(value)

api/pkg/services/message_service.go

@@ -416,6 +416,55 @@ func (service *MessageService) SendMessage(ctx context.Context, params MessageSe
 	return message, err
 }
 
+// MissedCallParams parameters for sending a new message
+type MissedCallParams struct {
+	Owner     *phonenumbers.PhoneNumber
+	Contact   string
+	Source    string
+	SIM       entities.SIM
+	Timestamp time.Time
+	UserID    entities.UserID
+}
+
+// RegisterMissedCall a new message
+func (service *MessageService) RegisterMissedCall(ctx context.Context, params *MissedCallParams) (*entities.Message, error) {
+	ctx, span := service.tracer.Start(ctx)
+	defer span.End()
+
+	ctxLogger := service.tracer.CtxLogger(service.logger, span)
+
+	eventPayload := &events.MessageCallMissedPayload{
+		MessageID: uuid.New(),
+		UserID:    params.UserID,
+		Timestamp: params.Timestamp,
+		Owner:     phonenumbers.Format(params.Owner, phonenumbers.E164),
+		Contact:   params.Contact,
+		SIM:       params.SIM,
+	}
+
+	event, err := service.createEvent(events.MessageCallMissed, params.Source, eventPayload)
+	if err != nil {
+		msg := fmt.Sprintf("cannot create [%T] from payload with message id [%s]", event, eventPayload.MessageID)
+		return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+	}
+
+	ctxLogger.Info(fmt.Sprintf("created event [%s] with id [%s] and message id [%s] and user [%s]", event.Type(), event.ID(), eventPayload.MessageID, eventPayload.UserID))
+
+	message, err := service.storeMissedCallMessage(ctx, eventPayload)
+	if err != nil {
+		msg := fmt.Sprintf("cannot store missed call message message with id [%s]", eventPayload.MessageID)
+		return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+	}
+
+	if err = service.eventDispatcher.Dispatch(ctx, event); err != nil {
+		msg := fmt.Sprintf("cannot dispatch event type [%s] and id [%s]", event.Type(), event.ID())
+		return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+	}
+
+	ctxLogger.Info(fmt.Sprintf("[%s] event with ID [%s] dispatched succesfully for message [%s] with user [%s]", event.Type(), event.ID(), eventPayload.MessageID, eventPayload.UserID))
+	return message, err
+}
+
 func (service *MessageService) getSendDelay(ctxLogger telemetry.Logger, eventPayload events.MessageAPISentPayload, sendAt *time.Time) time.Duration {
 	if sendAt == nil {
 		return time.Duration(0)
@@ -848,6 +897,36 @@ func (service *MessageService) storeSentMessage(ctx context.Context, payload eve
 	return message, nil
 }
 
+// storeMissedCallMessage a new message
+func (service *MessageService) storeMissedCallMessage(ctx context.Context, payload *events.MessageCallMissedPayload) (*entities.Message, error) {
+	ctx, span := service.tracer.Start(ctx)
+	defer span.End()
+
+	ctxLogger := service.tracer.CtxLogger(service.logger, span)
+
+	message := &entities.Message{
+		ID:                payload.MessageID,
+		Owner:             payload.Owner,
+		Contact:           payload.Contact,
+		UserID:            payload.UserID,
+		SIM:               payload.SIM,
+		Type:              entities.MessageTypeCallMissed,
+		Status:            entities.MessageStatusReceived,
+		RequestReceivedAt: payload.Timestamp,
+		CreatedAt:         time.Now().UTC(),
+		UpdatedAt:         time.Now().UTC(),
+		OrderTimestamp:    payload.Timestamp,
+	}
+
+	if err := service.repository.Store(ctx, message); err != nil {
+		msg := fmt.Sprintf("cannot save missed call message with id [%s]", payload.MessageID)
+		return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+	}
+
+	ctxLogger.Info(fmt.Sprintf("missed call message saved with id [%s]", payload.MessageID))
+	return message, nil
+}
+
 func (service *MessageService) createMessageSendExpiredEvent(source string, payload events.MessageSendExpiredPayload) (cloudevents.Event, error) {
 	return service.createEvent(events.EventTypeMessageSendExpired, source, payload)
 }

api/pkg/validators/message_handler_validator.go

@@ -228,3 +228,28 @@ func (validator MessageHandlerValidator) ValidateMessageEvent(_ context.Context,
 	})
 	return v.ValidateStruct()
 }
+
+// ValidateCallMissed validates the requests.MessageCallMissed request
+func (validator MessageHandlerValidator) ValidateCallMissed(_ context.Context, request requests.MessageCallMissed) url.Values {
+	v := govalidator.New(govalidator.Options{
+		Data: &request,
+		Rules: govalidator.MapData{
+			"to": []string{
+				"required",
+				phoneNumberRule,
+			},
+			"from": []string{
+				"required",
+			},
+			"sim": []string{
+				"required",
+				"in:" + strings.Join([]string{
+					string(entities.SIM1),
+					string(entities.SIM2),
+				}, ","),
+			},
+		},
+	})
+
+	return v.ValidateStruct()
+}

api/pkg/validators/validator.go

@@ -86,6 +86,7 @@ func init() {
 			events.EventTypeMessageSendExpired:    true,
 			events.EventTypePhoneHeartbeatOnline:  true,
 			events.EventTypePhoneHeartbeatOffline: true,
+			events.MessageCallMissed:              true,
 		}
 
 		for _, event := range input {