fix: date time and improve erorrs (#22)

internal/action/lidarr.go

@@ -48,18 +48,19 @@ func (s *service) lidarr(announce domain.Announce, action domain.Action) error {
 		Indexer:          announce.Site,
 		DownloadProtocol: "torrent",
 		Protocol:         "torrent",
-		PublishDate:      time.Now().String(),
+		PublishDate:      time.Now().Format(time.RFC3339),
 	}
 
-	err = r.Push(release)
+	success, err := r.Push(release)
 	if err != nil {
-		log.Error().Err(err).Msgf("lidarr: failed to push release: %v", release)
+		log.Error().Stack().Err(err).Msgf("lidarr: failed to push release: %v", release)
 		return err
 	}
 
-	// TODO save pushed release
+	if success {
-
+		// TODO save pushed release
-	log.Debug().Msgf("lidarr: successfully pushed release: %v, indexer %v to %v", release.Title, release.Indexer, client.Host)
+		log.Debug().Msgf("lidarr: successfully pushed release: %v, indexer %v to %v", release.Title, release.Indexer, client.Host)
+	}
 
 	return nil
 }

internal/action/radarr.go

@@ -48,18 +48,19 @@ func (s *service) radarr(announce domain.Announce, action domain.Action) error {
 		Indexer:          announce.Site,
 		DownloadProtocol: "torrent",
 		Protocol:         "torrent",
-		PublishDate:      time.Now().String(),
+		PublishDate:      time.Now().Format(time.RFC3339),
 	}
 
-	err = r.Push(release)
+	success, err := r.Push(release)
 	if err != nil {
-		log.Error().Err(err).Msgf("radarr: failed to push release: %v", release)
+		log.Error().Stack().Err(err).Msgf("radarr: failed to push release: %v", release)
 		return err
 	}
 
-	// TODO save pushed release
+	if success {
-
+		// TODO save pushed release
-	log.Debug().Msgf("radarr: successfully pushed release: %v, indexer %v to %v", release.Title, release.Indexer, client.Host)
+		log.Debug().Msgf("radarr: successfully pushed release: %v, indexer %v to %v", release.Title, release.Indexer, client.Host)
+	}
 
 	return nil
 }

internal/action/sonarr.go

@@ -48,18 +48,19 @@ func (s *service) sonarr(announce domain.Announce, action domain.Action) error {
 		Indexer:          announce.Site,
 		DownloadProtocol: "torrent",
 		Protocol:         "torrent",
-		PublishDate:      time.Now().String(),
+		PublishDate:      time.Now().Format(time.RFC3339),
 	}
 
-	err = r.Push(release)
+	success, err := r.Push(release)
 	if err != nil {
-		log.Error().Err(err).Msgf("sonarr: failed to push release: %v", release)
+		log.Error().Stack().Err(err).Msgf("sonarr: failed to push release: %v", release)
 		return err
 	}
 
-	// TODO save pushed release
+	if success {
-
+		// TODO save pushed release
-	log.Debug().Msgf("sonarr: successfully pushed release: %v, indexer %v to %v", release.Title, release.Indexer, client.Host)
+		log.Debug().Msgf("sonarr: successfully pushed release: %v, indexer %v to %v", release.Title, release.Indexer, client.Host)
+	}
 
 	return nil
 }

internal/irc/handler.go

@@ -114,7 +114,7 @@ func (s *Handler) Run() error {
 				s.handleJoined(m)
 
 			case "JOIN":
-				log.Debug().Msgf("%v: JOIN %v", s.network.Server, m.Trailing())
+				log.Debug().Msgf("%v: JOIN %v", s.network.Server, m)
 
 			case "433":
 				// TODO: handle nick in use

pkg/lidarr/client.go

@@ -74,7 +74,7 @@ func (c *client) post(endpoint string, data interface{}) (*http.Response, error)
 		return nil, errors.New("unauthorized: bad credentials")
 	} else if res.StatusCode != http.StatusOK {
 		log.Error().Err(err).Msgf("lidarr client request error: %v", reqUrl)
-		return nil, nil
+		return nil, errors.New("lidarr: bad request")
 	}
 
 	// return raw response and let the caller handle json unmarshal of body

pkg/lidarr/lidarr.go

@@ -2,8 +2,6 @@ package lidarr
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
 	"io"
 	"net/http"
 	"strings"
