···
+
package tangledalertbot
+
"github.com/pkg/errors"
+
httpClientTimeoutDuration = time.Second * 5
+
transportIdleConnTimeoutDuration = time.Second * 90
+
baseBskyURL = "https://bsky.social/xrpc"
+
AccessJwt string `json:"accessJwt"`
+
RefershJWT string `json:"refreshJwt"`
+
Did string `json:"did"`
+
type accessData struct {
+
type ListConvosResponse struct {
+
Cursor string `json:"cursor"`
+
Convos []Convo `json:"convos"`
+
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"`
+
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 DmService struct {
+
httpClient *http.Client
+
timerDuration time.Duration
+
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")
+
httpClient: &httpClient,
+
accessData: accessData{
+
appPassword: accessAppPassword,
+
timerDuration: timerDuration,
+
auth, err := service.Authenicate()
+
return nil, fmt.Errorf("authenticating: %w", err)
+
func (d *DmService) Start(ctx context.Context) {
+
timer := time.NewTimer(d.timerDuration)
+
slog.Warn("context canceled - stopping dm task")
+
err := d.HandleMessageTimer(ctx)
+
slog.Error("handle message timer", "error", err)
+
timer.Reset(d.timerDuration)
+
func (d *DmService) RefreshTask(ctx context.Context) {
+
timer := time.NewTimer(time.Hour)
+
err := d.RefreshAuthenication(ctx)
+
slog.Error("handle refresh auth timer", "error", err)
+
// TODO: better retry with backoff probably
+
timer.Reset(time.Minute)
+
func (d *DmService) HandleMessageTimer(ctx context.Context) error {
+
convoResp, err := d.GetUnreadMessages()
+
return fmt.Errorf("get unread messages: %w", err)
+
// TODO: handle the cursor pagination
+
for _, convo := range convoResp.Convos {
+
if convo.UnreadCount == 0 {
+
messageResp, err := d.GetMessages(ctx, convo.ID)
+
slog.Error("failed to get messages for convo", "error", err, "convo id", convo.ID)
+
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 {
+
unreadMessages = append(unreadMessages, msg)
+
for _, msg := range unreadMessages {
+
d.handleMessage(msg, convo)
+
err = d.MarkMessageRead(msg.ID, convo.ID)
+
slog.Error("marking message read", "error", err)
+
func (d *DmService) handleMessage(msg Message, convo Convo) {
+
// TODO: add or remote user the list of "subsribed" users
+
if strings.ToLower(msg.Text) == "subscribe" {
+
for _, member := range convo.Members {
+
if member.Did == msg.Sender.Did {
+
userHandle = member.Handle
+
slog.Error("user handle for sent message not found", "sender did", msg.Sender.Did, "convo members", convo.Members)
+
CreatedAt: int(time.Now().UnixMilli()),
+
err := d.store.CreateUser(user)
+
slog.Error("error creating user", "error", err, "user", user)
+
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)
+
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)
+
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)
+
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)
+
return ListConvosResponse{}, err
+
return listConvoResp, nil
+
func (d *DmService) MarkMessageRead(messageID, convoID string) error {
+
bodyReq := UpdateMessageReadRequest{
+
bodyB, err := json.Marshal(bodyReq)
+
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)
+
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)
+
return fmt.Errorf("do http request to update message read: %w", err)
+
defer resp.Body.Close()
+
if resp.StatusCode == http.StatusOK {
+
var errorResp ErrorResponse
+
err = decodeResp(resp.Body, &errorResp)
+
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)
+
return auth{}, errors.Wrap(err, "failed to marshal request")
+
r := bytes.NewReader(data)
+
request, err := http.NewRequest("POST", url, r)
+
return auth{}, errors.Wrap(err, "failed to create request")
+
request.Header.Add("Content-Type", "application/json")
+
resp, err := d.httpClient.Do(request)
+
return auth{}, errors.Wrap(err, "failed to make request")
+
defer resp.Body.Close()
+
err = decodeResp(resp.Body, &loginResp)
+
func (d *DmService) RefreshAuthenication(ctx context.Context) error {
+
url := fmt.Sprintf("%s/com.atproto.server.refreshSession", baseBskyURL)
+
request, err := http.NewRequest("POST", url, 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)
+
return errors.Wrap(err, "failed to make request")
+
defer resp.Body.Close()
+
err = decodeResp(resp.Body, &loginResp)
+
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)
+
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)
+
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)
+
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)
+
return MessageResp{}, err
+
return messageResp, nil
+
func decodeResp(body io.Reader, result any) error {
+
resBody, err := io.ReadAll(body)
+
return errors.Wrap(err, "failed to read response")
+
err = json.Unmarshal(resBody, result)
+
return errors.Wrap(err, "failed to unmarshal response")
willdot.net