listeners.*WebhookListener.onUserAccountDeleted - Code Metrics - Inspection of "Add ability for users to delete their acounts with..." - NdoleStudio/httpsms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 570b65...2ff189 )

by Acho

created 2024-11-07 08:18 UTC

listeners.*WebhookListener.onUserAccountDeleted A

↳ Parent: api/pkg/listeners/webhook_listener.go

Complexity

Conditions

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	11
dl	0
loc	16
rs	9.85
c	0
b	0
f	0
nop	2

package listeners

import (
	"context"
	"fmt"

	"github.com/NdoleStudio/httpsms/pkg/events"
	"github.com/NdoleStudio/httpsms/pkg/services"
	"github.com/NdoleStudio/httpsms/pkg/telemetry"
	cloudevents "github.com/cloudevents/sdk-go/v2"
	"github.com/palantir/stacktrace"
)

// WebhookListener sends webhook events to users
type WebhookListener struct {
	logger  telemetry.Logger
	tracer  telemetry.Tracer
	service *services.WebhookService
}

// NewWebhookListener creates a new instance of WebhookListener
func NewWebhookListener(
	logger telemetry.Logger,
	tracer telemetry.Tracer,
	service *services.WebhookService,
) (l *WebhookListener, routes map[string]events.EventListener) {
	l = &WebhookListener{
		logger:  logger.WithService(fmt.Sprintf("%T", l)),
		tracer:  tracer,
		service: service,
	}

	return l, map[string]events.EventListener{
		events.EventTypeMessagePhoneReceived:  l.OnMessagePhoneReceived,
		events.EventTypeMessageSendExpired:    l.OnMessageSendExpired,
		events.EventTypeMessagePhoneDelivered: l.OnMessagePhoneDelivered,
		events.EventTypeMessageSendFailed:     l.OnMessageSendFailed,
		events.EventTypeMessagePhoneSent:      l.OnMessagePhoneSent,
		events.EventTypePhoneHeartbeatOnline:  l.onPhoneHeartbeatOnline,
		events.EventTypePhoneHeartbeatOffline: l.onPhoneHeartbeatOffline,
		events.MessageCallMissed:              l.onMessageCallMissed,
		events.UserAccountDeleted:             l.onUserAccountDeleted,
	}
}

