14283825881

Committed 05 Apr 2025 04:39PM UTC coverage: 30.292% (-36.9%) from 67.207%

Build # 14283825881

Build Type

push

github

Committed by

gregdel

Commit Message

Fix log warning

Signed-off-by: Lucas BEE <pouulet@gmail.com>

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

2693 of 8890 relevant lines covered (30.29%)

0.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/modules/webhook/webhook.go

package webhook

import (
        "bytes"
        "context"
        "encoding/json"
        "errors"
        "fmt"
        "html/template"
        "net/http"
        "time"

        "gopkg.in/yaml.v2"

        polochon "github.com/odwrtw/polochon/lib"
        "github.com/sirupsen/logrus"
)

// Make sure that the module is a notifier
var _ polochon.Notifier = (*WebHook)(nil)

func init() {
        polochon.RegisterModule(&WebHook{})
}

// WebHook errors
var (
        ErrInvalidArgument = errors.New("webhook: invalid argument type")
)

// Module constants
const (
        moduleName = "webhook"
)

// Params are the params for webhooks
type Params struct {
        Hooks []*Hook `yaml:"hooks"`
}

// Hook represents a Hook
type Hook struct {
        URLTemplate *template.Template `yaml:"-"`
        URL         string             `yaml:"url"`
}

// WebHook stores the webhook configs
type WebHook struct {
        httpClient *http.Client
        hooks      []*Hook
        configured bool
}

// Init implements the module interface
func (w *WebHook) Init(p []byte) error {
        if w.configured {
                return nil
        }

        params := &Params{}
        if err := yaml.Unmarshal(p, &params); err != nil {
                return err
        }

        return w.InitWithParams(params)
}

// InitWithParams configures the module
func (w *WebHook) InitWithParams(params *Params) error {
        for _, h := range params.Hooks {
                url, err := template.New("url").Parse(h.URL)
                if err != nil {
                        return err
                }
                h.URLTemplate = url
        }

        w.hooks = params.Hooks
        w.httpClient = http.DefaultClient
        w.configured = true

        return nil
}

// Name implements the Module interface
func (w *WebHook) Name() string {
        return moduleName
}

// Status implements the Module interface
func (w *WebHook) Status() (polochon.ModuleStatus, error) {
        return polochon.StatusNotImplemented, nil
}

// Notify sends a notification to the recipient
func (w *WebHook) Notify(i interface{}, log *logrus.Entry) error {
        var videoType string
        var video polochon.Video

        switch v := i.(type) {
        case *polochon.ShowEpisode:
                videoType = "episode"
                video = v
        case *polochon.Movie:
                videoType = "movie"
                video = v
        default:
                return ErrInvalidArgument
        }

        for _, h := range w.hooks {
                err := w.notify(h, video, videoType)
                if err != nil {
                        log.Warn(err.Error())
                }
        }

        return nil
}

func (w *WebHook) notify(hook *Hook, video polochon.Video, videoType string) error {
        var URL bytes.Buffer
        err := hook.URLTemplate.Execute(&URL, video)
        if err != nil {
                return err
        }

        b := new(bytes.Buffer)
        json.NewEncoder(b).Encode(struct {
                Type string      `json:"type"`
                Data interface{} `json:"data"`
        }{
                Type: videoType,
                Data: video,
        })

        req, err := http.NewRequest("POST", URL.String(), b)
        if err != nil {
                return err
        }

        req.Header.Set("Content-Type", "application/json")

        // Add a context with a timeout to the request
        ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
        defer cancel()

        // Send request
        resp, err := w.httpClient.Do(req.WithContext(ctx))
        if err != nil {
                return err
        }
        defer resp.Body.Close()

        // If status > 400, something's wrong
        if resp.StatusCode >= http.StatusBadRequest {
                return fmt.Errorf("%s call failed with error %d", URL.String(), resp.StatusCode)
        }

        return nil
}

