fix: improve number mapping

Author: gsanchietti

docs/DEPLOY_NS8.md

@@ -140,15 +140,43 @@ curl -s -X POST   https://synapse.gs.nethserver.net/m2a/api/client/send_message
 
 Map SMS number (201) to Matrix user (giacomo):
 ```
-
 curl -v -X POST "http://127.0.0.1:8080/api/internal/map_sms_to_matrix"   -H "Content-Type: application/json"   -H "X-Super-Admin-Token: secret"   -d '{
   "sms_number": "201",
   "matrix_id": "@giacomo:synapse.gs.nethserver.net",
   "room_id": "!giacomo-room:synapse.gs.nethserver.net"
 }'
 ```
 
-Retrieve current mapping:
+Map SMS number (202) to Matrix user (mario):
+```
+curl -v -X POST "http://127.0.0.1:8080/api/internal/map_sms_to_matrix"   -H "Content-Type: application/json"   -H "X-Super-Admin-Token: secret"   -d '{
+  "sms_number": "202",
+  "matrix_id": "@mario:synapse.gs.nethserver.net",
+  "room_id": "!mario-room:synapse.gs.nethserver.net"
+}'
+```
+
+Retrieve current mappings:
+```
+curl "http://127.0.0.1:8080/api/internal/map_sms_to_matrix" -H "X-Super-Admin-Token: secret"
 ```
-curl -v -G "http://127.0.0.1:8080/api/internal/map_sms_to_matrix"   -H "X-Super-Admin-Token: secret"   --data-urlencode "sms_number=201"
+
+Send message using mapped SMS number (201) - Giacomo to Mario:
 ```
+curl -s -X POST   https://synapse.gs.nethserver.net/m2a/api/client/send_message   -H "Content-Type: application/json"   -d '{
+    "from": "@giacomo:synapse.gs.nethserver.net",
+    "sms_to": "202",
+    "sms_body": "Hello Mario — this is Giacomo (curl test using mapped number)",
+    "content_type": "text/plain"
+  }'
+```
+
+Send message using mapped SMS number (202) - Mario to Giacomo:
+```
+curl -s -X POST   https://synapse.gs.nethserver.net/m2a/api/client/send_message   -H "Content-Type: application/json"   -d '{
+    "from": "@mario:synapse.gs.nethserver.net",
+    "sms_to": "201",
+    "sms_body": "Hello Giacomo — this is Mario reply (curl test using mapped number)",
+    "content_type": "text/plain"
+  }'
+```

docs/openapi.yaml

@@ -54,6 +54,14 @@ paths:
       operationId: sendMessage
       description: |
         Sends an outgoing message on behalf of a user.
+
+        The `from` field can be:
+        - A full Matrix ID (e.g., @user:server.com) - used directly
+        - A phone number (e.g., +1234567890) - resolved to Matrix ID via SMS-to-Matrix mapping if available
+
+        If a phone number is provided and a mapping exists, the message is sent on behalf of the mapped Matrix user.
+        If a phone number is provided but no mapping exists, the phone number is used as the sender ID.
+
         Authentication is handled by the Application Service backend; the `password` field is ignored.
       requestBody:
         required: true
@@ -68,7 +76,7 @@ paths:
               properties:
                 from:
                   type: string
-                  description: The full Matrix ID (e.g., @user:server.com) of the user to impersonate.
+                  description: The sender - either a full Matrix ID (e.g., @user:server.com) or a phone number (e.g., +1234567890).
                 password:
                   type: string
                   description: This field is ignored. Kept for client compatibility.

main_test.go

@@ -14,12 +14,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
 	"github.com/nethesis/matrix2acrobits/api"
 	"github.com/nethesis/matrix2acrobits/matrix"
 	"github.com/nethesis/matrix2acrobits/models"
 	"github.com/nethesis/matrix2acrobits/service"
-	"github.com/labstack/echo/v4"
-	"github.com/labstack/echo/v4/middleware"
 	"maunium.net/go/mautrix/id"
 )
 
@@ -420,6 +420,112 @@ func TestIntegration_MappingAPI(t *testing.T) {
 	})
 }
 
