phoenix/catapult
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tsk-8: Schedule message (#15)

Browse Source 
Closes #8

Reviewed-on: #15
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>
This commit is contained in:
phoenix
2025-11-29 19:28:05 +00:00
committed by phoenix
parent 9af11dc961
commit 04da7785c8
9 changed files with 367 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/app/app.go
+33 -3
View File
@@ -5,6 +5,7 @@ import (
"os"
"path"
"git.kundeng.us/phoenix/textsender-models/tx0/config"
"github.com/joho/godotenv"
)
@@ -15,6 +16,7 @@ type App struct {
AuthUrl string
ServiceUsername string
ServicePassphrase string
TwilioConfig *config.TwiloConfig
}
func Load() (*App, error) {
@@ -44,8 +46,36 @@ func Load() (*App, error) {
} else if len(servicePassphrase) == 0 {
return nil, fmt.Errorf("Service passphrase not provided")
} else {
return &App{
ApiUrl: apiUrl, AuthUrl: authUrl, ServiceUsername: serviceUsername, ServicePassphrase: servicePassphrase,
}, nil
if cfg, err := loadTwilioConfig(); err != nil {
return nil, err
} else {
return &App{
ApiUrl: apiUrl, AuthUrl: authUrl, ServiceUsername: serviceUsername, ServicePassphrase: servicePassphrase, TwilioConfig: cfg,
}, nil
}
}
}
func loadTwilioConfig() (*config.TwiloConfig, error) {
authSid := os.Getenv("TWILIO_AUTH_SID")
serviceSid := os.Getenv("TWILIO_SERVICE_SID")
authToken := os.Getenv("TWILIO_AUTH_TOKEN")
phoneNumber := os.Getenv("TWILIO_PHONE_NUMBER")
if len(authSid) == 0 {
return nil, fmt.Errorf("Twilio config auth sid not provided")
} else if len(serviceSid) == 0 {
return nil, fmt.Errorf("Twilio config service sid not provided")
} else if len(authToken) == 0 {
return nil, fmt.Errorf("Twilio config token not provided")
} else if len(phoneNumber) == 0 {
return nil, fmt.Errorf("Twilio config phone number not provided")
} else {
cfg := config.TwiloConfig{}
cfg.AccountSID = authSid
cfg.AuthToken = authToken
cfg.ServiceSID = serviceSid
cfg.Number = phoneNumber
return &cfg, nil
}
}
internal/service/contact.go
+58
View File
@@ -0,0 +1,58 @@
package service
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"git.kundeng.us/phoenix/textsender-models/tx0/contact"
"git.kundeng.us/phoenix/textsender-models/tx0/token"
"github.com/google/uuid"
"git.kundeng.us/phoenix/catapult/internal/app"
)
type Contact struct {
Application *app.App
Token *token.Login
}
type getContactResponse struct {
Message string `json:"message"`
Data []*contact.Contact `json:"data"`
}
func (c *Contact) GetContact(id uuid.UUID) (*contact.Contact, error) {
params := url.Values{}
params.Add("id", id.String())
pm := params.Encode()
fullUrl := fmt.Sprintf("%s/api/v1/contact?%s", c.Application.ApiUrl, pm)
fmt.Println("Url:", fullUrl)
req, err := http.NewRequest("GET", fullUrl, nil)
if err != nil {
return nil, err
}
token := c.Token.AccessToken
req.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var r getContactResponse
err = json.NewDecoder(resp.Body).Decode(&r)
if err != nil {
return nil, err
} else {
if len(r.Data) == 0 {
return nil, nil
} else {
return r.Data[0], nil
}
}
}
internal/service/core/service.go
+40 -2
View File
@@ -2,6 +2,7 @@ package core
import (
"context"
"encoding/json"
"fmt"
"log"
"sync"
@@ -66,18 +67,55 @@ func (s *Service) worker1() {
}
}
log.Println("Twilio config account sid:", s.App.TwilioConfig.AccountSID)
log.Println("Twilio config auth token:", s.App.TwilioConfig.AuthToken)
log.Println("Twilio config service sid:", s.App.TwilioConfig.ServiceSID)
log.Println("Twilio config number:", s.App.TwilioConfig.Number)
queue := service.Queue{Application: s.App, Token: s.token}
if item, exists, err := queue.GetQueue(); err != nil {
fmt.Println("Error:", err)
} else {
if *exists {
fmt.Println("Id:", item.Id)
fmt.Println("Scheduled message Id:", item.Id)
fmt.Println("Created:", item.Created)
fmt.Println("Scheduled:", item.Scheduled)
fmt.Println("Status:", item.Status)
fmt.Println("User Id:", item.UserId)
log.Println("User Id:", item.UserId)
if scheduledMessageValid(item, now) {
fmt.Println("Scheduled Message can be sent")
scheduler := service.Scheduler{Application: s.App, Token: s.token}
if events, err := scheduler.GetEvents(item.Id); err != nil {
fmt.Println("Error getting event:", err)
} else {
for _, event := range events {
if msg, err := scheduler.GetMessage(event.MessageId); err != nil {
fmt.Println("Error getting message:", err)
} else {
if c, err := scheduler.GetContact(event.RecipientId); err != nil {
fmt.Println("Error getting contact:", err)
} else {
fmt.Println("Message Id:", msg.Id)
fmt.Println("Contact Id:", c.Id)
if res, err := scheduler.ScheduleMessage(*item, *event, *c, *msg); err != nil {
log.Println("Failure with scheduling the message:", err)
} else {
if res != nil {
bytes, err := json.Marshal(res)
if err != nil {
log.Println("Error parsing result:", err)
} else {
jsonValue := string(bytes)
log.Println("Result:", jsonValue)
}
} else {
log.Println("Result should not be empty")
}
}
}
}
}
}
} else {
fmt.Println("Invalid scheduled message")
}
internal/service/message.go
+58
View File
@@ -0,0 +1,58 @@
package service
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"git.kundeng.us/phoenix/textsender-models/tx0/message"
"git.kundeng.us/phoenix/textsender-models/tx0/token"
"github.com/google/uuid"
"git.kundeng.us/phoenix/catapult/internal/app"
)
type Message struct {
Application *app.App
Token *token.Login
}
type getMessageResponse struct {
Message string `json:"message"`
Data []*message.Message `json:"data"`
}
func (m *Message) GetMessage(id uuid.UUID) (*message.Message, error) {
params := url.Values{}
params.Add("id", id.String())
pm := params.Encode()
fullUrl := fmt.Sprintf("%s/api/v1/message?%s", m.Application.ApiUrl, pm)
fmt.Println("Url:", fullUrl)
req, err := http.NewRequest("GET", fullUrl, nil)
if err != nil {
return nil, err
}
token := m.Token.AccessToken
req.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var r getMessageResponse
err = json.NewDecoder(resp.Body).Decode(&r)
if err != nil {
return nil, err
} else {
if len(r.Data) == 0 {
return nil, nil
} else {
return r.Data[0], nil
}
}
}
internal/service/scheduled_message_event.go
+59
View File
@@ -0,0 +1,59 @@
package service
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"github.com/google/uuid"
"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
"git.kundeng.us/phoenix/textsender-models/tx0/token"
"git.kundeng.us/phoenix/catapult/internal/app"
)
type ScheduledMessageEvent struct {
Application *app.App
Token *token.Login
}
type getScheduledMessageEventResponse struct {
Message string `json:"message"`
Data []*scheduling.ScheduledMessageEvent `json:"data"`
}
func (s *ScheduledMessageEvent) GetEvents(scheduledMessageId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error) {
params := url.Values{}
params.Add("scheduled_message_id", scheduledMessageId.String())
pm := params.Encode()
fullUrl := fmt.Sprintf("%s/api/v1/schedule/message/event?%s", s.Application.ApiUrl, pm)
req, err := http.NewRequest("GET", fullUrl, nil)
if err != nil {
return nil, err
}
token := s.Token.AccessToken
req.Header.Set("Authorization", "Bearer "+token)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var r getScheduledMessageEventResponse
err = json.NewDecoder(resp.Body).Decode(&r)
if err != nil {
return nil, err
} else {
if len(r.Data) == 0 {
return nil, nil
} else {
return r.Data, nil
}
}
}
internal/service/scheduler.go
+58
View File
@@ -0,0 +1,58 @@
package service
import (
"fmt"
"git.kundeng.us/phoenix/swoosh/swoop/send"
"git.kundeng.us/phoenix/swoosh/swoop/types"
"git.kundeng.us/phoenix/textsender-models/tx0/contact"
"git.kundeng.us/phoenix/textsender-models/tx0/message"
"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
"git.kundeng.us/phoenix/textsender-models/tx0/token"
"github.com/google/uuid"
"git.kundeng.us/phoenix/catapult/internal/app"
)
type Scheduler struct {
Application *app.App
Token *token.Login
}
func (s *Scheduler) GetEvents(scheduledMessageId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error) {
sme := ScheduledMessageEvent{Application: s.Application, Token: s.Token}
if events, err := sme.GetEvents(scheduledMessageId); err != nil {
return nil, err
} else {
return events, nil
}
}
func (s *Scheduler) GetMessage(id uuid.UUID) (*message.Message, error) {
msg := Message{Application: s.Application, Token: s.Token}
if letter, err := msg.GetMessage(id); err != nil {
return nil, err
} else {
return letter, nil
}
}
func (s *Scheduler) GetContact(id uuid.UUID) (*contact.Contact, error) {
ctct := Contact{Application: s.Application, Token: s.Token}
if c, err := ctct.GetContact(id); err != nil {
return nil ,err
} else {
return c, nil
}
}
func (s *Scheduler) ScheduleMessage(schMsg scheduling.ScheduledMessage, event scheduling.ScheduledMessageEvent, c contact.Contact, msg message.Message) (*types.TwilioResult, error) {
msgSender := send.MessageSender{Config: s.Application.TwilioConfig}
if res, err := msgSender.Send(msg, c, &schMsg.Scheduled); err != nil {
return nil, err
} else {
fmt.Println(res.AccountSid)
return res, nil
}
}