Skip to content

High performance, self-hosted, newsletter and mailing list manager with a modern dashboard. Single binary app.

8.7 KB
Raw Blame
package main

import (
	"net/http"
	"time"

	"github.com/knadh/listmonk/internal/auth"
	"github.com/knadh/listmonk/models"
	"github.com/labstack/echo/v5"
)

// analyticsData is the chart data embedded into the analytics page for the Chart.js renderer.
type analyticsData struct {
	Items           []models.AnalyticsItem          `json:"items"`
	Subscriptions   []models.CampaignAnalyticsCount `json:"subscriptions"`
	Unsubscriptions []models.CampaignAnalyticsCount `json:"unsubscriptions"`
	Views           []models.CampaignAnalyticsCount `json:"views"`
	Clicks          []models.CampaignAnalyticsCount `json:"clicks"`
	UniqueViews     []models.CampaignAnalyticsCount `json:"unique_views,omitempty"`
	UniqueClicks    []models.CampaignAnalyticsCount `json:"unique_clicks,omitempty"`
	Bounces         []models.CampaignAnalyticsCount `json:"bounces"`
	Links           []models.CampaignAnalyticsLink  `json:"links"`
}

// analyticsView is the shared admin view for campaign and list analytics.
type analyticsView struct {
	adminView

	Items                 []models.AnalyticsItem
	Resource              string
	CanViewCampaignCharts bool
	FromInput             string
	ToInput               string
	Interval              string
	DisableTracking       bool
	IndividualTracking    bool
	ShowUnique            bool

	HasData bool
	Counts  struct {
		Subscriptions   int
		Unsubscriptions int
		Views           int
		Clicks          int
		UniqueViews     int
		UniqueClicks    int
		Bounces         int
	}
	Data analyticsData
}

// ViewCampaignAnalytics renders the HTML view for campaign analytics.
func (a *App) ViewCampaignAnalytics(c *echo.Context) error {
	return a.viewAnalytics(c, models.ResourceCampaigns)
}

// ViewListAnalytics renders analytics for selected lists.
func (a *App) ViewListAnalytics(c *echo.Context) error {
	return a.viewAnalytics(c, models.ResourceLists)
}

func (a *App) viewAnalytics(c *echo.Context, resource string) error {
	user := auth.GetUser(c)
	ids, err := getQueryInts("id", c.QueryParams())
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest,
			a.i18n.Ts("globals.messages.errorInvalidIDs", "error", err.Error()))
	}

	getAll, permittedLists := user.GetPermittedLists(auth.PermTypeGet)
	if resource == models.ResourceCampaigns {
		getAll, permittedLists = user.GetPermittedLists(auth.PermTypeGet | auth.PermTypeManage)
		getAll = getAll || user.HasPerm(auth.PermCampaignsGetAll)
	}

	items, err := a.core.GetAnalyticsItems(resource, ids, getAll, permittedLists)
	if err != nil {
		return err
	}

	// Resolve the date range, defaulting to the last 7 days.
	var (
		to   = time.Now()
		from = to.AddDate(0, 0, -7)
	)
	if t, ok := parseDateTime(c.QueryParam("from")); ok {
		from = t
	}
	if t, ok := parseDateTime(c.QueryParam("to")); ok {
		to = t
	}

	data := analyticsView{
		adminView:          newAdminView(c, a.i18n.T("globals.terms.analytics"), "", resource+".analytics"),
		Items:              items,
		Resource:           resource,
		FromInput:          from.Format(time.RFC3339),
		ToInput:            to.Format(time.RFC3339),
		Interval:           c.QueryParam("interval"),
		DisableTracking:    a.cfg.Privacy.DisableTracking,
		IndividualTracking: a.cfg.Privacy.IndividualTracking,
		ShowUnique:         a.cfg.Privacy.IndividualTracking && c.QueryParam("unique") == "true",
	}

	data.CanViewCampaignCharts = resource == models.ResourceCampaigns || (data.Can(auth.PermCampaignsGet, auth.PermCampaignsGetAll) && data.Can(auth.PermCampaignsGetAnalytics))

	if data.Interval == "" {
		data.Interval = models.AnalyticsIntervalDay
	}

	// Pull analytics for the selected campaigns or lists.
	if len(items) > 0 {
		var (
			fromStr = from.Format(time.RFC3339)
			toStr   = to.Format(time.RFC3339)
			ids     = make([]int, len(items))
		)
		for i, item := range items {
			ids[i] = item.ID
		}

		data.HasData = true
		data.Data.Items = items
		getCounts := a.core.GetCampaignAnalyticsCounts
		getLinks := a.core.GetCampaignAnalyticsLinks

		if resource == models.ResourceLists {
			getCounts = a.core.GetListAnalyticsCounts
			getLinks = a.core.GetListAnalyticsLinks
			rows, err := getCounts(ids, models.AnalyticsTypeSubscriptions, fromStr, toStr, data.Interval)
			if err != nil {
				return err
			}

			data.Data.Subscriptions = rows
			data.Counts.Subscriptions = sumAnalyticsCounts(rows)
			rows, err = getCounts(ids, models.AnalyticsTypeUnsubscriptions, fromStr, toStr, data.Interval)
			if err != nil {
				return err
			}

			data.Data.Unsubscriptions = rows
			data.Counts.Unsubscriptions = sumAnalyticsCounts(rows)
		}

		if data.CanViewCampaignCharts {
			var err error
			data.Data.Views, err = getCounts(ids, models.AnalyticsTypeTotalViews, fromStr, toStr, data.Interval)
			if err != nil {
				return err
			}

			data.Data.Clicks, err = getCounts(ids, models.AnalyticsTypeTotalClicks, fromStr, toStr, data.Interval)
			if err != nil {
				return err
			}

			if data.ShowUnique {
				data.Data.UniqueViews, err = getCounts(ids, models.AnalyticsTypeViews, fromStr, toStr, data.Interval)
				if err != nil {
					return err
				}

				data.Data.UniqueClicks, err = getCounts(ids, models.AnalyticsTypeClicks, fromStr, toStr, data.Interval)
				if err != nil {
					return err
				}

				data.Counts.UniqueViews = sumAnalyticsCounts(data.Data.UniqueViews)
				data.Counts.UniqueClicks = sumAnalyticsCounts(data.Data.UniqueClicks)
			}

			data.Data.Bounces, err = getCounts(ids, models.AnalyticsTypeBounces, fromStr, toStr, data.Interval)
			if err != nil {
				return err
			}

			data.Data.Links, err = getLinks(ids, fromStr, toStr)
			if err != nil {
				return err
			}

			data.Counts.Views = sumAnalyticsCounts(data.Data.Views)
			data.Counts.Clicks = sumAnalyticsCounts(data.Data.Clicks)
			data.Counts.Bounces = sumAnalyticsCounts(data.Data.Bounces)
		}
	}

	return c.Render(http.StatusOK, "admin-analytics", data)
}