+func TestIntegration_SendMessageWithPhoneNumberMapping(t *testing.T) {
+	cfg := checkTestEnv(t)
+
+	// This test verifies that phone numbers in the 'from' field are resolved to Matrix IDs via mapping
+	if os.Getenv("RUN_INTEGRATION_TESTS") == "" {
+		t.Skip("Skipping integration tests; set RUN_INTEGRATION_TESTS=1 to run.")
+	}
+
+	server, err := startTestServer(cfg)
+	if err != nil {
+		t.Fatalf("failed to start test server: %v", err)
+	}
+	defer stopTestServer(server)
+
+	baseURL := "http://127.0.0.1:" + testServerPort
+	user1Localpart := getLocalpart(cfg.user1)
+	user2Localpart := getLocalpart(cfg.user2)
+	user1MatrixID := fmt.Sprintf("@%s:%s", user1Localpart, cfg.serverName)
+	user2MatrixID := fmt.Sprintf("@%s:%s", user2Localpart, cfg.serverName)
+
+	t.Run("SendMessageWithPhoneNumberFromField", func(t *testing.T) {
+		// Step 1: Create a room as user1
+		matrixClient, err := matrix.NewClient(matrix.Config{
+			HomeserverURL: cfg.homeserverURL,
+			AsUserID:      id.UserID(cfg.asUser),
+			AsToken:       cfg.adminToken,
+		})
+		if err != nil {
+			t.Fatalf("failed to create matrix client: %v", err)
+		}
+
+		roomName := fmt.Sprintf("Phone Test Room %d", time.Now().Unix())
+		createResp, err := matrixClient.CreateRoom(context.Background(), id.UserID(user1MatrixID), roomName, []id.UserID{id.UserID(user2MatrixID)})
+		if err != nil {
+			t.Fatalf("failed to create room: %v", err)
+		}
+		roomID := createResp.RoomID
+		t.Logf("Created room %s", roomID)
+
+		// Step 2: Join the room as user2
+		_, err = matrixClient.JoinRoom(context.Background(), id.UserID(user2MatrixID), roomID)
+		if err != nil {
+			t.Fatalf("failed for user2 to join room: %v", err)
+		}
+		t.Logf("User2 joined room %s", roomID)
+		time.Sleep(1 * time.Second)
+
+		// Step 3: Create a mapping from user1's phone number to user1's Matrix ID
+		phoneNumber := cfg.user1Number
+		mappingReq := models.MappingRequest{
+			SMSNumber: phoneNumber,
+			MatrixID:  user1MatrixID,
+			RoomID:    string(roomID),
+		}
+		headers := map[string]string{
+			"X-Super-Admin-Token": cfg.adminToken,
+		}
+		resp, body, err := doRequest("POST", baseURL+"/api/internal/map_sms_to_matrix", mappingReq, headers)
+		if err != nil {
+			t.Fatalf("failed to create mapping: %v", err)
+		}
+		if resp.StatusCode != http.StatusOK {
+			t.Fatalf("failed to create mapping: expected 200, got %d: %s", resp.StatusCode, string(body))
+		}
+		t.Logf("Created mapping: %s → %s", phoneNumber, user1MatrixID)
+
+		// Step 4: Send a message using the phone number as the 'from' field
+		sendReq := models.SendMessageRequest{
+			From:    phoneNumber, // Using phone number instead of Matrix ID
+			SMSTo:   string(roomID),
+			SMSBody: fmt.Sprintf("Message from phone number %d", time.Now().Unix()),
+		}
+		resp, body, err = doRequest("POST", baseURL+"/api/client/send_message", sendReq, nil)
+		if err != nil {
+			t.Fatalf("send message request failed: %v", err)
+		}
+		if resp.StatusCode != http.StatusOK {
+			t.Fatalf("expected 200, got %d: %s", resp.StatusCode, string(body))
+		}
+		var sendResp models.SendMessageResponse
+		if err := json.Unmarshal(body, &sendResp); err != nil {
+			t.Fatalf("failed to parse response: %v", err)
+		}
+		t.Logf("Message sent from phone number: %s", sendResp.SMSID)
+
+		// Step 5: Verify that user2 sees the message from the mapped Matrix user (user1)
+		time.Sleep(2 * time.Second)
+		fetchResp, err := fetchMessagesWithRetry(t, baseURL, user2MatrixID, 10*time.Second)
+		if err != nil {
+			t.Fatalf("fetch messages failed: %v", err)
+		}
+
+		foundPhoneMessage := false
+		for _, msg := range fetchResp.ReceivedSMSS {
+			if strings.Contains(msg.SMSText, "Message from phone number") && msg.Sender == user1MatrixID {
+				foundPhoneMessage = true
+				t.Logf("User2 received message from phone-mapped user: sender=%s, text=%s", msg.Sender, msg.SMSText)
+				break
+			}
+		}
+		if !foundPhoneMessage {
+			t.Errorf("user2 did not receive message sent from phone number mapping")
+		}
+	})
+}
+
 func TestIntegration_RoomMessaging(t *testing.T) {
 	cfg := checkTestEnv(t)
 

service/messages.go

@@ -56,6 +56,18 @@ func (s *MessageService) SendMessage(ctx context.Context, req *models.SendMessag
 		return nil, ErrAuthentication
 	}
 
+	// If 'From' is a phone number, try to map it to a Matrix user
+	if isPhoneNumber(req.From) {
+		logger.Debug().Str("from", req.From).Msg("sender is a phone number, attempting to resolve to Matrix user")
+		if entry, ok := s.getMapping(req.From); ok && entry.MatrixID != "" {
+			resolvedUserID := id.UserID(entry.MatrixID)
+			logger.Info().Str("phone_number", req.From).Str("matrix_id", entry.MatrixID).Msg("phone number mapped to Matrix user")
+			userID = resolvedUserID
+		} else {
+			logger.Warn().Str("phone_number", req.From).Msg("phone number mapping not found, using original sender ID")
+		}
+	}
+
 	logger.Debug().Str("user_id", string(userID)).Str("recipient", req.SMSTo).Msg("resolving recipient")
 
 	roomID, err := s.resolveRecipient(ctx, userID, req.SMSTo)
@@ -319,3 +331,34 @@ func mapAuthErr(err error) error {
 	}
 	return err
 }
