116 lines
3.4 KiB
Go
116 lines
3.4 KiB
Go
package notifications
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
|
|
me "github.com/tech/sendico/pkg/messaging/envelope"
|
|
np "github.com/tech/sendico/pkg/messaging/notifications/processor"
|
|
ch "github.com/tech/sendico/pkg/messaging/notifications/telegram/handler"
|
|
"github.com/tech/sendico/pkg/mlogger"
|
|
"github.com/tech/sendico/pkg/model"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type TelegramReactionProcessor struct {
|
|
logger mlogger.Logger
|
|
handler ch.TelegramReactionHandler
|
|
event model.NotificationEvent
|
|
}
|
|
|
|
func (trp *TelegramReactionProcessor) Process(ctx context.Context, envelope me.Envelope) error {
|
|
var msg model.TelegramReactionRequest
|
|
if err := json.Unmarshal(envelope.GetData(), &msg); err != nil {
|
|
trp.logger.Warn("Failed to decode telegram reaction envelope", zap.Error(err), zap.String("topic", trp.event.ToString()))
|
|
return err
|
|
}
|
|
if trp.handler == nil {
|
|
trp.logger.Warn("Telegram reaction handler is not configured", zap.String("topic", trp.event.ToString()))
|
|
return nil
|
|
}
|
|
return trp.handler(ctx, &msg)
|
|
}
|
|
|
|
func (trp *TelegramReactionProcessor) GetSubject() model.NotificationEvent {
|
|
return trp.event
|
|
}
|
|
|
|
func NewTelegramReactionProcessor(logger mlogger.Logger, handler ch.TelegramReactionHandler) np.EnvelopeProcessor {
|
|
if logger != nil {
|
|
logger = logger.Named("telegram_reaction_processor")
|
|
}
|
|
return &TelegramReactionProcessor{
|
|
logger: logger,
|
|
handler: handler,
|
|
event: telegramReactionEvent(),
|
|
}
|
|
}
|
|
|
|
type TelegramTextProcessor struct {
|
|
logger mlogger.Logger
|
|
handler ch.TelegramTextHandler
|
|
event model.NotificationEvent
|
|
}
|
|
|
|
func (ttp *TelegramTextProcessor) Process(ctx context.Context, envelope me.Envelope) error {
|
|
var msg model.TelegramTextRequest
|
|
if err := json.Unmarshal(envelope.GetData(), &msg); err != nil {
|
|
ttp.logger.Warn("Failed to decode telegram text envelope", zap.Error(err), zap.String("topic", ttp.event.ToString()))
|
|
return err
|
|
}
|
|
if ttp.handler == nil {
|
|
ttp.logger.Warn("Telegram text handler is not configured", zap.String("topic", ttp.event.ToString()))
|
|
return nil
|
|
}
|
|
return ttp.handler(ctx, &msg)
|
|
}
|
|
|
|
func (ttp *TelegramTextProcessor) GetSubject() model.NotificationEvent {
|
|
return ttp.event
|
|
}
|
|
|
|
func NewTelegramTextProcessor(logger mlogger.Logger, handler ch.TelegramTextHandler) np.EnvelopeProcessor {
|
|
if logger != nil {
|
|
logger = logger.Named("telegram_text_processor")
|
|
}
|
|
return &TelegramTextProcessor{
|
|
logger: logger,
|
|
handler: handler,
|
|
event: telegramTextEvent(),
|
|
}
|
|
}
|
|
|
|
type TelegramUpdateProcessor struct {
|
|
logger mlogger.Logger
|
|
handler ch.TelegramUpdateHandler
|
|
event model.NotificationEvent
|
|
}
|
|
|
|
func (tup *TelegramUpdateProcessor) Process(ctx context.Context, envelope me.Envelope) error {
|
|
var msg model.TelegramWebhookUpdate
|
|
if err := json.Unmarshal(envelope.GetData(), &msg); err != nil {
|
|
tup.logger.Warn("Failed to decode telegram webhook update envelope", zap.Error(err), zap.String("topic", tup.event.ToString()))
|
|
return err
|
|
}
|
|
if tup.handler == nil {
|
|
tup.logger.Warn("Telegram update handler is not configured", zap.String("topic", tup.event.ToString()))
|
|
return nil
|
|
}
|
|
return tup.handler(ctx, &msg)
|
|
}
|
|
|
|
func (tup *TelegramUpdateProcessor) GetSubject() model.NotificationEvent {
|
|
return tup.event
|
|
}
|
|
|
|
func NewTelegramUpdateProcessor(logger mlogger.Logger, handler ch.TelegramUpdateHandler) np.EnvelopeProcessor {
|
|
if logger != nil {
|
|
logger = logger.Named("telegram_update_processor")
|
|
}
|
|
return &TelegramUpdateProcessor{
|
|
logger: logger,
|
|
handler: handler,
|
|
event: telegramUpdateEvent(),
|
|
}
|
|
}
|