flash call

common.go

@@ -0,0 +1,6 @@
+package sigmasms
+
+type Payload struct {
+	Sender string `json:"sender"`
+	Text   string `json:"text"`
+}

flash_call.go

@@ -1,46 +1,105 @@
 package sigmasms
 
 import (
-	"bytes"
-	"encoding/json"
-	"net/http"
+	"crypto/rand"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/google/uuid"
 )
 
+/*
+{
+  "recipient": "+79999999999",
+  "type": "flashcall",
+  "payload": {
+    "sender": "Имя отправителя",
+    "text": "1234"
+  }
+}
+*/
+
 type FlashCallRequest struct {
-	APIKey  string `json:"api_key"`
-	Phone   string `json:"phone"`
-	CodeLen int    `json:"code_len"` // 4, 5, 6
+	Recepient string  `json:"recipient"`
+	Type      string  `json:"type"`
+	Payload   Payload `json:"payload"`
 }
 
 type FlashCallResponse struct {
-	Status string `json:"status"`
-	CallID string `json:"call_id"`
-	From   string `json:"from"` // номер, с которого звонили
-	Code   string `json:"code"` // обычно это последние digits из from
+	ID        uuid.UUID `json:"id"`
+	Price     float64   `json:"price"`
+	Recepient string    `json:"recipient"`
+	Status    string    `json:"status"`
+	Error     string    `json:"error"`
 }
 
