High performance, self-hosted, newsletter and mailing list manager with a modern dashboard. Single binary app.
JavaScript campaigncampaign-managementemail-marketingemail-subscriptionlistmonkmailing-listnewsletternewsletter-managementnewsletter-softwareself-hostedsms-gatewaysmtptransactional-emails
package main
import (
"encoding/json"
"io"
"net/http"
"os"
"strings"
"github.com/knadh/listmonk/internal/auth"
"github.com/knadh/listmonk/internal/subimporter"
"github.com/knadh/listmonk/models"
"github.com/labstack/echo/v5"
)
// importView is the admin view for the subscriber import page.
type importView struct {
adminView
AllLists []models.List
SelectedLists []models.List
Status subimporter.Status
}
// ViewImport renders the HTML view for the subscriber CSV import page.
func (a *App) ViewImport(c *echo.Context) error {
// Get the lists the user can access.
allLists, err := a.getViewableLists(c)
if err != nil {
return err
}
// Get the lists to pre-select (in the form) from the `list_id`` query param.
var selected []models.List
if ids, err := getQueryInts("list_id", c.QueryParams()); err == nil && len(ids) > 0 {
s := make(map[int]struct{}, len(ids))
for _, id := range ids {
s[id] = struct{}{}
}
for _, l := range allLists {
if _, ok := s[l.ID]; ok {
selected = append(selected, l)
}
}
}
data := importView{
adminView: newAdminView(c, a.i18n.T("import.title"), "", "subscribers.import"),
AllLists: allLists,
SelectedLists: selected,
// Live import stats.
Status: a.importer.GetStats(),
}
return c.Render(http.StatusOK, "admin-import", data)
}
// ImportSubscribers handles the uploading and bulk importing of
// a ZIP file of one or more CSV files.
func (a *App) ImportSubscribers(c *echo.Context) error {
// Is an import already running?
if a.importer.GetStats().Status == subimporter.StatusImporting {
return echo.NewHTTPError(http.StatusBadRequest, a.i18n.T("import.alreadyRunning"))
}
// Unmarshal the JSON params.
var opt subimporter.SessionOpt
if err := json.Unmarshal([]byte(c.FormValue("params")), &opt); err != nil {
return echo.NewHTTPError(http.StatusBadRequest,
a.i18n.Ts("globals.messages.invalidParams", "error", err.Error()))
}
// Filter list IDs against the current user's permitted lists.
// Blocklist mode doesn't require list subscriptions.
user := auth.GetUser(c)
// Because blocklisting is a global subscriber-level action that supercedes all lists,
// mandate the full list management permission.
if opt.Mode == subimporter.ModeBlocklist && !user.HasPerm(auth.PermListManageAll) {
return echo.NewHTTPError(http.StatusForbidden,
a.i18n.Ts("globals.messages.permissionDenied", "name", auth.PermListManageAll))
}
opt.ListIDs = user.FilterListsByPerm(auth.PermTypeManage, opt.ListIDs)
if len(opt.ListIDs) == 0 && opt.Mode != subimporter.ModeBlocklist {
return echo.NewHTTPError(http.StatusForbidden,
a.i18n.Ts("globals.messages.permissionDenied", "name", "lists"))
}
// Validate mode.
if opt.Mode != subimporter.ModeSubscribe && opt.Mode != subimporter.ModeBlocklist {
return echo.NewHTTPError(http.StatusBadRequest, a.i18n.T("globals.messages.invalidMode"))
}
// If no status is specified, pick a default one.
if opt.SubStatus == "" {
switch opt.Mode {
case subimporter.ModeSubscribe:
opt.SubStatus = models.SubscriptionStatusUnconfirmed
case subimporter.ModeBlocklist:
opt.SubStatus = models.SubscriptionStatusUnsubscribed
}
}
if opt.SubStatus != models.SubscriptionStatusUnconfirmed &&
opt.SubStatus != models.SubscriptionStatusConfirmed &&
opt.SubStatus != models.SubscriptionStatusUnsubscribed {
return echo.NewHTTPError(http.StatusBadRequest, a.i18n.T("import.invalidSubStatus"))
}
if len(opt.Delim) != 1 {
return echo.NewHTTPError(http.StatusBadRequest, a.i18n.T("import.invalidDelim"))
}
// Open the HTTP file.
file, err := c.FormFile("file")
if err != nil {
return echo.NewHTTPError(http.StatusBadRequest,
a.i18n.Ts("globals.messages.invalidFile", "error", err.Error()))
}
src, err := file.Open()
if err != nil {
return err
}
defer src.Close()
// Copy it to a temp location.
out, err := os.CreateTemp("", "listmonk")
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError,
a.i18n.Ts("globals.messages.errorCopyingFile", "error", err.Error()))
}
defer out.Close()
if _, err = io.Copy(out, src); err != nil {
return echo.NewHTTPError(http.StatusInternalServerError,
a.i18n.Ts("globals.messages.errorCopyingFile", "error", err.Error()))
}
// Start the importer session.
opt.Filename = file.Filename
sess, err := a.importer.NewSession(opt)
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError,
a.i18n.Ts("import.errorStarting", "error", err.Error()))
}
go sess.Start()
if strings.HasSuffix(strings.ToLower(file.Filename), ".csv") {
go sess.LoadCSV(out.Name(), rune(opt.Delim[0]))
} else {
// Only 1 CSV from the ZIP is considered. If multiple files have
// to be processed, counting the net number of lines (to track progress),
// keeping the global import state (failed / successful) etc. across
// multiple files becomes complex. Instead, it's just easier for the
// end user to concat multiple CSVs (if there are multiple in the first)
// place and upload as one in the first place.
dir, files, err := sess.ExtractZIP(out.Name(), 1)
if err != nil {
return echo.NewHTTPError(http.StatusInternalServerError,
a.i18n.Ts("import.errorProcessingZIP", "error", err.Error()))
}
go sess.LoadCSV(dir+"/"+files[0], rune(opt.Delim[0]))
}
return c.JSON(http.StatusOK, okResp{a.importer.GetStats()})
}
// GetImportSubscribers returns import statistics.
func (a *App) GetImportSubscribers(c *echo.Context) error {
s := a.importer.GetStats()
return c.JSON(http.StatusOK, okResp{s})
}
// GetImportSubscriberStats returns import statistics.
func (a *App) GetImportSubscriberStats(c *echo.Context) error {
return c.JSON(http.StatusOK, okResp{string(a.importer.GetLogs())})
}
// StopImportSubscribers sends a stop signal to the importer.
// If there's an ongoing import, it'll be stopped, and if an import
// is finished, it's state is cleared.
func (a *App) StopImportSubscribers(c *echo.Context) error {
a.importer.Stop()
return c.JSON(http.StatusOK, okResp{a.importer.GetStats()})
}