refactored notificatoin / tgsettle responsibility boundaries

api/pkg/messaging/internal/notifications/telegram/notification.go

@@ -26,6 +26,40 @@ func telegramReactionEvent() model.NotificationEvent {
 	return model.NewNotification(mservice.Notifications, nm.NATelegramReaction)
 }
 
+type TelegramTextNotification struct {
+	messaging.Envelope
+	payload model.TelegramTextRequest
+}
+
+func (ttn *TelegramTextNotification) Serialize() ([]byte, error) {
+	data, err := json.Marshal(ttn.payload)
+	if err != nil {
+		return nil, err
+	}
+	return ttn.Envelope.Wrap(data)
+}
+
+func telegramTextEvent() model.NotificationEvent {
+	return model.NewNotification(mservice.Notifications, nm.NATelegramText)
+}
+
+type TelegramUpdateNotification struct {
+	messaging.Envelope
+	payload model.TelegramWebhookUpdate
+}
+
+func (tun *TelegramUpdateNotification) Serialize() ([]byte, error) {
+	data, err := json.Marshal(tun.payload)
+	if err != nil {
+		return nil, err
+	}
+	return tun.Envelope.Wrap(data)
+}
+
+func telegramUpdateEvent() model.NotificationEvent {
+	return model.NewNotification(mservice.Notifications, nm.NATelegramUpdate)
+}
+
 func NewTelegramReactionEnvelope(sender string, request *model.TelegramReactionRequest) messaging.Envelope {
 	var payload model.TelegramReactionRequest
 	if request != nil {
@@ -36,3 +70,25 @@ func NewTelegramReactionEnvelope(sender string, request *model.TelegramReactionR
 		payload:  payload,
 	}
 }
+
+func NewTelegramTextEnvelope(sender string, request *model.TelegramTextRequest) messaging.Envelope {
+	var payload model.TelegramTextRequest
+	if request != nil {
+		payload = *request
+	}
+	return &TelegramTextNotification{
+		Envelope: messaging.CreateEnvelope(sender, telegramTextEvent()),
+		payload:  payload,
+	}
+}
+
+func NewTelegramUpdateEnvelope(sender string, update *model.TelegramWebhookUpdate) messaging.Envelope {
+	var payload model.TelegramWebhookUpdate
+	if update != nil {
+		payload = *update
+	}
+	return &TelegramUpdateNotification{
+		Envelope: messaging.CreateEnvelope(sender, telegramUpdateEvent()),
+		payload:  payload,
+	}
+}

api/pkg/messaging/internal/notifications/telegram/processor.go

@@ -45,3 +45,71 @@ func NewTelegramReactionProcessor(logger mlogger.Logger, handler ch.TelegramReac
 		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(),
+	}
+}