-func FlashCall(apiKey, phone string, codeLen int) (*FlashCallResponse, error) {
-	body := FlashCallRequest{
-		APIKey:  apiKey,
-		Phone:   phone,
-		CodeLen: codeLen,
+// GenerateRandomDigits генерирует строку из четырёх случайных цифр.
+func GenerateFreshcCallCode() (string, error) {
+	var b [2]byte
+	_, err := rand.Read(b[:])
+	if err != nil {
+		return "", err
 	}
 
-	data, _ := json.Marshal(body)
+	// Превращаем 2 байта в число
+	num := int(b[0])<<8 | int(b[1])
+	// Ограничиваем диапазон 0–9999
+	num = num % 10000
 
-	resp, err := http.Post(
-		"https://voice.sigmasms.ru/flashcall",
-		"application/json",
-		bytes.NewReader(data),
-	)
+	// Возвращаем строку с ведущими нулями
+	return fmt.Sprintf("%04d", num), nil
+}
+
+func FlashCall(apiKey, phone, sender string, code string) (*FlashCallResponse, error) {
+	req := FlashCallRequest{
+		Recepient: phone,
+		Type:      "flashcall",
+		Payload: Payload{
+			Sender: sender,
+			Text:   code,
+		},
+	}
+
+	var resp FlashCallResponse
+
+	err := requestPost("https://user.sigmasms.ru/api/sendings", apiKey, &req, &resp)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
 
-	var result FlashCallResponse
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return nil, err
-	}
-	return &result, nil
+	return &resp, nil
+}
+
+func FlashCallWait(apiKey, phone, sender string, code string) (transactionID uuid.UUID, err error) {
+	var resp *FlashCallResponse
+	if resp, err = FlashCall(apiKey, phone, sender, code); err != nil {
+		log.Println(err)
+		return
+	} else {
+		if resp.Status == "failed" {
+			err = fmt.Errorf("flashcall send error: %s", resp.Error)
+			return
+		}
+		transactionID = resp.ID
+		var sResp *StatusResponse
+	mainLoop:
+		for resp.Status == "pending" {
+			time.Sleep(time.Millisecond * 100)
+			sResp, err = RequestStatus(resp.ID, apiKey)
+			if err != nil {
+				return
+			}
+			resp.Status = sResp.State.Status
+			switch resp.Status {
+			case "pending", "sent":
+				continue mainLoop
+			case "seen", "delivered":
+				return
+			default:
+				err = fmt.Errorf("sms status: %s", sResp.State.Status)
+			}
+		}
+	}
+	return
 }

flashcall_test.go

@@ -4,6 +4,8 @@ import (
 	"log"
 	"os"
 	"testing"
+
+	"github.com/google/uuid"
 )
 
 func loadToken(t *testing.T) string {
@@ -16,7 +18,20 @@ func loadToken(t *testing.T) string {
 
 func TestFlashCall(t *testing.T) {
 	token := loadToken(t)
-	log.Println(token)
+	code, _ := GenerateFreshcCallCode()
+	log.Println(code)
+	FlashCall(token, "+79857770038", "NG.Market", code)
+}
+
+func TestFlashCallWait(t *testing.T) {
+	token := loadToken(t)
+	code, _ := GenerateFreshcCallCode()
+	log.Println(code)
+	trID, err := FlashCallWait(token, "+79857770038", "NG.Market", code)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(trID)
 }
 
 func TestSMS(t *testing.T) {
@@ -28,3 +43,30 @@ func TestSMS(t *testing.T) {
 		"Привет",
 	)
 }
+
+func TestSMSWait(t *testing.T) {
+	token := loadToken(t)
+	trID, err := SendSMSWait(token, "+79857770038", "NG.Market", "Привет из Москвы :)")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(trID)
+}
+
+func TestStatus(t *testing.T) {
+	token := loadToken(t)
+	id, _ := uuid.Parse("518095e8-a62d-4af1-ad1f-2a56e955cf55")
+	status, err := RequestStatus(id, token)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(status)
+}
+
+func TestFreshCallCode(t *testing.T) {
+	code, err := GenerateFreshcCallCode()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log(code)
+}

request.go

@@ -9,6 +9,12 @@ import (
 	"net/url"
 )
 
+type ErrorCode struct {
+	Error   int    `json:"error"`
+	Name    string `json:"name"`
+	Message string `json:"message"`
+}
+
 func httpRequest(req *http.Request, resp any) error {
 	client := &http.Client{}
 
@@ -23,7 +29,13 @@ func httpRequest(req *http.Request, resp any) error {
 		return fmt.Errorf("http response read error: %w", err)
 	}
 
+	//log.Println(string(body))
+
 	if err = json.Unmarshal(body, resp); err != nil {
+		var rErr ErrorCode
+		if err = json.Unmarshal(body, &rErr); err == nil && rErr.Error != 0 {
+			return fmt.Errorf("error %d %s: %s", rErr.Error, rErr.Name, rErr.Message)
+		}
 		err = fmt.Errorf("http response unmarshal error: %w", err)
 	}
 	return err

sms.go

@@ -1,7 +1,9 @@
 package sigmasms
 
 import (
+	"fmt"
 	"log"
+	"time"
 
 	"github.com/google/uuid"
 )
@@ -21,11 +23,6 @@ var (
 	TypeSMS = "sms"
 )
 
-type Payload struct {
-	Sender string `json:"sender"`
-	Text   string `json:"text"`
-}
-
 type SendSMSResponse struct {
 	Error     string    `json:"error"`
 	ID        uuid.UUID `json:"id"`
@@ -50,7 +47,7 @@ func SendSMS(apiKey, phone, sender, text string) (*SendSMSResponse, error) {
 		},
 	}
 
-	resp := make(map[string]any)
+	var resp SendSMSResponse
 
 	err := requestPost(
 		"https://user.sigmasms.ru/api/sendings",
@@ -63,7 +60,38 @@ func SendSMS(apiKey, phone, sender, text string) (*SendSMSResponse, error) {
 		return nil, err
 	}
 
-	log.Println(resp)
-
-	return nil, nil
+	return &resp, nil
+}
+
+func SendSMSWait(apiKey, phone, sender, text string) (transactionID uuid.UUID, err error) {
+	var resp *SendSMSResponse
+	if resp, err = SendSMS(apiKey, phone, sender, text); err != nil {
+		log.Println(err)
+		return
+	} else {
+		if resp.Status == "failed" {
+			err = fmt.Errorf("sms send error: %s", resp.Error)
+			return
+		}
+		transactionID = resp.ID
+		var sResp *StatusResponse
+	mainLoop:
+		for resp.Status == "pending" {
+			time.Sleep(time.Millisecond * 100)
+			sResp, err = RequestStatus(resp.ID, apiKey)
+			if err != nil {
+				return
+			}
+			resp.Status = sResp.State.Status
+			switch resp.Status {
+			case "pending", "sent":
+				continue mainLoop
+			case "seen", "delivered":
+				return
+			default:
+				err = fmt.Errorf("sms status: %s", sResp.State.Status)
+			}
+		}
+	}
+	return
 }

status.go

@@ -1,9 +1,62 @@
 package sigmasms
 
-import "github.com/google/uuid"
+import (
+	"github.com/google/uuid"
+)
 
-func RequestStatus(id uuid.UUID, apiKey string) error {
-	url := "https://user.sigmasms.ru/api/sendings/" + id.String()
-	resp := make(map[string])
-	requestGet(url, apiKey, nil, )
+type RecepientData struct {
+	MCC      string `json:"mcc"`
+	MNC      string `json:"mnc"`
+	Code     string `json:"code"`
+	Type     string `json:"type"`
+	Group    string `json:"group"`
+	Operator string `json:"operator"`
+}
+
+type Billing struct {
+	ID       string  `json:"id"`
+	Amount   float64 `json:"amount"`
+	Refunded bool    `json:"refunded"`
+	TariffID string  `json:"TariffId"`
+}
+
+type Billings struct {
+	IDs []uuid.UUID `json:"ids"`
+}
+
+type Stats struct {
+	Segments   int `json:"segments"`
+	Characters int `json:"characters"`
+}
+
+type Meta struct {
+	Billing       Billing       `json:"billing"`
+	Billings      Billings      `json:"billings"`
+	Stats         Stats         `json:"stats"`
+	PatternID     bool          `json:"patternId"`
+	RecepientData RecepientData `json:"_recipientData"`
+}
+
+type State struct {
+	Status         string `json:"status"`
+	Error          bool   `json:"error"`
+	ExtendedStatus string `json:"extendedStatus"`
+}
+
+type StatusResponse struct {
+	ID        uuid.UUID `json:"id"`
+	ChainID   uuid.UUID `json:"chainId"`
+	Type      string    `json:"type"`
+	CreatedAt string    `json:"createdAt"`
+	UpdatedAt string    `json:"updatedAt"`
+	State     State     `json:"state"`
+	Meta      *Meta     `json:"meta"`
+	OwnerID   uuid.UUID `json:"OwnerId"`
+}
+
+// 9987bf00-c082-4dec-b25f-875eb528cf34
+func RequestStatus(id uuid.UUID, apiKey string) (resp *StatusResponse, err error) {
+	url := "https://user.sigmasms.ru/api/sendings/" + id.String()
+	err = requestGet(url, apiKey, nil, &resp)
+	return
 }

token.test

@@ -1 +0,0 @@
-b1eaeb6864933be52d8a203785c009fd6f33ccd557786836a8ca9ef3aa6b7aff