libredesk/internal/activity_log/activity_log.go

// Package activity manages activity logs for all users.
package activitylog

import (
	"context"
	"database/sql"
	"embed"
	"fmt"
	"strings"

	"github.com/abhinavxd/libredesk/internal/activity_log/models"
	"github.com/abhinavxd/libredesk/internal/dbutil"
	"github.com/abhinavxd/libredesk/internal/envelope"
	umodels "github.com/abhinavxd/libredesk/internal/user/models"
	"github.com/jmoiron/sqlx"
	"github.com/knadh/go-i18n"
	"github.com/zerodha/logf"
)

var (
	//go:embed queries.sql
	efs embed.FS
)

type Manager struct {
	q    queries
	lo   *logf.Logger
	i18n *i18n.I18n
	db   *sqlx.DB
}

// Opts contains options for initializing the Manager.
type Opts struct {
	DB   *sqlx.DB
	Lo   *logf.Logger
	I18n *i18n.I18n
}

// queries contains prepared SQL queries.
type queries struct {
	GetAllActivities string     `query:"get-all-activities"`
	InsertActivity   *sqlx.Stmt `query:"insert-activity"`
}

// New creates and returns a new instance of the Manager.
func New(opts Opts) (*Manager, error) {
	var q queries
	if err := dbutil.ScanSQLFile("queries.sql", &q, opts.DB, efs); err != nil {
		return nil, err
	}
	return &Manager{
		q:    q,
		lo:   opts.Lo,
		i18n: opts.I18n,
		db:   opts.DB,
	}, nil
}

// GetAll retrieves all activity logs.
func (m *Manager) GetAll(order, orderBy, filtersJSON string, page, pageSize int) ([]models.ActivityLog, error) {
	query, qArgs, err := m.makeQuery(page, pageSize, order, orderBy, filtersJSON)
	if err != nil {
		m.lo.Error("error creating activity log list query", "error", err)
		return nil, envelope.NewError(envelope.GeneralError, m.i18n.T("globals.messages.somethingWentWrong"), nil)
	}

	// Start a read-only txn.
	tx, err := m.db.BeginTxx(context.Background(), &sql.TxOptions{
		ReadOnly: true,
	})
	if err != nil {
		m.lo.Error("error starting read-only transaction", "error", err)
		return nil, envelope.NewError(envelope.GeneralError, m.i18n.T("globals.messages.somethingWentWrong"), nil)
	}
	defer tx.Rollback()

	// Execute query
	var activityLogs = make([]models.ActivityLog, 0)
	if err := tx.Select(&activityLogs, query, qArgs...); err != nil {
		m.lo.Error("error fetching activity logs", "error", err)
		return nil, envelope.NewError(envelope.GeneralError, m.i18n.T("globals.messages.somethingWentWrong"), nil)
	}
	return activityLogs, nil
}

// Login records a login event for the given user.
func (al *Manager) Login(userID int, email, ip string) error {
	description := al.i18n.Ts("activityLog.agentLogin",
		"email", email,
		"userId", fmt.Sprintf("#%d", userID))
	return al.create(
		models.AgentLogin,
		description,
		userID,
		umodels.UserModel,
		userID,
		ip,
	)
}

// Logout records a logout event for the given user.
func (al *Manager) Logout(userID int, email, ip string) error {
	description := al.i18n.Ts("activityLog.agentLogout",
		"email", email,
		"userId", fmt.Sprintf("#%d", userID))
	return al.create(
		models.AgentLogout,
		description,
		userID,
		umodels.UserModel,
		userID,
		ip,
	)
}

// Away records an away event for the given user.
func (al *Manager) Away(actorID int, actorEmail, ip string, targetID int, targetEmail string) error {
	var description string
	if targetID != 0 && targetEmail != "" && (targetID != actorID || targetEmail != actorEmail) {
		description = al.i18n.Ts("activityLog.agentAway",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID),
			"targetEmail", targetEmail,
			"targetId", fmt.Sprintf("#%d", targetID))
	} else {
		description = al.i18n.Ts("activityLog.agentAwaySelf",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID))
	}
	return al.create(
		models.AgentAway, /* activity type*/
		description,
		actorID,           /*actor_id*/
		umodels.UserModel, /*target_model_type*/
		actorID,           /*target_model_id*/
		ip,
	)
}

// AwayReassigned records an away and reassigned event for the given user.
func (al *Manager) AwayReassigned(actorID int, actorEmail, ip string, targetID int, targetEmail string) error {
	var description string
	if targetID != 0 && targetEmail != "" && (targetID != actorID || targetEmail != actorEmail) {
		description = al.i18n.Ts("activityLog.agentAwayReassign",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID),
			"targetEmail", targetEmail,
			"targetId", fmt.Sprintf("#%d", targetID))
	} else {
		description = al.i18n.Ts("activityLog.agentAwayReassignSelf",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID))
	}
	return al.create(
		models.AgentAwayReassigned, /* activity type*/
		description,
		actorID,           /*actor_id*/
		umodels.UserModel, /*target_model_type*/
		actorID,           /*target_model_id*/
		ip,
	)
}

