125 lines
3.7 KiB
Go
125 lines
3.7 KiB
Go
package localserver
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
)
|
|
|
|
type SquadNotificationsHandler struct {
|
|
SquadId string
|
|
SquadMembersId []string
|
|
DataChannels map[string]*DataChannel
|
|
Flag *uint32
|
|
Publishers []<-chan *SquadRequest
|
|
reqChans []chan<- *SquadRequest
|
|
}
|
|
|
|
func NewSquadNotificationsHandler(_ string, squadId string, owner string, authorizedMembers []string, dataChannels map[string]*DataChannel, flag *uint32) (squadNotificationsHandler *SquadNotificationsHandler, err error) {
|
|
if _, dirErr := os.ReadDir(filepath.Join(dataPath, "data", "squads", squadId, "notifications")); os.IsNotExist(dirErr) {
|
|
dirErr := os.MkdirAll(filepath.Join(dataPath, "data", "squads", squadId, "notifications"), 0700)
|
|
if dirErr != nil {
|
|
return
|
|
}
|
|
}
|
|
squadNotificationsHandler = &SquadNotificationsHandler{
|
|
SquadId: squadId,
|
|
SquadMembersId: authorizedMembers,
|
|
DataChannels: dataChannels,
|
|
Flag: flag,
|
|
}
|
|
return
|
|
}
|
|
|
|
func (znh *SquadNotificationsHandler) Init(ctx context.Context, authorizedMembers []string) (err error) {
|
|
//? initialization code here
|
|
return
|
|
}
|
|
|
|
func (znh *SquadNotificationsHandler) Subscribe(ctx context.Context, publisher <-chan *SquadRequest) (reqChan chan *SquadRequest, done chan struct{}, errCh chan error) {
|
|
reqChan, done, errCh = make(chan *SquadRequest), make(chan struct{}), make(chan error)
|
|
znh.reqChans = append(znh.reqChans, reqChan)
|
|
go func() {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
done <- struct{}{}
|
|
return
|
|
case req := <-publisher:
|
|
if err := znh.handleSquadRequest(ctx, req); err != nil {
|
|
errCh <- err
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
return
|
|
}
|
|
|
|
func (znh *SquadNotificationsHandler) ListNotifications(userId string) {}
|
|
|
|
func (znh *SquadNotificationsHandler) CreateNotification(notificationType, title, body, payload string, isPushed bool, recipients ...string) (err error) {
|
|
if isPushed {
|
|
err = znh.PushNotification(notificationType, title, body, payload, recipients...)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (znh *SquadNotificationsHandler) DeleteNotification() {}
|
|
|
|
func (znh *SquadNotificationsHandler) PushNotification(notificationType, title, body, payload string, recipients ...string) (err error) {
|
|
em := NewEncryptionManager()
|
|
sig := em.SignRequestHMAC(NodeID)
|
|
b, err := json.Marshal(map[string]interface{}{
|
|
"type": NOTIFY,
|
|
"mac": sig,
|
|
"from": NodeID,
|
|
"peerType": "node",
|
|
"payload": map[string]interface{}{
|
|
"type": notificationType,
|
|
"title": title,
|
|
"body": body,
|
|
"recipients": recipients,
|
|
"payload": payload,
|
|
},
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = HTTPClient.Post("https://dev.zippytal.com/req", "application/json", bytes.NewReader(b))
|
|
if err != nil {
|
|
// logger.Println("error come from there in squad manager")
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (znh SquadNotificationsHandler) handleDataChannel(ctx context.Context, dc *DataChannel) (catched bool) {
|
|
return
|
|
}
|
|
|
|
func (znh *SquadNotificationsHandler) handleSquadRequest(ctx context.Context, req *SquadRequest) (err error) {
|
|
switch req.ReqType {
|
|
case CREATE_NOTIFICATION:
|
|
if err = VerifyFieldsString(req.Payload, "type", "title", "body", "payload"); err != nil {
|
|
return
|
|
}
|
|
if err = VerifyFieldsBool(req.Payload, "isPushed"); err != nil {
|
|
return
|
|
}
|
|
if _, ok := req.Payload["recipients"]; !ok {
|
|
err = fmt.Errorf("no field recipient in payload")
|
|
return
|
|
}
|
|
if _, ok := req.Payload["recipients"].([]string); !ok {
|
|
err = fmt.Errorf(" field recipient in payload is wrong type")
|
|
return
|
|
}
|
|
|
|
err = znh.CreateNotification(req.Payload["type"].(string), req.Payload["title"].(string), req.Payload["body"].(string), req.Payload["payload"].(string), req.Payload["isPushed"].(bool), req.Payload["recipients"].([]string)...)
|
|
}
|
|
return
|
|
}
|