Event-based webhook

config.yml.sample

@@ -316,3 +316,10 @@ metrics:
   username:
   # If set to a non-empty value the /metrics endpoint will require this as a password via basic auth in combination with the username below.
   password:
+
+# Webhook configuration
+webhook:
+  # If set to true, HTTP POST is executed
+  enabled: true
+  # URL for webhook
+  url: "http://127.0.0.1/test/"

pkg/config/config.go

@@ -159,6 +159,11 @@ const (
 	MetricsEnabled  Key = `metrics.enabled`
 	MetricsUsername Key = `metrics.username`
 	MetricsPassword Key = `metrics.password`
+
+	WebhookEnabled   Key = `webhook.enabled`
+	WebhookURL       Key = `webhook.url`
+
+
 )
 
 // GetString returns a string config value
@@ -367,6 +372,9 @@ func InitDefaultConfig() {
 	KeyvalueType.setDefault("memory")
 	// Metrics
 	MetricsEnabled.setDefault(false)
+
+	WebhookEnabled.setDefault(false)
+	WebhookURL.setDefault("")
 }
 
 // InitConfig initializes the config, sets defaults etc.

pkg/initialize/init.go

@@ -32,6 +32,7 @@ import (
 	"code.vikunja.io/api/pkg/notifications"
 	"code.vikunja.io/api/pkg/red"
 	"code.vikunja.io/api/pkg/user"
+	"code.vikunja.io/api/pkg/webhooks"
 )
 
 // LightInit will only fullInit config, redis, logger but no db connection.