// Online records an online event for the given user.
func (al *Manager) Online(actorID int, actorEmail, ip string, targetID int, targetEmail string) error {
	var description string
	if targetID != 0 && targetEmail != "" && (targetID != actorID || targetEmail != actorEmail) {
		description = al.i18n.Ts("activityLog.agentOnline",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID),
			"targetEmail", targetEmail,
			"targetId", fmt.Sprintf("#%d", targetID))
	} else {
		description = al.i18n.Ts("activityLog.agentOnlineSelf",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID))
	}
	return al.create(
		models.AgentOnline, /* activity type*/
		description,
		actorID,           /*actor_id*/
		umodels.UserModel, /*target_model_type*/
		actorID,           /*target_model_id*/
		ip,
	)
}

// UserAvailability records a user availability event for the given user.
func (al *Manager) UserAvailability(actorID int, actorEmail, status, ip, targetEmail string, targetID int) error {
	switch status {
	case umodels.Online:
		if err := al.Online(actorID, actorEmail, ip, targetID, targetEmail); err != nil {
			return err
		}
	case umodels.AwayManual:
		if err := al.Away(actorID, actorEmail, ip, targetID, targetEmail); err != nil {
			al.lo.Error("error logging away activity", "error", err)
			return err
		}
	case umodels.AwayAndReassigning:
		if err := al.AwayReassigned(actorID, actorEmail, ip, targetID, targetEmail); err != nil {
			al.lo.Error("error logging away and reassigning activity", "error", err)
			return err
		}
	}
	return nil
}

// PasswordSet records a password set event.
func (al *Manager) PasswordSet(actorID int, actorEmail, ip string, targetID int, targetEmail string) error {
	description := al.i18n.Ts("activityLog.agentPasswordSet",
		"actorEmail", actorEmail,
		"actorId", fmt.Sprintf("#%d", actorID),
		"targetEmail", targetEmail,
		"targetId", fmt.Sprintf("#%d", targetID))
	return al.create(
		models.AgentPasswordSet,
		description,
		actorID,
		umodels.UserModel,
		targetID,
		ip,
	)
}

// RolePermissionsChanged records a role permissions change event.
func (al *Manager) RolePermissionsChanged(actorID int, actorEmail, ip string, roleID int, roleName string, added, removed []string) error {
	var description string
	if len(removed) > 0 && len(added) > 0 {
		description = al.i18n.Ts("activityLog.rolePermissionsChanged",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID),
			"removed", strings.Join(removed, ", "),
			"added", strings.Join(added, ", "),
			"roleName", roleName,
			"roleId", fmt.Sprintf("#%d", roleID))
	} else if len(removed) > 0 {
		description = al.i18n.Ts("activityLog.rolePermissionsRemoved",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID),
			"permissions", strings.Join(removed, ", "),
			"roleName", roleName,
			"roleId", fmt.Sprintf("#%d", roleID))
	} else if len(added) > 0 {
		description = al.i18n.Ts("activityLog.rolePermissionsAdded",
			"actorEmail", actorEmail,
			"actorId", fmt.Sprintf("#%d", actorID),
			"permissions", strings.Join(added, ", "),
			"roleName", roleName,
			"roleId", fmt.Sprintf("#%d", roleID))
	} else {
		return nil // No changes
	}
	return al.create(
		models.AgentRolePermissionsChanged,
		description,
		actorID,
		"role",
		roleID,
		ip,
	)
}

// create creates a new activity log in DB.
func (m *Manager) create(activityType, activityDescription string, actorID int, targetModelType string, targetModelID int, ip string) error {
	if _, err := m.q.InsertActivity.Exec(activityType, activityDescription, actorID, targetModelType, targetModelID, ip); err != nil {
		m.lo.Error("error inserting activity log", "error", err)
		return envelope.NewError(envelope.GeneralError, m.i18n.T("globals.messages.somethingWentWrong"), nil)
	}
	return nil
}

// makeQuery constructs the SQL query for fetching activity logs with filters and pagination.
func (m *Manager) makeQuery(page, pageSize int, order, orderBy, filtersJSON string) (string, []any, error) {
	var (
		baseQuery = m.q.GetAllActivities
		qArgs     []any
	)
	return dbutil.BuildPaginatedQuery(baseQuery, qArgs, dbutil.PaginationOptions{
		Order:    order,
		OrderBy:  orderBy,
		Page:     page,
		PageSize: pageSize,
	}, filtersJSON, dbutil.AllowedFields{
		"activity_logs": {"activity_type", "actor_id", "ip", "created_at"},
	})
}