1	package webhook
2
3	import (
4	"bytes"
5	"context"
6	"encoding/json"
7	"errors"
8	"fmt"
9	"html/template"
10	"net/http"
11	"time"
12
13	"gopkg.in/yaml.v2"
14
15	polochon "github.com/odwrtw/polochon/lib"
16	"github.com/sirupsen/logrus"
17	)
18
19	// Make sure that the module is a notifier
20	var _ polochon.Notifier = (*WebHook)(nil)
21
22	func init() {	×
23	polochon.RegisterModule(&WebHook{})	×
24	}	×
25
26	// WebHook errors
27	var (
28	ErrInvalidArgument = errors.New("webhook: invalid argument type")
29	)
30
31	// Module constants
32	const (
33	moduleName = "webhook"
34	)
35
36	// Params are the params for webhooks
37	type Params struct {
38	Hooks []*Hook `yaml:"hooks"`
39	}
40
41	// Hook represents a Hook
42	type Hook struct {
43	URLTemplate *template.Template `yaml:"-"`
44	URL string `yaml:"url"`
45	}
46
47	// WebHook stores the webhook configs
48	type WebHook struct {
49	httpClient *http.Client
50	hooks []*Hook
51	configured bool
52	}
53
54	// Init implements the module interface
55	func (w *WebHook) Init(p []byte) error {	×
56	if w.configured {	×
57	return nil	×
58	}	×
59
60	params := &Params{}	×
61	if err := yaml.Unmarshal(p, &params); err != nil {	×
62	return err	×
63	}	×
64
65	return w.InitWithParams(params)	×
66	}
67
68	// InitWithParams configures the module
69	func (w WebHook) InitWithParams(params Params) error {	×
70	for _, h := range params.Hooks {	×
71	url, err := template.New("url").Parse(h.URL)	×
72	if err != nil {	×
73	return err	×
74	}	×
75	h.URLTemplate = url	×
76	}
77
78	w.hooks = params.Hooks	×
79	w.httpClient = http.DefaultClient	×
80	w.configured = true	×
81		×
82	return nil	×
83	}
84
85	// Name implements the Module interface
86	func (w *WebHook) Name() string {	×
87	return moduleName	×
88	}	×
89
90	// Status implements the Module interface
91	func (w *WebHook) Status() (polochon.ModuleStatus, error) {	×
92	return polochon.StatusNotImplemented, nil	×
93	}	×
94
95	// Notify sends a notification to the recipient
96	func (w WebHook) Notify(i interface{}, log logrus.Entry) error {	×
97	var videoType string	×
98	var video polochon.Video	×
99		×
100	switch v := i.(type) {	×
101	case *polochon.ShowEpisode:	×
102	videoType = "episode"	×
103	video = v	×
104	case *polochon.Movie:	×
105	videoType = "movie"	×
106	video = v	×
107	default:	×
108	return ErrInvalidArgument	×
109	}
110
111	for _, h := range w.hooks {	×
112	err := w.notify(h, video, videoType)	×
113	if err != nil {	×
NEW 114	log.Warn(err.Error())	×
115	}	×
116	}
117
118	return nil	×
119	}
120
121	func (w WebHook) notify(hook Hook, video polochon.Video, videoType string) error {	×
122	var URL bytes.Buffer	×
123	err := hook.URLTemplate.Execute(&URL, video)	×
124	if err != nil {	×
125	return err	×
126	}	×
127
128	b := new(bytes.Buffer)	×
129	json.NewEncoder(b).Encode(struct {	×
130	Type string `json:"type"`	×
131	Data interface{} `json:"data"`	×
132	}{	×
133	Type: videoType,	×
134	Data: video,	×
135	})	×
136		×
137	req, err := http.NewRequest("POST", URL.String(), b)	×
138	if err != nil {	×
139	return err	×
140	}	×
141
142	req.Header.Set("Content-Type", "application/json")	×
143		×
144	// Add a context with a timeout to the request	×
145	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)	×
146	defer cancel()	×
147		×
148	// Send request	×
149	resp, err := w.httpClient.Do(req.WithContext(ctx))	×
150	if err != nil {	×
151	return err	×
152	}	×
153	defer resp.Body.Close()	×
154		×
155	// If status > 400, something's wrong	×
156	if resp.StatusCode >= http.StatusBadRequest {	×
157	return fmt.Errorf("%s call failed with error %d", URL.String(), resp.StatusCode)	×
158	}	×
159
160	return nil	×
161	}

odwrtw / polochon / 14283825881

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous