Something went wrong. Try again.
Something went wrong. Try again.
tangled-alert-bot dm_handler.go
11 kB · 441 lines
Go
at send-alerts
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442package tangledalertbot
import ( "bytes" "context" "encoding/json" "fmt" "io" "log/slog" "net/http" "os" "strings" "time"
"github.com/pkg/errors")
const ( httpClientTimeoutDuration = time.Second * 5 transportIdleConnTimeoutDuration = time.Second * 90 baseBskyURL = "https://bsky.social/xrpc")
type auth struct { AccessJwt string `json:"accessJwt"` RefershJWT string `json:"refreshJwt"` Did string `json:"did"`}
type accessData struct { handle string appPassword string}
type ListConvosResponse struct { Cursor string `json:"cursor"` Convos []Convo `json:"convos"`}
type Convo struct { ID string `json:"id"` Members []ConvoMember `json:"members"` UnreadCount int `json:"unreadCount"`}
type ConvoMember struct { Did string `json:"did"` Handle string `json:"handle"`}
type ErrorResponse struct { Error string `json:"error"`}
type MessageResp struct { Messages []Message `json:"messages"` Cursor string `json:"cursor"`}
type Message struct { ID string `json:"id"` Sender MessageSender `json:"sender"` Text string `json:"text"`}
type MessageSender struct { Did string `json:"did"`}
type UpdateMessageReadRequest struct { ConvoID string `json:"convoId"` MessageID string `json:"messageId"`}
type User struct { DID string Handle string ConvoID string CreatedAt int}
type DmService struct { httpClient *http.Client accessData accessData auth auth timerDuration time.Duration pdsURL string store Store}
func NewDmService(store Store, timerDuration time.Duration) (*DmService, error) { httpClient := http.Client{ Timeout: httpClientTimeoutDuration, Transport: &http.Transport{ IdleConnTimeout: transportIdleConnTimeoutDuration, }, }
accessHandle := os.Getenv("MESSAGING_ACCESS_HANDLE") accessAppPassword := os.Getenv("MESSAGING_ACCESS_APP_PASSWORD") pdsURL := os.Getenv("MESSAGING_PDS_URL")
service := DmService{ httpClient: &httpClient, accessData: accessData{ handle: accessHandle, appPassword: accessAppPassword, }, timerDuration: timerDuration, pdsURL: pdsURL, store: store, }
auth, err := service.Authenicate() if err != nil { return nil, fmt.Errorf("authenticating: %w", err) }
service.auth = auth
return &service, nil}
func (d *DmService) Start(ctx context.Context) { go d.RefreshTask(ctx)
timer := time.NewTimer(d.timerDuration) defer timer.Stop()
for { select { case <-ctx.Done(): slog.Warn("context canceled - stopping dm task") return case <-timer.C: err := d.HandleMessageTimer(ctx) if err != nil { slog.Error("handle message timer", "error", err) } timer.Reset(d.timerDuration) } }}
func (d *DmService) RefreshTask(ctx context.Context) { timer := time.NewTimer(time.Hour) defer timer.Stop()
for { select { case <-ctx.Done(): return case <-timer.C: err := d.RefreshAuthenication(ctx) if err != nil { slog.Error("handle refresh auth timer", "error", err) // TODO: better retry with backoff probably timer.Reset(time.Minute) continue } timer.Reset(time.Hour) } }}
func (d *DmService) HandleMessageTimer(ctx context.Context) error { convoResp, err := d.GetUnreadMessages() if err != nil { return fmt.Errorf("get unread messages: %w", err) }
// TODO: handle the cursor pagination
for _, convo := range convoResp.Convos { if convo.UnreadCount == 0 { continue }
messageResp, err := d.GetMessages(ctx, convo.ID) if err != nil { slog.Error("failed to get messages for convo", "error", err, "convo id", convo.ID) continue }
unreadCount := convo.UnreadCount unreadMessages := make([]Message, 0, convo.UnreadCount) // TODO: handle cursor pagination for _, msg := range messageResp.Messages { // TODO: techincally if I get to a message that's from the bot account, then there shouldn't be // an more unread messages? if msg.Sender.Did == d.auth.Did { continue }
unreadMessages = append(unreadMessages, msg) unreadCount-- if unreadCount == 0 { break } }
for _, msg := range unreadMessages { d.handleMessage(msg, convo)
err = d.MarkMessageRead(msg.ID, convo.ID) if err != nil { slog.Error("marking message read", "error", err) continue } } }
return nil}
func (d *DmService) handleMessage(msg Message, convo Convo) { // TODO: add or remote user the list of "subsribed" users if strings.ToLower(msg.Text) == "subscribe" { userHandle := "" for _, member := range convo.Members { if member.Did == msg.Sender.Did { userHandle = member.Handle break } }
if userHandle == "" { slog.Error("user handle for sent message not found", "sender did", msg.Sender.Did, "convo members", convo.Members) return }
user := User{ DID: msg.Sender.Did, ConvoID: convo.ID, Handle: userHandle, CreatedAt: int(time.Now().UnixMilli()), }
err := d.store.CreateUser(user) if err != nil { slog.Error("error creating user", "error", err, "user", user) return } }}
func (d *DmService) GetUnreadMessages() (ListConvosResponse, error) { url := fmt.Sprintf("%s/xrpc/chat.bsky.convo.listConvos?readState=unread", d.pdsURL) request, err := http.NewRequest("GET", url, nil) if err != nil { return ListConvosResponse{}, fmt.Errorf("create new list convos http request: %w", err) }
request.Header.Add("Content-Type", "application/json") request.Header.Add("Accept", "application/json") request.Header.Add("Atproto-Proxy", "did:web:api.bsky.chat#bsky_chat") request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", d.auth.AccessJwt))
resp, err := d.httpClient.Do(request) if err != nil { return ListConvosResponse{}, fmt.Errorf("do http request to list convos: %w", err) } defer resp.Body.Close()
if resp.StatusCode != http.StatusOK { var errorResp ErrorResponse err = decodeResp(resp.Body, &errorResp) if err != nil { return ListConvosResponse{}, err }
return ListConvosResponse{}, fmt.Errorf("listing convos responded with code %d: %s", resp.StatusCode, errorResp.Error) }
var listConvoResp ListConvosResponse err = decodeResp(resp.Body, &listConvoResp) if err != nil { return ListConvosResponse{}, err }
return listConvoResp, nil}
func (d *DmService) MarkMessageRead(messageID, convoID string) error { bodyReq := UpdateMessageReadRequest{ ConvoID: convoID, MessageID: messageID, }
bodyB, err := json.Marshal(bodyReq) if err != nil { return fmt.Errorf("marshal update message request body: %w", err) }
r := bytes.NewReader(bodyB)
url := fmt.Sprintf("%s/xrpc/chat.bsky.convo.updateRead", d.pdsURL) request, err := http.NewRequest("POST", url, r) if err != nil { return fmt.Errorf("create new list convos http request: %w", err) }
request.Header.Add("Content-Type", "application/json") request.Header.Add("Accept", "application/json") request.Header.Add("Atproto-Proxy", "did:web:api.bsky.chat#bsky_chat") request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", d.auth.AccessJwt))
resp, err := d.httpClient.Do(request) if err != nil { return fmt.Errorf("do http request to update message read: %w", err) } defer resp.Body.Close()
if resp.StatusCode == http.StatusOK { return nil }
var errorResp ErrorResponse err = decodeResp(resp.Body, &errorResp) if err != nil { return err }
return fmt.Errorf("listing convos responded with code %d: %s", resp.StatusCode, errorResp.Error)
}
func (d *DmService) Authenicate() (auth, error) { url := fmt.Sprintf("%s/com.atproto.server.createSession", baseBskyURL)
requestData := map[string]interface{}{ "identifier": d.accessData.handle, "password": d.accessData.appPassword, }
data, err := json.Marshal(requestData) if err != nil { return auth{}, errors.Wrap(err, "failed to marshal request") }
r := bytes.NewReader(data)
request, err := http.NewRequest("POST", url, r) if err != nil { return auth{}, errors.Wrap(err, "failed to create request") }
request.Header.Add("Content-Type", "application/json")
resp, err := d.httpClient.Do(request) if err != nil { return auth{}, errors.Wrap(err, "failed to make request") } defer resp.Body.Close()
var loginResp auth err = decodeResp(resp.Body, &loginResp) if err != nil { return auth{}, err }
return loginResp, nil}
func (d *DmService) RefreshAuthenication(ctx context.Context) error { url := fmt.Sprintf("%s/com.atproto.server.refreshSession", baseBskyURL)
request, err := http.NewRequest("POST", url, nil) if err != nil { return errors.Wrap(err, "failed to create request") }
request.Header.Add("Content-Type", "application/json") request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", d.auth.RefershJWT))
resp, err := d.httpClient.Do(request) if err != nil { return errors.Wrap(err, "failed to make request") } defer resp.Body.Close()
var loginResp auth err = decodeResp(resp.Body, &loginResp) if err != nil { return err }
d.auth = loginResp
return nil}
func (d *DmService) GetMessages(ctx context.Context, convoID string) (MessageResp, error) { url := fmt.Sprintf("%s/xrpc/chat.bsky.convo.getMessages?convoId=%s", d.pdsURL, convoID) request, err := http.NewRequest("GET", url, nil) if err != nil { return MessageResp{}, fmt.Errorf("create new get messages http request: %w", err) }
request.Header.Add("Content-Type", "application/json") request.Header.Add("Accept", "application/json") request.Header.Add("Atproto-Proxy", "did:web:api.bsky.chat#bsky_chat") request.Header.Add("Authorization", fmt.Sprintf("Bearer %s", d.auth.AccessJwt))
resp, err := d.httpClient.Do(request) if err != nil { return MessageResp{}, fmt.Errorf("do http request to get messages: %w", err) } defer resp.Body.Close()
if resp.StatusCode != http.StatusOK { var errorResp ErrorResponse err = decodeResp(resp.Body, &errorResp) if err != nil { return MessageResp{}, err }
return MessageResp{}, fmt.Errorf("listing convos responded with code %d: %s", resp.StatusCode, errorResp.Error) }
var messageResp MessageResp err = decodeResp(resp.Body, &messageResp) if err != nil { return MessageResp{}, err }
return messageResp, nil}
func decodeResp(body io.Reader, result any) error { resBody, err := io.ReadAll(body) if err != nil { return errors.Wrap(err, "failed to read response") }
err = json.Unmarshal(resBody, result) if err != nil { return errors.Wrap(err, "failed to unmarshal response") } return nil}