@@ -24,7 +22,7 @@ type Config struct {
 
 type Client interface {
 	Test() (*SystemStatusResponse, error)
-	Push(release Release) error
+	Push(release Release) (bool, error)
 }
 
 type client struct {
@@ -71,7 +69,7 @@ type SystemStatusResponse struct {
 func (c *client) Test() (*SystemStatusResponse, error) {
 	res, err := c.get("system/status")
 	if err != nil {
-		log.Error().Err(err).Msg("lidarr client get error")
+		log.Error().Stack().Err(err).Msg("lidarr client get error")
 		return nil, err
 	}
 
@@ -79,14 +77,14 @@ func (c *client) Test() (*SystemStatusResponse, error) {
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Error().Err(err).Msg("lidarr client error reading body")
+		log.Error().Stack().Err(err).Msg("lidarr client error reading body")
 		return nil, err
 	}
 
 	response := SystemStatusResponse{}
 	err = json.Unmarshal(body, &response)
 	if err != nil {
-		log.Error().Err(err).Msg("lidarr client error json unmarshal")
+		log.Error().Stack().Err(err).Msg("lidarr client error json unmarshal")
 		return nil, err
 	}
 
@@ -95,37 +93,41 @@ func (c *client) Test() (*SystemStatusResponse, error) {
 	return &response, nil
 }
 
-func (c *client) Push(release Release) error {
+func (c *client) Push(release Release) (bool, error) {
 	res, err := c.post("release/push", release)
 	if err != nil {
-		log.Error().Err(err).Msg("lidarr client post error")
+		log.Error().Stack().Err(err).Msg("lidarr client post error")
-		return err
+		return false, err
+	}
+
+	if res == nil {
+		return false, nil
 	}
 
 	defer res.Body.Close()
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Error().Err(err).Msg("lidarr client error reading body")
+		log.Error().Stack().Err(err).Msg("lidarr client error reading body")
-		return err
+		return false, err
 	}
 
 	pushResponse := PushResponse{}
 	err = json.Unmarshal(body, &pushResponse)
 	if err != nil {
-		log.Error().Err(err).Msg("lidarr client error json unmarshal")
+		log.Error().Stack().Err(err).Msg("lidarr client error json unmarshal")
-		return err
+		return false, err
 	}
 
-	log.Trace().Msgf("lidarr release/push response body: %+v", string(body))
+	log.Trace().Msgf("lidarr release/push response body: %+v", body)
 
 	// log and return if rejected
 	if pushResponse.Rejected {
 		rejections := strings.Join(pushResponse.Rejections, ", ")
 
 		log.Trace().Msgf("lidarr push rejected: %s - reasons: %q", release.Title, rejections)
-		return errors.New(fmt.Errorf("lidarr push rejected %v", rejections).Error())
+		return false, nil
 	}
 
-	return nil
+	return true, nil
 }

pkg/lidarr/lidarr_test.go

@@ -103,7 +103,7 @@ func Test_client_Push(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			c := New(tt.fields.config)
 
-			err := c.Push(tt.args.release)
+			_, err := c.Push(tt.args.release)
 			if tt.wantErr && assert.Error(t, err) {
 				assert.Equal(t, tt.err, err)
 			}

pkg/radarr/client.go

@@ -74,7 +74,7 @@ func (c *client) post(endpoint string, data interface{}) (*http.Response, error)
 		return nil, errors.New("unauthorized: bad credentials")
 	} else if res.StatusCode != http.StatusOK {
 		log.Error().Err(err).Msgf("radarr client request error: %v", reqUrl)
-		return nil, nil
+		return nil, errors.New("radarr: bad request")
 	}
 
 	// return raw response and let the caller handle json unmarshal of body

pkg/radarr/radarr.go

@@ -2,8 +2,6 @@ package radarr
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
 	"io"
 	"net/http"
 	"strings"
@@ -24,7 +22,7 @@ type Config struct {
 
 type Client interface {
 	Test() (*SystemStatusResponse, error)
-	Push(release Release) error
+	Push(release Release) (bool, error)
 }
 
 type client struct {
@@ -70,7 +68,7 @@ type SystemStatusResponse struct {
 func (c *client) Test() (*SystemStatusResponse, error) {
 	res, err := c.get("system/status")
 	if err != nil {
-		log.Error().Err(err).Msg("radarr client get error")
+		log.Error().Stack().Err(err).Msg("radarr client get error")
 		return nil, err
 	}
 
@@ -78,14 +76,14 @@ func (c *client) Test() (*SystemStatusResponse, error) {
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Error().Err(err).Msg("radarr client error reading body")
+		log.Error().Stack().Err(err).Msg("radarr client error reading body")
 		return nil, err
 	}
 
 	response := SystemStatusResponse{}
 	err = json.Unmarshal(body, &response)
 	if err != nil {
-		log.Error().Err(err).Msg("radarr client error json unmarshal")
+		log.Error().Stack().Err(err).Msg("radarr client error json unmarshal")
 		return nil, err
 	}
 
@@ -94,37 +92,42 @@ func (c *client) Test() (*SystemStatusResponse, error) {
 	return &response, nil
 }
 
-func (c *client) Push(release Release) error {
+func (c *client) Push(release Release) (bool, error) {
 	res, err := c.post("release/push", release)
 	if err != nil {
-		log.Error().Err(err).Msg("radarr client post error")
+		log.Error().Stack().Err(err).Msg("radarr client post error")
-		return err
+		return false, err
+	}
+
+	if res == nil {
+		return false, nil
 	}
 
 	defer res.Body.Close()
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Error().Err(err).Msg("radarr client error reading body")
+		log.Error().Stack().Err(err).Msg("radarr client error reading body")
-		return err
+		return false, err
 	}
 
 	pushResponse := make([]PushResponse, 0)
 	err = json.Unmarshal(body, &pushResponse)
 	if err != nil {
-		log.Error().Err(err).Msg("radarr client error json unmarshal")
+		log.Error().Stack().Err(err).Msg("radarr client error json unmarshal")
-		return err
+		return false, err
 	}
 
-	log.Trace().Msgf("radarr release/push response body: %+v", string(body))
+	log.Trace().Msgf("radarr release/push response body: %+v", body)
 
 	// log and return if rejected
 	if pushResponse[0].Rejected {
 		rejections := strings.Join(pushResponse[0].Rejections, ", ")
 
 		log.Trace().Msgf("radarr push rejected: %s - reasons: %q", release.Title, rejections)
-		return errors.New(fmt.Errorf("radarr push rejected %v", rejections).Error())
+		return false, nil
 	}
 
-	return nil
+	// success true
+	return true, nil
 }

pkg/radarr/radarr_test.go

@@ -104,7 +104,7 @@ func Test_client_Push(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			c := New(tt.fields.config)
 
-			err := c.Push(tt.args.release)
+			_, err := c.Push(tt.args.release)
 			if tt.wantErr && assert.Error(t, err) {
 				assert.Equal(t, tt.err, err)
 			}

pkg/sonarr/client.go

@@ -74,7 +74,7 @@ func (c *client) post(endpoint string, data interface{}) (*http.Response, error)
 		return nil, errors.New("unauthorized: bad credentials")
 	} else if res.StatusCode != http.StatusOK {
 		log.Error().Err(err).Msgf("sonarr client request error: %v", reqUrl)
-		return nil, nil
+		return nil, errors.New("sonarr: bad request")
 	}
 
 	// return raw response and let the caller handle json unmarshal of body

pkg/sonarr/sonarr.go

@@ -2,8 +2,6 @@ package sonarr
 
 import (
 	"encoding/json"
-	"errors"
-	"fmt"
 	"io"
 	"net/http"
 	"strings"
@@ -24,7 +22,7 @@ type Config struct {
 
 type Client interface {
 	Test() (*SystemStatusResponse, error)
-	Push(release Release) error
+	Push(release Release) (bool, error)
 }
 
 type client struct {
@@ -71,7 +69,7 @@ type SystemStatusResponse struct {
 func (c *client) Test() (*SystemStatusResponse, error) {
 	res, err := c.get("system/status")
 	if err != nil {
-		log.Error().Err(err).Msg("sonarr client get error")
+		log.Error().Stack().Err(err).Msg("sonarr client get error")
 		return nil, err
 	}
 
@@ -79,14 +77,14 @@ func (c *client) Test() (*SystemStatusResponse, error) {
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Error().Err(err).Msg("sonarr client error reading body")
+		log.Error().Stack().Err(err).Msg("sonarr client error reading body")
 		return nil, err
 	}
 
 	response := SystemStatusResponse{}
 	err = json.Unmarshal(body, &response)
 	if err != nil {
-		log.Error().Err(err).Msg("sonarr client error json unmarshal")
+		log.Error().Stack().Err(err).Msg("sonarr client error json unmarshal")
 		return nil, err
 	}
 
@@ -95,37 +93,42 @@ func (c *client) Test() (*SystemStatusResponse, error) {
 	return &response, nil
 }
 
-func (c *client) Push(release Release) error {
+func (c *client) Push(release Release) (bool, error) {
 	res, err := c.post("release/push", release)
 	if err != nil {
-		log.Error().Err(err).Msg("sonarr client post error")
+		log.Error().Stack().Err(err).Msg("sonarr client post error")
-		return err
+		return false, err
+	}
+
+	if res == nil {
+		return false, nil
 	}
 
 	defer res.Body.Close()
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		log.Error().Err(err).Msg("sonarr client error reading body")
+		log.Error().Stack().Err(err).Msg("sonarr client error reading body")
-		return err
+		return false, err
 	}
 
 	pushResponse := make([]PushResponse, 0)
 	err = json.Unmarshal(body, &pushResponse)
 	if err != nil {
-		log.Error().Err(err).Msg("sonarr client error json unmarshal")
+		log.Error().Stack().Err(err).Msg("sonarr client error json unmarshal")
-		return err
+		return false, err
 	}
 
-	log.Trace().Msgf("sonarr release/push response body: %+v", string(body))
+	log.Trace().Msgf("sonarr release/push response body: %+v", body)
 
 	// log and return if rejected
 	if pushResponse[0].Rejected {
 		rejections := strings.Join(pushResponse[0].Rejections, ", ")
 
 		log.Trace().Msgf("sonarr push rejected: %s - reasons: %q", release.Title, rejections)
-		return errors.New(fmt.Errorf("sonarr push rejected %v", rejections).Error())
+		return false, nil
 	}
 
-	return nil
+	// successful push
+	return true, nil
 }

pkg/sonarr/sonarr_test.go

@@ -104,7 +104,7 @@ func Test_client_Push(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			c := New(tt.fields.config)
 
-			err := c.Push(tt.args.release)
+			_, err := c.Push(tt.args.release)
 			if tt.wantErr && assert.Error(t, err) {
 				assert.Equal(t, tt.err, err)
 			}