// GetCampaignViewAnalytics retrieves analytics for campaigns.
func (a *App) GetCampaignViewAnalytics(c *echo.Context) error {
	return a.getAnalytics(c, models.ResourceCampaigns)
}

// GetListAnalytics retrieves analytics for lists.
func (a *App) GetListAnalytics(c *echo.Context) error {
	return a.getAnalytics(c, models.ResourceLists)
}

func (a *App) getAnalytics(c *echo.Context, resource string) error {
	ids, err := parseStringIDs(c.Request().URL.Query()["id"])
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest,
			a.i18n.Ts("globals.messages.errorInvalidIDs", "error", err.Error()))
	}

	if len(ids) == 0 {
		return echo.NewHTTPError(http.StatusBadRequest,
			a.i18n.Ts("globals.messages.missingFields", "name", "`id`"))
	}

	getCounts := a.core.GetCampaignAnalyticsCounts
	getLinks := a.core.GetCampaignAnalyticsLinks
	if resource == models.ResourceLists {
		user := auth.GetUser(c)
		if err := user.HasListPerm(auth.PermTypeGet, ids...); err != nil {
			return err
		}
		// Match the list page: campaign metrics require campaign analytics access.
		if typ := c.Param("type"); typ != models.AnalyticsTypeSubscriptions && typ != models.AnalyticsTypeUnsubscriptions {
			if !(user.HasPerm(auth.PermCampaignsGet) || user.HasPerm(auth.PermCampaignsGetAll)) || !user.HasPerm(auth.PermCampaignsGetAnalytics) {
				return auth.ErrPermDenied
			}
		}
		getCounts = a.core.GetListAnalyticsCounts
		getLinks = a.core.GetListAnalyticsLinks
	} else {
		// Ensure the user has access to campaigns via lists.
		for _, id := range ids {
			if err := a.checkCampaignPerm(auth.PermTypeGet, id, c); err != nil {
				return err
			}
		}
	}

	var (
		typ  = c.Param("type")
		from = c.QueryParams().Get("from")
		to   = c.QueryParams().Get("to")
	)
	if !strHasLen(from, 10, 30) || !strHasLen(to, 10, 30) {
		return echo.NewHTTPError(http.StatusBadRequest, a.i18n.T("analytics.invalidDates"))
	}

	// Link stats.
	if typ == models.AnalyticsTypeLinks {
		out, err := getLinks(ids, from, to)
		if err != nil {
			return err
		}

		return c.JSON(http.StatusOK, okResp{out})
	}

	interval := c.QueryParam("interval")
	if interval == "" {
		interval = models.AnalyticsIntervalDay
	}

	// Views and clicks default to totals, with unique counts available when tracking is on.
	if c.QueryParam("unique") != "true" || !a.cfg.Privacy.IndividualTracking {
		switch typ {
		case models.AnalyticsTypeViews:
			typ = models.AnalyticsTypeTotalViews
		case models.AnalyticsTypeClicks:
			typ = models.AnalyticsTypeTotalClicks
		}
	}

	// Get the analytics numbers from the DB.
	out, err := getCounts(ids, typ, from, to, interval)
	if err != nil {
		return err
	}

	return c.JSON(http.StatusOK, okResp{out})
}

// sumAnalyticsCounts returns the combined list totals when available or sums up the rows.
func sumAnalyticsCounts(rows []models.CampaignAnalyticsCount) int {
	if len(rows) > 0 && rows[0].Total != nil {
		return *rows[0].Total
	}

	total := 0
	for _, r := range rows {
		total += r.Count
	}

	return total
}