// OnMessagePhoneReceived handles the events.EventTypeMessagePhoneReceived event
func (listener *WebhookListener) OnMessagePhoneReceived(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.MessagePhoneReceivedPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// OnMessageSendExpired handles the events.EventTypeMessageSendExpired event
func (listener *WebhookListener) OnMessageSendExpired(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.MessageSendExpiredPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// OnMessageSendFailed handles the events.EventTypeMessageSendFailed event
func (listener *WebhookListener) OnMessageSendFailed(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.MessageSendFailedPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// OnMessagePhoneSent handles the events.EventTypeMessagePhoneSent event
func (listener *WebhookListener) OnMessagePhoneSent(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.MessagePhoneSentPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// OnMessagePhoneDelivered handles the events.EventTypeMessagePhoneDelivered event
func (listener *WebhookListener) OnMessagePhoneDelivered(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.MessagePhoneDeliveredPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// OnMessagePhoneDelivered handles the events.EventTypeMessagePhoneDelivered event
func (listener *WebhookListener) onPhoneHeartbeatOffline(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.PhoneHeartbeatOfflinePayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// OnMessagePhoneDelivered handles the events.EventTypeMessagePhoneDelivered event
func (listener *WebhookListener) onPhoneHeartbeatOnline(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.PhoneHeartbeatOnlinePayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

// onMessageCallMissed handles the events.MessageCallMissed event
func (listener *WebhookListener) onMessageCallMissed(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.MessageCallMissedPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
		msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}

func (listener *WebhookListener) onUserAccountDeleted(ctx context.Context, event cloudevents.Event) error {
	ctx, span := listener.tracer.Start(ctx)
	defer span.End()

	var payload events.UserAccountDeletedPayload
	if err := event.DataAs(&payload); err != nil {
		msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	if err := listener.service.DeleteAllForUser(ctx, payload.UserID); err != nil {
		msg := fmt.Sprintf("cannot delete [entities.Webhook] for user [%s] on [%s] event with ID [%s]", payload.UserID, event.Type(), event.ID())
		return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
	}

	return nil
}


1			package listeners
2
3			import (
4			"context"
5			"fmt"
6
7			"github.com/NdoleStudio/httpsms/pkg/events"
8			"github.com/NdoleStudio/httpsms/pkg/services"
9			"github.com/NdoleStudio/httpsms/pkg/telemetry"
10			cloudevents "github.com/cloudevents/sdk-go/v2"
11			"github.com/palantir/stacktrace"
12			)
13
14			// WebhookListener sends webhook events to users
15			type WebhookListener struct {
16			logger telemetry.Logger
17			tracer telemetry.Tracer
18			service *services.WebhookService
19			}
20
21			// NewWebhookListener creates a new instance of WebhookListener
22			func NewWebhookListener(
23			logger telemetry.Logger,
24			tracer telemetry.Tracer,
25			service *services.WebhookService,
26			) (l *WebhookListener, routes map[string]events.EventListener) {
27			l = &WebhookListener{
28			logger: logger.WithService(fmt.Sprintf("%T", l)),
29			tracer: tracer,
30			service: service,
31			}
32
33			return l, map[string]events.EventListener{
34			events.EventTypeMessagePhoneReceived: l.OnMessagePhoneReceived,
35			events.EventTypeMessageSendExpired: l.OnMessageSendExpired,
36			events.EventTypeMessagePhoneDelivered: l.OnMessagePhoneDelivered,
37			events.EventTypeMessageSendFailed: l.OnMessageSendFailed,
38			events.EventTypeMessagePhoneSent: l.OnMessagePhoneSent,
39			events.EventTypePhoneHeartbeatOnline: l.onPhoneHeartbeatOnline,
40			events.EventTypePhoneHeartbeatOffline: l.onPhoneHeartbeatOffline,
41			events.MessageCallMissed: l.onMessageCallMissed,
42			events.UserAccountDeleted: l.onUserAccountDeleted,
43			}
44			}
45
46			// OnMessagePhoneReceived handles the events.EventTypeMessagePhoneReceived event
47			func (listener *WebhookListener) OnMessagePhoneReceived(ctx context.Context, event cloudevents.Event) error {
48			ctx, span := listener.tracer.Start(ctx)
49			defer span.End()
50
51			var payload events.MessagePhoneReceivedPayload
52			if err := event.DataAs(&payload); err != nil {
53			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
54			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
55			}
56
57			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
58			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
59			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
60			}
61
62			return nil
63			}
64
65			// OnMessageSendExpired handles the events.EventTypeMessageSendExpired event
66			func (listener *WebhookListener) OnMessageSendExpired(ctx context.Context, event cloudevents.Event) error {
67			ctx, span := listener.tracer.Start(ctx)
68			defer span.End()
69
70			var payload events.MessageSendExpiredPayload
71			if err := event.DataAs(&payload); err != nil {
72			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
73			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
74			}
75
76			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
77			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
78			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
79			}
80
81			return nil
82			}
83
84			// OnMessageSendFailed handles the events.EventTypeMessageSendFailed event
85			func (listener *WebhookListener) OnMessageSendFailed(ctx context.Context, event cloudevents.Event) error {
86			ctx, span := listener.tracer.Start(ctx)
87			defer span.End()
88
89			var payload events.MessageSendFailedPayload
90			if err := event.DataAs(&payload); err != nil {
91			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
92			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
93			}
94
95			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
96			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
97			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
98			}
99
100			return nil
101			}
102
103			// OnMessagePhoneSent handles the events.EventTypeMessagePhoneSent event
104			func (listener *WebhookListener) OnMessagePhoneSent(ctx context.Context, event cloudevents.Event) error {
105			ctx, span := listener.tracer.Start(ctx)
106			defer span.End()
107
108			var payload events.MessagePhoneSentPayload
109			if err := event.DataAs(&payload); err != nil {
110			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
111			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
112			}
113
114			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
115			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
116			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
117			}
118
119			return nil
120			}
121
122			// OnMessagePhoneDelivered handles the events.EventTypeMessagePhoneDelivered event
123			func (listener *WebhookListener) OnMessagePhoneDelivered(ctx context.Context, event cloudevents.Event) error {
124			ctx, span := listener.tracer.Start(ctx)
125			defer span.End()
126
127			var payload events.MessagePhoneDeliveredPayload
128			if err := event.DataAs(&payload); err != nil {
129			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
130			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
131			}
132
133			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
134			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
135			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
136			}
137
138			return nil
139			}
140
141			// OnMessagePhoneDelivered handles the events.EventTypeMessagePhoneDelivered event
142			func (listener *WebhookListener) onPhoneHeartbeatOffline(ctx context.Context, event cloudevents.Event) error {
143			ctx, span := listener.tracer.Start(ctx)
144			defer span.End()
145
146			var payload events.PhoneHeartbeatOfflinePayload
147			if err := event.DataAs(&payload); err != nil {
148			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
149			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
150			}
151
152			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
153			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
154			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
155			}
156
157			return nil
158			}
159
160			// OnMessagePhoneDelivered handles the events.EventTypeMessagePhoneDelivered event
161			func (listener *WebhookListener) onPhoneHeartbeatOnline(ctx context.Context, event cloudevents.Event) error {
162			ctx, span := listener.tracer.Start(ctx)
163			defer span.End()
164
165			var payload events.PhoneHeartbeatOnlinePayload
166			if err := event.DataAs(&payload); err != nil {
167			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
168			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
169			}
170
171			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
172			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
173			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
174			}
175
176			return nil
177			}
178
179			// onMessageCallMissed handles the events.MessageCallMissed event
180			func (listener *WebhookListener) onMessageCallMissed(ctx context.Context, event cloudevents.Event) error {
181			ctx, span := listener.tracer.Start(ctx)
182			defer span.End()
183
184			var payload events.MessageCallMissedPayload
185			if err := event.DataAs(&payload); err != nil {
186			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
187			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
188			}
189
190			if err := listener.service.Send(ctx, payload.UserID, event, payload.Owner); err != nil {
191			msg := fmt.Sprintf("cannot process [%s] event with ID [%s]", event.Type(), event.ID())
192			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
193			}
194
195			return nil
196			}
197
198			func (listener *WebhookListener) onUserAccountDeleted(ctx context.Context, event cloudevents.Event) error {
199			ctx, span := listener.tracer.Start(ctx)
200			defer span.End()
201
202			var payload events.UserAccountDeletedPayload
203			if err := event.DataAs(&payload); err != nil {
204			msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)
205			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
206			}
207
208			if err := listener.service.DeleteAllForUser(ctx, payload.UserID); err != nil {
209			msg := fmt.Sprintf("cannot delete [entities.Webhook] for user [%s] on [%s] event with ID [%s]", payload.UserID, event.Type(), event.ID())
210			return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
211			}
212
213			return nil
214			}
215

NdoleStudio / httpsms

Push — main ( 570b65...2ff189 )

listeners.*WebhookListener.onUserAccountDeleted A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like