@@ -103,6 +104,7 @@ func FullInit() {
 	go func() {
 		models.RegisterListeners()
 		user.RegisterListeners()
+		webhooks.RegisterListeners()
 		err := events.InitEvents()
 		if err != nil {
 			log.Fatal(err.Error())

pkg/webhooks/listeners.go

@@ -0,0 +1,316 @@
+// TESTING
+
+
+package webhooks
+
+import (
+	// "encoding/json"
+
+	"fmt"
+	"net/http"
+	"bytes"
+
+  "code.vikunja.io/api/pkg/config"
+	"code.vikunja.io/api/pkg/events"
+	"code.vikunja.io/api/pkg/models"
+	"code.vikunja.io/api/pkg/log"
+
+	"github.com/ThreeDotsLabs/watermill/message"
+
+
+)
+
+// RegisterListeners registers all event listeners
+func RegisterListeners() {
+	events.RegisterListener((&models.ListCreatedEvent{}).Name(), &WebHookListCreatedEvent{})
+	events.RegisterListener((&models.ListDeletedEvent{}).Name(), &WebHookListDeletedEvent{})
+	events.RegisterListener((&models.NamespaceCreatedEvent{}).Name(), &WebHookNamespaceCreatedEvent{})
+	events.RegisterListener((&models.NamespaceDeletedEvent{}).Name(), &WebHookNamespaceDeletedEvent{})
+	events.RegisterListener((&models.TaskCreatedEvent{}).Name(), &WebHookTaskCreatedEvent{})
+	events.RegisterListener((&models.TaskDeletedEvent{}).Name(), &WebHookTaskDeletedEvent{})
+	events.RegisterListener((&models.TeamDeletedEvent{}).Name(), &WebHookTeamDeletedEvent{})
+	events.RegisterListener((&models.TeamCreatedEvent{}).Name(), &WebHookTeamCreatedEvent{})
+	events.RegisterListener((&models.TeamMemberAddedEvent{}).Name(), &WebHookTeamMemberAddedEvent{})
+	events.RegisterListener((&models.TaskCommentCreatedEvent{}).Name(), &WebHookTaskCommentCreatedEvent{})
+	events.RegisterListener((&models.TaskAssigneeCreatedEvent{}).Name(), &WebHookTaskAssigneeCreatedEvent{})
+	events.RegisterListener((&models.TaskCommentUpdatedEvent{}).Name(), &WebHookTaskCommentUpdatedEvent{})
+	events.RegisterListener((&models.TaskUpdatedEvent{}).Name(), &WebHookTaskUpdatedEvent{})
+}
+
+
+
+///////
+// Event Listeners
+
+
+
+// WebHookListCreatedEvent  represents a listener
+type WebHookListCreatedEvent struct {
+}
+
+// Name defines the name for the WebHookListCreatedEvent listener
+func (s *WebHookListCreatedEvent) Name() string {
+	return "web.hook.list.created.event"
+}
+
+// Handle is executed when the event WebHookListCreatedEvent listens on is fired
+func (s *WebHookListCreatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.ListCreatedEvent{}).Name(), msg)
+// end
+	
+	return nil
+}
+
+// WebHookListDeletedEvent  represents a listener
+type WebHookListDeletedEvent struct {
+}
+
+// Name defines the name for the WebHookListDeletedEvent listener
+func (s *WebHookListDeletedEvent) Name() string {
+	return "web.hook.list.deleted.event"
+}
+
+// Handle is executed when the event WebHookListDeletedEvent listens on is fired
+func (s *WebHookListDeletedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.ListDeletedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookNamespaceCreatedEvent  represents a listener
+type WebHookNamespaceCreatedEvent struct {
+}
+
+// Name defines the name for the WebHookNamespaceCreatedEvent listener
+func (s *WebHookNamespaceCreatedEvent) Name() string {
+	return "web.hook.namespace.created.event"
+}
+
+// Handle is executed when the event WebHookNamespaceCreatedEvent listens on is fired
+func (s *WebHookNamespaceCreatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.NamespaceCreatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookNamespaceDeletedEvent  represents a listener
+type WebHookNamespaceDeletedEvent struct {
+}
+
+// Name defines the name for the WebHookNamespaceDeletedEvent listener
+func (s *WebHookNamespaceDeletedEvent) Name() string {
+	return "web.hook.namespace.deleted.event"
+}
+
+// Handle is executed when the event WebHookNamespaceDeletedEvent listens on is fired
+func (s *WebHookNamespaceDeletedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.NamespaceDeletedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTaskCreatedEvent  represents a listener
+type WebHookTaskCreatedEvent struct {
+}
+
+// Name defines the name for the WebHookTaskCreatedEvent listener
+func (s *WebHookTaskCreatedEvent) Name() string {
+	return "web.hook.task.created.event"
+}
+
+// Handle is executed when the event WebHookTaskCreatedEvent listens on is fired
+func (s *WebHookTaskCreatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TaskCreatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTaskDeletedEvent  represents a listener
+type WebHookTaskDeletedEvent struct {
+}
+
+// Name defines the name for the WebHookTaskDeletedEvent listener
+func (s *WebHookTaskDeletedEvent) Name() string {
+	return "web.hook.task.deleted.event"
+}
+
+// Handle is executed when the event WebHookTaskDeletedEvent listens on is fired
+func (s *WebHookTaskDeletedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TaskDeletedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTeamDeletedEvent  represents a listener
+type WebHookTeamDeletedEvent struct {
+}
+
+// Name defines the name for the WebHookTeamDeletedEvent listener
+func (s *WebHookTeamDeletedEvent) Name() string {
+	return "web.hook.team.deleted.event"
+}
+
+// Handle is executed when the event WebHookTeamDeletedEvent listens on is fired
+func (s *WebHookTeamDeletedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TeamDeletedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTeamCreatedEvent  represents a listener
+type WebHookTeamCreatedEvent struct {
+}
+
+// Name defines the name for the WebHookTeamCreatedEvent listener
+func (s *WebHookTeamCreatedEvent) Name() string {
+	return "web.hook.team.created.event"
+}
+
+// Handle is executed when the event WebHookTeamCreatedEvent listens on is fired
+func (s *WebHookTeamCreatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TeamCreatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTeamMemberAddedEvent  represents a listener
+type WebHookTeamMemberAddedEvent struct {
+}
+
+// Name defines the name for the WebHookTeamMemberAddedEvent listener
+func (s *WebHookTeamMemberAddedEvent) Name() string {
+	return "web.hook.team.member.added.event"
+}
+
+// Handle is executed when the event WebHookTeamMemberAddedEvent listens on is fired
+func (s *WebHookTeamMemberAddedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TeamMemberAddedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTaskCommentCreatedEvent  represents a listener
+type WebHookTaskCommentCreatedEvent struct {
+}
+
+// Name defines the name for the WebHookTaskCommentCreatedEvent listener
+func (s *WebHookTaskCommentCreatedEvent) Name() string {
+	return "web.hook.task.comment.created.event"
+}
+
+// Handle is executed when the event WebHookTaskCommentCreatedEvent listens on is fired
+func (s *WebHookTaskCommentCreatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TaskCommentCreatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTaskAssigneeCreatedEvent  represents a listener
+type WebHookTaskAssigneeCreatedEvent struct {
+}
+
+// Name defines the name for the WebHookTaskAssigneeCreatedEvent listener
+func (s *WebHookTaskAssigneeCreatedEvent) Name() string {
+	return "web.hook.task.assignee.created.event"
+}
+
+// Handle is executed when the event WebHookTaskAssigneeCreatedEvent listens on is fired
+func (s *WebHookTaskAssigneeCreatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TaskAssigneeCreatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTaskCommentUpdatedEvent  represents a listener
+type WebHookTaskCommentUpdatedEvent struct {
+}
+
+// Name defines the name for the WebHookTaskCommentUpdatedEvent listener
+func (s *WebHookTaskCommentUpdatedEvent) Name() string {
+	return "web.hook.task.comment.updated.event"
+}
+
+// Handle is executed when the event WebHookTaskCommentUpdatedEvent listens on is fired
+func (s *WebHookTaskCommentUpdatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TaskCommentUpdatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+// WebHookTaskUpdatedEvent  represents a listener
+type WebHookTaskUpdatedEvent struct {
+}
+
+// Name defines the name for the WebHookTaskUpdatedEvent listener
+func (s *WebHookTaskUpdatedEvent) Name() string {
+	return "web.hook.task.updated.event"
+}
+
+// Handle is executed when the event WebHookTaskUpdatedEvent listens on is fired
+func (s *WebHookTaskUpdatedEvent) Handle(msg *message.Message) (err error) {
+// -> global handler
+
+  TheGreatWebhookHandler( (&models.TaskUpdatedEvent{}).Name(), msg)
+// end
+
+	return nil
+}
+
+
+func TheGreatWebhookHandler(name string, msg *message.Message) {
+	log.Debugf("Webhook for %s => %s", name, msg.Payload)
+
+	if !config.WebhookEnabled.GetBool() {
+		return 
+	}
+
+	base_url := config.WebhookURL.GetString()
+	webhook_url := fmt.Sprintf("%s?event=%s", base_url, name)
+
+	data := bytes.NewBuffer(msg.Payload)
+	_, err := http.Post(webhook_url, "application/json",data)
+
+	if err != nil {
+		log.Debugf("Webhook failed : %s ", webhook_url )
+	} else {
+  	log.Debugf("Webhook success : %s ", webhook_url )
+	}
+
+}
+
+