Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

6.9 KB
Raw Blame
package listmonk

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

	"github.com/ente/stacktrace"
)

type Credentials struct {
	BaseURL  string
	Username string
	Password string
}

const listmonkRequestTimeout = 60 * time.Second

var ErrSubscriberNotFound = errors.New("subscriber not found")

type Subscriber struct {
	Email   string
	ListIDs []int
}

type SubscribersPage struct {
	Results []Subscriber
	Total   int
	Page    int
	PerPage int
}

func GetSubscriberID(endpoint string, username string, password string, subscriberEmail string) (int, error) {
	type SubscriberResponse struct {
		Data struct {
			Results []struct {
				ID int `json:"id"`
			} `json:"results"`
		} `json:"data"`
	}

	// Escape single quotes to prevent SQL-like injection in Listmonk's query syntax
	sanitizedEmail := strings.ReplaceAll(subscriberEmail, "'", "''")
	queryParams := url.Values{}
	queryParams.Set("query", fmt.Sprintf("subscribers.email = '%s'", sanitizedEmail))

	endpointURL, err := url.Parse(endpoint)
	if err != nil {
		return 0, stacktrace.Propagate(err, "")
	}
	endpointURL.RawQuery = queryParams.Encode()

	req, err := http.NewRequest("GET", endpointURL.String(), nil)
	if err != nil {
		return 0, stacktrace.Propagate(err, "")
	}

	req.SetBasicAuth(username, password)

	client := &http.Client{Timeout: listmonkRequestTimeout}
	resp, err := client.Do(req)
	if err != nil {
		return 0, stacktrace.Propagate(err, "")
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return 0, stacktrace.Propagate(err, "")
	}
	if resp.StatusCode != http.StatusOK {
		return 0, stacktrace.Propagate(
			fmt.Errorf("listmonk request failed with status %d: %s", resp.StatusCode, strings.TrimSpace(string(body))),
			"",
		)
	}

	var subscriberResp SubscriberResponse
	if err := json.Unmarshal(body, &subscriberResp); err != nil {
		return 0, stacktrace.Propagate(err, "")
	}

	if len(subscriberResp.Data.Results) == 0 {
		return 0, stacktrace.Propagate(ErrSubscriberNotFound, "")
	}

	id := subscriberResp.Data.Results[0].ID

	return id, nil
}

func ListSubscribers(endpoint string, username string, password string, page int, perPage int) (SubscribersPage, error) {
	type subscriberResponse struct {
		Data struct {
			Results []map[string]json.RawMessage `json:"results"`
			Total   int                          `json:"total"`
			Page    int                          `json:"page"`
			PerPage int                          `json:"per_page"`
		} `json:"data"`
	}

	endpointURL, err := url.Parse(endpoint)
	if err != nil {
		return SubscribersPage{}, stacktrace.Propagate(err, "")
	}

	queryParams := endpointURL.Query()
	queryParams.Set("page", strconv.Itoa(page))
	queryParams.Set("per_page", strconv.Itoa(perPage))
	endpointURL.RawQuery = queryParams.Encode()

	req, err := http.NewRequest("GET", endpointURL.String(), nil)
	if err != nil {
		return SubscribersPage{}, stacktrace.Propagate(err, "")
	}
	req.SetBasicAuth(username, password)

	client := &http.Client{Timeout: listmonkRequestTimeout}
	resp, err := client.Do(req)
	if err != nil {
		return SubscribersPage{}, stacktrace.Propagate(err, "")
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return SubscribersPage{}, stacktrace.Propagate(err, "")
	}
	if resp.StatusCode != http.StatusOK {
		return SubscribersPage{}, stacktrace.Propagate(
			fmt.Errorf("listmonk request failed with status %d: %s", resp.StatusCode, strings.TrimSpace(string(body))),
			"",
		)
	}

	var parsed subscriberResponse
	if err := json.Unmarshal(body, &parsed); err != nil {
		return SubscribersPage{}, stacktrace.Propagate(err, "")
	}

	results := make([]Subscriber, 0, len(parsed.Data.Results))
	for _, row := range parsed.Data.Results {
		subscriber, parseErr := parseSubscriber(row)
		if parseErr != nil {
			return SubscribersPage{}, stacktrace.Propagate(parseErr, "")
		}
		results = append(results, subscriber)
	}

	return SubscribersPage{
		Results: results,
		Total:   parsed.Data.Total,
		Page:    parsed.Data.Page,
		PerPage: parsed.Data.PerPage,
	}, nil
}

func parseSubscriber(data map[string]json.RawMessage) (Subscriber, error) {
	emailRaw, ok := data["email"]
	if !ok {
		return Subscriber{}, stacktrace.Propagate(errors.New("missing email in listmonk subscriber payload"), "")
	}
	var email string
	if err := json.Unmarshal(emailRaw, &email); err != nil {
		return Subscriber{}, stacktrace.Propagate(err, "failed to parse listmonk subscriber email")
	}

	var listIDs []int
	if listsRaw, ok := data["lists"]; ok {
		ids, err := decodeListIDs(listsRaw)
		if err != nil {
			return Subscriber{}, stacktrace.Propagate(err, "failed to parse listmonk subscriber lists")
		}
		listIDs = ids
	} else if listIDsRaw, ok := data["list_ids"]; ok {
		ids, err := decodeListIDs(listIDsRaw)
		if err != nil {
			return Subscriber{}, stacktrace.Propagate(err, "failed to parse listmonk subscriber list_ids")
		}
		listIDs = ids
	}

	return Subscriber{
		Email:   email,
		ListIDs: listIDs,
	}, nil
}

func decodeListIDs(raw json.RawMessage) ([]int, error) {
	type listWithID struct {
		ID int `json:"id"`
	}

	if len(raw) == 0 || string(raw) == "null" {
		return []int{}, nil
	}

	var directIntIDs []int
	if err := json.Unmarshal(raw, &directIntIDs); err == nil {
		return directIntIDs, nil
	}

	var objectIDs []listWithID
	if err := json.Unmarshal(raw, &objectIDs); err == nil {
		ids := make([]int, 0, len(objectIDs))
		for _, item := range objectIDs {
			ids = append(ids, item.ID)
		}
		return ids, nil
	}

	var generic []map[string]interface{}
	if err := json.Unmarshal(raw, &generic); err == nil {
		ids := make([]int, 0, len(generic))
		for _, item := range generic {
			value, ok := item["id"]
			if !ok {
				continue
			}
			switch typed := value.(type) {
			case float64:
				ids = append(ids, int(typed))
			case int:
				ids = append(ids, typed)
			case string:
				id, convErr := strconv.Atoi(typed)
				if convErr == nil {
					ids = append(ids, id)
				}
			}
		}
		return ids, nil
	}

	return nil, errors.New("unsupported list ids format")
}

func SendRequest(method string, url string, data interface{}, username string, password string) error {
	jsonData, err := json.Marshal(data)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}

	client := &http.Client{Timeout: listmonkRequestTimeout}
	req, err := http.NewRequest(method, url, bytes.NewBuffer(jsonData))
	if err != nil {
		return stacktrace.Propagate(err, "")
	}

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

	resp, err := client.Do(req)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, readErr := io.ReadAll(resp.Body)
		if readErr != nil {
			return stacktrace.Propagate(readErr, "")
		}
		return stacktrace.Propagate(
			fmt.Errorf("listmonk request failed with status %d: %s", resp.StatusCode, strings.TrimSpace(string(body))),
			"",
		)
	}

	return nil
}