[lint] minor fixes

Author: capcom6

cmd/sms-gateway/main.go

@@ -7,6 +7,10 @@ import (
 	"github.com/android-sms-gateway/server/internal/worker"
 )
 
+const (
+	cmdWorker = "worker"
+)
+
 //	@securitydefinitions.basic	ApiAuth
 //	@description				User authentication
 
@@ -36,15 +40,15 @@ import (
 //	@host		api.sms-gate.app
 //	@schemes	https
 //
-// SMSGate Backend
+// SMSGate Backend.
 func main() {
 	args := os.Args[1:]
 	cmd := "start"
-	if len(args) > 0 && args[0] == "worker" {
-		cmd = "worker"
+	if len(args) > 0 && args[0] == cmdWorker {
+		cmd = cmdWorker
 	}
 
-	if cmd == "worker" {
+	if cmd == cmdWorker {
 		worker.Run()
 	} else {
 		smsgateway.Run()

go.mod

@@ -25,7 +25,6 @@ require (
 	go.uber.org/fx v1.24.0
 	go.uber.org/zap v1.27.0
 	golang.org/x/crypto v0.42.0
-	golang.org/x/exp v0.0.0-20240525044651-4c93da0ed11d
 	google.golang.org/api v0.148.0
 	gopkg.in/yaml.v3 v3.0.1
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde

go.sum

@@ -343,8 +343,6 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
 golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20240525044651-4c93da0ed11d h1:N0hmiNbwsSNwHBAvR3QB5w25pUwH4tK0Y/RltD1j1h4=
-golang.org/x/exp v0.0.0-20240525044651-4c93da0ed11d/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=

internal/sms-gateway/handlers/messages/3rdparty.go

@@ -2,7 +2,6 @@ package messages
 
 import (
 	"errors"
-	"fmt"
 	"strconv"
 	"time"
 
@@ -144,7 +143,14 @@ func (h *ThirdPartyController) post(user models.User, c *fiber.Ctx) error {
 			return fiber.NewError(fiber.StatusConflict, err.Error())
 		}
 
-		return fmt.Errorf("failed to enqueue message: %w", err)
+		h.Logger.Error(
+			"failed to enqueue message",
+			zap.Error(err),
+			zap.String("user_id", user.ID),
+			zap.String("device_id", req.DeviceID),
+		)
+
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to enqueue message. Please contact support")
 	}
 
 	location, err := c.GetRouteURL(route3rdPartyGetMessage, fiber.Map{

internal/sms-gateway/modules/devices/service.go

@@ -177,16 +177,16 @@ func (s *Service) Remove(userID string, filter ...SelectFilter) error {
 	}
 
 	for _, device := range devices {
-		if err := s.cache.DeleteByID(device.ID); err != nil {
+		if cacheErr := s.cache.DeleteByID(device.ID); cacheErr != nil {
 			s.logger.Error("failed to invalidate cache",
 				zap.String("device_id", device.ID),
-				zap.Error(err),
+				zap.Error(cacheErr),
 			)
 		}
 	}
 
-	if err := s.devices.Remove(filter...); err != nil {
-		return err
+	if rmErr := s.devices.Remove(filter...); rmErr != nil {
+		return rmErr
 	}
 
 	return nil

internal/sms-gateway/modules/messages/models.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/android-sms-gateway/server/internal/sms-gateway/models"
+	"github.com/samber/lo"
 	"gorm.io/gorm"
 )
 
@@ -54,6 +55,33 @@ type Message struct {
 	States     []MessageState     `gorm:"foreignKey:MessageID;constraint:OnDelete:CASCADE"`
 }
 
+func NewMessage(
+	extID string,
+	deviceID string,
+	phoneNumbers []string,
+	priority int8,
+	simNumber *uint8,
+	validUntil *time.Time,
+	withDeliveryReport bool,
+	isEncrypted bool,
+) *Message {
+	//nolint:exhaustruct // partial constructor
+	return &Message{
+		ExtID:    extID,
+		DeviceID: deviceID,
+		Recipients: lo.Map(phoneNumbers, func(item string, _ int) MessageRecipient {
+			return MessageRecipient{PhoneNumber: item, State: ProcessingStatePending}
+		}),
+		Priority:           priority,
+		SimNumber:          simNumber,
+		ValidUntil:         validUntil,
+		WithDeliveryReport: withDeliveryReport,
+		IsEncrypted:        isEncrypted,
+
+		State: ProcessingStatePending,
+	}
+}
+
 func (m *Message) SetTextContent(content TextMessageContent) error {
 	contentJSON, err := json.Marshal(content)
 	if err != nil {
@@ -73,7 +101,7 @@ func (m *Message) GetTextContent() (*TextMessageContent, error) {
 
 	content := new(TextMessageContent)
 
-	err := json.Unmarshal([]byte(m.Content), &content)
+	err := json.Unmarshal([]byte(m.Content), content)
 	if err != nil {
 		return nil, fmt.Errorf("failed to unmarshal text content: %w", err)
 	}

internal/sms-gateway/modules/messages/repository.go

@@ -155,7 +155,7 @@ func (r *Repository) UpdateState(message *Message) error {
 		}
 
 		for _, v := range message.Recipients {
-			if err := tx.Model(&MessageRecipient{}).
+			if err := tx.Model((*MessageRecipient)(nil)).
 				Where("message_id = ? AND phone_number = ?", message.ID, v.PhoneNumber).
 				Select("state", "error").
 				Updates(map[string]any{"state": v.State, "error": v.Error}).Error; err != nil {

internal/sms-gateway/modules/messages/service.go

@@ -173,91 +173,102 @@ func (s *Service) GetState(user models.User, id string) (*MessageStateOut, error
 	return dto, nil
 }
 
-func (s *Service) Enqueue(device models.Device, message MessageIn, opts EnqueueOptions) (MessageStateOut, error) {
-	state := MessageStateOut{
+func (s *Service) Enqueue(device models.Device, message MessageIn, opts EnqueueOptions) (*MessageStateOut, error) {
+	msg, err := s.prepareMessage(device, message, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	state := &MessageStateOut{
 		DeviceID: device.ID,
 		MessageStateIn: MessageStateIn{
-			State:      ProcessingStatePending,
-			Recipients: make([]smsgateway.RecipientState, len(message.PhoneNumbers)),
+			ID:    msg.ExtID,
+			State: ProcessingStatePending,
+			Recipients: lo.Map(
+				msg.Recipients,
+				func(item MessageRecipient, _ int) smsgateway.RecipientState { return modelToRecipientState(item) },
+			),
+			States: map[string]time.Time{},
 		},
+		IsHashed:    false,
+		IsEncrypted: msg.IsEncrypted,
+	}
+
+	if insErr := s.messages.Insert(msg); insErr != nil {
+		return state, insErr
 	}
 
+	if cacheErr := s.cache.Set(context.Background(), device.UserID, msg.ExtID, anys.AsPointer(modelToMessageState(*msg))); cacheErr != nil {
+		s.logger.Warn("failed to cache message", zap.String("id", msg.ExtID), zap.Error(cacheErr))
+	}
+	s.metrics.IncTotal(string(msg.State))
+
+	go func(userID, deviceID string) {
+		if ntfErr := s.eventsSvc.Notify(userID, &deviceID, events.NewMessageEnqueuedEvent()); ntfErr != nil {
+			s.logger.Error(
+				"failed to notify device",
+				zap.Error(ntfErr),
+				zap.String("user_id", userID),
+				zap.String("device_id", deviceID),
+			)
+		}
+	}(device.UserID, device.ID)
+
+	return state, nil
+}
+
+func (s *Service) prepareMessage(device models.Device, message MessageIn, opts EnqueueOptions) (*Message, error) {
 	var phone string
 	var err error
 	for i, v := range message.PhoneNumbers {
 		if message.IsEncrypted || opts.SkipPhoneValidation {
 			phone = v
 		} else {
 			if phone, err = cleanPhoneNumber(v); err != nil {
-				return state, fmt.Errorf("failed to use phone in row %d: %w", i+1, err)
+				return nil, fmt.Errorf("failed to use phone in row %d: %w", i+1, err)
 			}
 		}
 
 		message.PhoneNumbers[i] = phone
-
-		state.Recipients[i] = smsgateway.RecipientState{
-			PhoneNumber: phone,
-			State:       smsgateway.ProcessingStatePending,
-		}
 	}
 
 	validUntil := message.ValidUntil
 	if message.TTL != nil && *message.TTL > 0 {
-		validUntil = anys.AsPointer(time.Now().Add(time.Duration(*message.TTL) * time.Second))
+		//nolint:gosec // not a problem
+		validUntil = anys.AsPointer(
+			time.Now().Add(time.Duration(*message.TTL) * time.Second),
+		)
 	}
 
-	msg := Message{
-		ExtID:       message.ID,
-		Recipients:  s.recipientsToModel(message.PhoneNumbers),
-		IsEncrypted: message.IsEncrypted,
-
-		DeviceID: device.ID,
-
-		SimNumber:          message.SimNumber,
-		WithDeliveryReport: anys.OrDefault(message.WithDeliveryReport, true),
-
-		Priority:   int8(message.Priority),
-		ValidUntil: validUntil,
-	}
+	msg := NewMessage(
+		message.ID,
+		device.ID,
+		message.PhoneNumbers,
+		int8(message.Priority),
+		message.SimNumber,
+		validUntil,
+		anys.OrDefault(message.WithDeliveryReport, true),
+		message.IsEncrypted,
+	)
 
-	if message.TextContent != nil {
-		if err := msg.SetTextContent(*message.TextContent); err != nil {
-			return state, fmt.Errorf("failed to set text content: %w", err)
+	switch {
+	case message.TextContent != nil:
+		if setErr := msg.SetTextContent(*message.TextContent); setErr != nil {
+			return nil, fmt.Errorf("failed to set text content: %w", setErr)
 		}
-	} else if message.DataContent != nil {
-		if err := msg.SetDataContent(*message.DataContent); err != nil {
-			return state, fmt.Errorf("failed to set data content: %w", err)
+	case message.DataContent != nil:
+		if setErr := msg.SetDataContent(*message.DataContent); setErr != nil {
+			return nil, fmt.Errorf("failed to set data content: %w", setErr)
 		}
-	} else {
-		return state, ErrNoContent
+	default:
+		return nil, ErrNoContent
 	}
 
 	if msg.ExtID == "" {
 		msg.ExtID = s.idgen()
 	}
-	state.ID = msg.ExtID
 
-	if err := s.messages.Insert(&msg); err != nil {
-		return state, err
-	}
-
-	if err := s.cache.Set(context.Background(), device.UserID, msg.ExtID, anys.AsPointer(modelToMessageState(msg))); err != nil {
-		s.logger.Warn("failed to cache message", zap.String("id", msg.ExtID), zap.Error(err))
-	}
-	s.metrics.IncTotal(string(msg.State))
-
-	go func(userID, deviceID string) {
-		if err := s.eventsSvc.Notify(userID, &deviceID, events.NewMessageEnqueuedEvent()); err != nil {
-			s.logger.Error(
-				"failed to notify device",
-				zap.Error(err),
-				zap.String("user_id", userID),
-				zap.String("device_id", deviceID),
-			)
-		}
-	}(device.UserID, device.ID)
-
-	return state, nil
+	return msg, nil
 }
 
 func (s *Service) ExportInbox(device models.Device, since, until time.Time) error {
@@ -272,15 +283,6 @@ func (s *Service) ExportInbox(device models.Device, since, until time.Time) erro
 
 ///////////////////////////////////////////////////////////////////////////////
 
-func (s *Service) recipientsToModel(input []string) []MessageRecipient {
-	return lo.Map(
-		input,
-		func(item string, _ int) MessageRecipient {
-			return newMessageRecipient(item, ProcessingStatePending, nil)
-		},
-	)
-}
-
 func (s *Service) recipientsStateToModel(input []smsgateway.RecipientState, hash bool) []MessageRecipient {
 	output := make([]MessageRecipient, len(input))
 

internal/sms-gateway/modules/messages/workers.go

@@ -2,11 +2,13 @@ package messages
 
 import (
 	"context"
+	"slices"
 	"sync"
 	"time"
 
+	"maps"
+
 	"go.uber.org/zap"
-	"golang.org/x/exp/maps"
 )
 
 type hashingWorker struct {
@@ -27,6 +29,7 @@ func newHashingWorker(config Config, messages *Repository, logger *zap.Logger) *
 		logger:   logger,
 
 		queue: map[uint64]struct{}{},
+		mux:   sync.Mutex{},
 	}
 }
 
@@ -46,7 +49,7 @@ func (t *hashingWorker) Run(ctx context.Context) {
 	}
 }
 
-// Enqueue adds a message ID to the processing queue to be hashed in the next batch
+// Enqueue adds a message ID to the processing queue to be hashed in the next batch.
 func (t *hashingWorker) Enqueue(id uint64) {
 	t.mux.Lock()
 	t.queue[id] = struct{}{}
@@ -56,8 +59,8 @@ func (t *hashingWorker) Enqueue(id uint64) {
 func (t *hashingWorker) process(ctx context.Context) {
 	t.mux.Lock()
 
-	ids := maps.Keys(t.queue)
-	maps.Clear(t.queue)
+	ids := slices.AppendSeq(make([]uint64, 0, len(t.queue)), maps.Keys(t.queue))
+	clear(t.queue)
 
 	t.mux.Unlock()