+
+// isPhoneNumber checks if a string looks like a phone number.
+// Returns true if the string contains only digits, spaces, hyphens, plus signs, and/or parentheses.
+func isPhoneNumber(s string) bool {
+	if s == "" {
+		return false
+	}
+	trimmed := strings.TrimSpace(s)
+	// Check if it starts with @ or ! or #, indicating it's a Matrix ID/room ID/alias
+	if strings.HasPrefix(trimmed, "@") || strings.HasPrefix(trimmed, "!") || strings.HasPrefix(trimmed, "#") {
+		return false
+	}
+	// A phone number contains only digits and optional formatting characters
+	for _, r := range trimmed {
+		if !isPhoneNumberRune(r) {
+			return false
+		}
+	}
+	// Must contain at least one digit
+	for _, r := range trimmed {
+		if r >= '0' && r <= '9' {
+			return true
+		}
+	}
+	return false
+}
+
+// isPhoneNumberRune checks if a rune is a valid character in a phone number
+func isPhoneNumberRune(r rune) bool {
+	return (r >= '0' && r <= '9') || r == ' ' || r == '-' || r == '+' || r == '(' || r == ')'
+}

service/messages_test.go

@@ -194,3 +194,74 @@ func TestListMappings(t *testing.T) {
 		t.Fatalf("missing mapping for +222")
 	}
 }
+
+func TestIsPhoneNumber(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{
+			name:     "Simple phone number",
+			input:    "1234567890",
+			expected: true,
+		},
+		{
+			name:     "Phone with plus prefix",
+			input:    "+1234567890",
+			expected: true,
+		},
+		{
+			name:     "Phone with hyphens",
+			input:    "123-456-7890",
+			expected: true,
+		},
+		{
+			name:     "Phone with spaces",
+			input:    "123 456 7890",
+			expected: true,
+		},
+		{
+			name:     "Phone with parentheses",
+			input:    "(123) 456-7890",
+			expected: true,
+		},
+		{
+			name:     "Matrix user ID",
+			input:    "@user:example.com",
+			expected: false,
+		},
+		{
+			name:     "Room ID",
+			input:    "!room123:example.com",
+			expected: false,
+		},
+		{
+			name:     "Room alias",
+			input:    "#alias:example.com",
+			expected: false,
+		},
+		{
+			name:     "Empty string",
+			input:    "",
+			expected: false,
+		},
+		{
+			name:     "Only formatting chars",
+			input:    "+-() ",
+			expected: false,
+		},
+		{
+			name:     "With invalid characters",
+			input:    "123-ABC",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := isPhoneNumber(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}