441 lines
16 KiB
Go
441 lines
16 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"code.springupsoftware.com/cmc/cmc-sales/internal/cmc/db"
|
|
"code.springupsoftware.com/cmc/cmc-sales/internal/cmc/templates"
|
|
)
|
|
|
|
// Import getUsername from pages.go
|
|
// If you move getUsername to a shared utils package, update the import accordingly.
|
|
func getUsername(r *http.Request) string {
|
|
username, _, ok := r.BasicAuth()
|
|
if ok && username != "" {
|
|
// Capitalise the username for display
|
|
return strings.Title(username)
|
|
}
|
|
return "Guest"
|
|
}
|
|
|
|
// Helper: returns date string or empty if zero
|
|
func formatDate(t time.Time) string {
|
|
if t.IsZero() || t.Year() == 1970 {
|
|
return ""
|
|
}
|
|
return t.UTC().Format(time.RFC3339)
|
|
}
|
|
|
|
// Helper: checks if a time is a valid DB value (not zero or 1970-01-01)
|
|
func isValidDBTime(t time.Time) bool {
|
|
return !t.IsZero() && t.After(time.Date(1971, 1, 1, 0, 0, 0, 0, time.UTC))
|
|
}
|
|
|
|
// calcExpiryInfo is a helper to calculate expiry info for a quote
|
|
func calcExpiryInfo(validUntil time.Time) (string, int, int) {
|
|
now := time.Now()
|
|
nowDate := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
|
|
validUntilDate := time.Date(validUntil.Year(), validUntil.Month(), validUntil.Day(), 0, 0, 0, 0, validUntil.Location())
|
|
daysUntil := int(validUntilDate.Sub(nowDate).Hours() / 24)
|
|
daysSince := int(nowDate.Sub(validUntilDate).Hours() / 24)
|
|
var relative string
|
|
if validUntilDate.After(nowDate) || validUntilDate.Equal(nowDate) {
|
|
switch daysUntil {
|
|
case 0:
|
|
relative = "expires today"
|
|
case 1:
|
|
relative = "expires tomorrow"
|
|
default:
|
|
relative = "expires in " + strconv.Itoa(daysUntil) + " days"
|
|
}
|
|
} else {
|
|
switch daysSince {
|
|
case 0:
|
|
relative = "expired today"
|
|
case 1:
|
|
relative = "expired yesterday"
|
|
default:
|
|
relative = "expired " + strconv.Itoa(daysSince) + " days ago"
|
|
}
|
|
}
|
|
return relative, daysUntil, daysSince
|
|
}
|
|
|
|
// QuoteRow interface for all quote row types
|
|
// (We use wrapper types since sqlc structs can't be modified directly)
|
|
type QuoteRow interface {
|
|
GetID() int32
|
|
GetUsername() string
|
|
GetEnquiryID() int32
|
|
GetEnquiryRef() string
|
|
GetDateIssued() time.Time
|
|
GetValidUntil() time.Time
|
|
GetReminderType() int32
|
|
GetReminderSent() time.Time
|
|
GetCustomerName() string
|
|
GetCustomerEmail() string
|
|
}
|
|
|
|
// Wrapper types for each DB row struct
|
|
|
|
type ExpiringSoonQuoteRowWrapper struct{ db.GetExpiringSoonQuotesRow }
|
|
|
|
func (q ExpiringSoonQuoteRowWrapper) GetID() int32 { return q.DocumentID }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetUsername() string { return q.Username }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetEnquiryID() int32 { return q.EnquiryID }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetEnquiryRef() string { return q.EnquiryRef }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetDateIssued() time.Time { return q.DateIssued }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetValidUntil() time.Time { return q.ValidUntil }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetReminderType() int32 { return q.LatestReminderType }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetReminderSent() time.Time { return q.LatestReminderSentTime }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetCustomerName() string { return q.CustomerName }
|
|
func (q ExpiringSoonQuoteRowWrapper) GetCustomerEmail() string { return q.CustomerEmail }
|
|
|
|
type RecentlyExpiredQuoteRowWrapper struct{ db.GetRecentlyExpiredQuotesRow }
|
|
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetID() int32 { return q.DocumentID }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetUsername() string { return q.Username }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetEnquiryID() int32 { return q.EnquiryID }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetEnquiryRef() string { return q.EnquiryRef }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetDateIssued() time.Time { return q.DateIssued }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetValidUntil() time.Time { return q.ValidUntil }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetReminderType() int32 { return q.LatestReminderType }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetReminderSent() time.Time { return q.LatestReminderSentTime }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetCustomerName() string { return q.CustomerName }
|
|
func (q RecentlyExpiredQuoteRowWrapper) GetCustomerEmail() string { return q.CustomerEmail }
|
|
|
|
type ExpiringSoonQuoteOnDayRowWrapper struct {
|
|
db.GetExpiringSoonQuotesOnDayRow
|
|
}
|
|
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetID() int32 { return q.DocumentID }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetUsername() string { return q.Username }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetEnquiryID() int32 { return q.EnquiryID }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetEnquiryRef() string { return q.EnquiryRef }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetDateIssued() time.Time { return q.DateIssued }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetValidUntil() time.Time { return q.ValidUntil }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetReminderType() int32 { return q.LatestReminderType }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetReminderSent() time.Time {
|
|
return q.LatestReminderSentTime
|
|
}
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetCustomerName() string { return q.CustomerName }
|
|
func (q ExpiringSoonQuoteOnDayRowWrapper) GetCustomerEmail() string { return q.CustomerEmail }
|
|
|
|
type RecentlyExpiredQuoteOnDayRowWrapper struct {
|
|
db.GetRecentlyExpiredQuotesOnDayRow
|
|
}
|
|
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetID() int32 { return q.DocumentID }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetUsername() string { return q.Username }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetEnquiryID() int32 { return q.EnquiryID }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetEnquiryRef() string { return q.EnquiryRef }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetDateIssued() time.Time { return q.DateIssued }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetValidUntil() time.Time { return q.ValidUntil }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetReminderType() int32 { return q.LatestReminderType }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetReminderSent() time.Time {
|
|
return q.LatestReminderSentTime
|
|
}
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetCustomerName() string { return q.CustomerName }
|
|
func (q RecentlyExpiredQuoteOnDayRowWrapper) GetCustomerEmail() string { return q.CustomerEmail }
|
|
|
|
// Helper: formats a quote row for output (generic)
|
|
func formatQuoteRow(q QuoteRow) map[string]interface{} {
|
|
relative, daysUntil, daysSince := calcExpiryInfo(q.GetValidUntil())
|
|
return map[string]interface{}{
|
|
"ID": q.GetID(),
|
|
"Username": strings.Title(q.GetUsername()),
|
|
"EnquiryID": q.GetEnquiryID(),
|
|
"EnquiryRef": q.GetEnquiryRef(),
|
|
"CustomerName": strings.TrimSpace(q.GetCustomerName()),
|
|
"CustomerEmail": q.GetCustomerEmail(),
|
|
"DateIssued": formatDate(q.GetDateIssued()),
|
|
"ValidUntil": formatDate(q.GetValidUntil()),
|
|
"ValidUntilRelative": relative,
|
|
"DaysUntilExpiry": daysUntil,
|
|
"DaysSinceExpiry": daysSince,
|
|
"LatestReminderSent": formatDate(q.GetReminderSent()),
|
|
"LatestReminderType": reminderTypeString(int(q.GetReminderType())),
|
|
}
|
|
}
|
|
|
|
type QuoteQueries interface {
|
|
GetQuoteRemindersByType(ctx context.Context, params db.GetQuoteRemindersByTypeParams) ([]db.QuoteReminder, error)
|
|
InsertQuoteReminder(ctx context.Context, params db.InsertQuoteReminderParams) (sql.Result, error)
|
|
GetExpiringSoonQuotes(ctx context.Context, dateADD interface{}) ([]db.GetExpiringSoonQuotesRow, error)
|
|
GetRecentlyExpiredQuotes(ctx context.Context, dateSUB interface{}) ([]db.GetRecentlyExpiredQuotesRow, error)
|
|
GetExpiringSoonQuotesOnDay(ctx context.Context, dateADD interface{}) ([]db.GetExpiringSoonQuotesOnDayRow, error)
|
|
GetRecentlyExpiredQuotesOnDay(ctx context.Context, dateSUB interface{}) ([]db.GetRecentlyExpiredQuotesOnDayRow, error)
|
|
}
|
|
|
|
type EmailSender interface {
|
|
SendTemplateEmail(to string, subject string, templateName string, data interface{}, ccs []string, bccs []string) error
|
|
}
|
|
|
|
type QuotesHandler struct {
|
|
queries QuoteQueries
|
|
tmpl *templates.TemplateManager
|
|
emailService EmailSender
|
|
}
|
|
|
|
func NewQuotesHandler(queries QuoteQueries, tmpl *templates.TemplateManager, emailService EmailSender) *QuotesHandler {
|
|
return &QuotesHandler{
|
|
queries: queries,
|
|
tmpl: tmpl,
|
|
emailService: emailService,
|
|
}
|
|
}
|
|
|
|
func (h *QuotesHandler) QuotesOutstandingView(w http.ResponseWriter, r *http.Request) {
|
|
// Days to look ahead and behind for expiring quotes
|
|
days := 7
|
|
|
|
// Show all quotes that are expiring in the next 7 days
|
|
expiringSoonQuotes, err := h.GetOutstandingQuotes(r, days)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Show all quotes that have expired in the last 60 days
|
|
recentlyExpiredQuotes, err := h.GetOutstandingQuotes(r, -60)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
data := map[string]interface{}{
|
|
"RecentlyExpiredQuotes": recentlyExpiredQuotes,
|
|
"ExpiringSoonQuotes": expiringSoonQuotes,
|
|
"User": getUsername(r),
|
|
}
|
|
if err := h.tmpl.Render(w, "quotes/index.html", data); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
// GetOutstandingQuotes returns outstanding quotes based on daysUntilExpiry.
|
|
func (h *QuotesHandler) GetOutstandingQuotes(r *http.Request, daysUntilExpiry int) ([]map[string]interface{}, error) {
|
|
var rows []map[string]interface{}
|
|
ctx := r.Context()
|
|
// If daysUntilExpiry is positive, get quotes expiring soon; if negative, get recently expired quotes
|
|
if daysUntilExpiry >= 0 {
|
|
quotes, err := h.queries.GetExpiringSoonQuotes(ctx, daysUntilExpiry)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, q := range quotes {
|
|
rows = append(rows, formatQuoteRow(ExpiringSoonQuoteRowWrapper{q}))
|
|
}
|
|
} else {
|
|
days := -daysUntilExpiry
|
|
quotes, err := h.queries.GetRecentlyExpiredQuotes(ctx, days)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, q := range quotes {
|
|
rows = append(rows, formatQuoteRow(RecentlyExpiredQuoteRowWrapper{q}))
|
|
}
|
|
}
|
|
return rows, nil
|
|
}
|
|
|
|
// GetOutstandingQuotesOnDay returns quotes expiring exactly N days from today (if day >= 0), or exactly N days ago (if day < 0).
|
|
func (h *QuotesHandler) GetOutstandingQuotesOnDay(r *http.Request, day int) ([]map[string]interface{}, error) {
|
|
var rows []map[string]interface{}
|
|
ctx := r.Context()
|
|
// If day is positive, get quotes expiring on that day; if negative, get recently expired quotes on that day in the past
|
|
if day >= 0 {
|
|
quotes, err := h.queries.GetExpiringSoonQuotesOnDay(ctx, day)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, q := range quotes {
|
|
rows = append(rows, formatQuoteRow(ExpiringSoonQuoteOnDayRowWrapper{q}))
|
|
}
|
|
} else {
|
|
days := -day
|
|
quotes, err := h.queries.GetRecentlyExpiredQuotesOnDay(ctx, days)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, q := range quotes {
|
|
rows = append(rows, formatQuoteRow(RecentlyExpiredQuoteOnDayRowWrapper{q}))
|
|
}
|
|
}
|
|
return rows, nil
|
|
}
|
|
|
|
type QuoteReminderType int
|
|
|
|
const (
|
|
FirstReminder QuoteReminderType = 1
|
|
SecondReminder QuoteReminderType = 2
|
|
ThirdReminder QuoteReminderType = 3
|
|
)
|
|
|
|
func (t QuoteReminderType) String() string {
|
|
switch t {
|
|
case FirstReminder:
|
|
return "FirstReminder"
|
|
case SecondReminder:
|
|
return "SecondReminder"
|
|
case ThirdReminder:
|
|
return "ThirdReminder"
|
|
default:
|
|
return "UnknownReminder"
|
|
}
|
|
}
|
|
|
|
type quoteReminderJob struct {
|
|
DayOffset int
|
|
ReminderType QuoteReminderType
|
|
Subject string
|
|
Template string
|
|
}
|
|
|
|
// DailyQuoteExpirationCheck checks quotes for reminders and expiry notices (callable as a cron job from main)
|
|
func (h *QuotesHandler) DailyQuoteExpirationCheck() {
|
|
fmt.Println("Running DailyQuoteExpirationCheck...")
|
|
|
|
reminderJobs := []quoteReminderJob{
|
|
{7, FirstReminder, "Reminder: Quote %s Expires Soon", "first_reminder.html"},
|
|
{-7, SecondReminder, "Follow-Up: Quote %s Expired", "second_reminder.html"},
|
|
{-60, ThirdReminder, "Final Reminder: Quote %s Closed", "final_reminder.html"},
|
|
}
|
|
|
|
for _, job := range reminderJobs {
|
|
quotes, err := h.GetOutstandingQuotesOnDay((&http.Request{}), job.DayOffset)
|
|
if err != nil {
|
|
fmt.Printf("Error getting quotes for day offset %d: %v\n", job.DayOffset, err)
|
|
continue
|
|
}
|
|
|
|
if len(quotes) == 0 {
|
|
continue
|
|
}
|
|
for _, q := range quotes {
|
|
// Format dates as DD/MM/YYYY
|
|
var submissionDate, expiryDate string
|
|
if dateIssued, ok := q["DateIssued"].(string); ok && dateIssued != "" {
|
|
t, err := time.Parse(time.RFC3339, dateIssued)
|
|
if err == nil {
|
|
submissionDate = t.Format("02/01/2006")
|
|
} else {
|
|
submissionDate = dateIssued
|
|
}
|
|
}
|
|
if validUntil, ok := q["ValidUntil"].(string); ok && validUntil != "" {
|
|
t, err := time.Parse(time.RFC3339, validUntil)
|
|
if err == nil {
|
|
expiryDate = t.Format("02/01/2006")
|
|
} else {
|
|
expiryDate = validUntil
|
|
}
|
|
}
|
|
templateData := map[string]interface{}{
|
|
"CustomerName": q["CustomerName"],
|
|
"SubmissionDate": submissionDate,
|
|
"ExpiryDate": expiryDate,
|
|
"QuoteRef": q["EnquiryRef"],
|
|
}
|
|
err := h.SendQuoteReminderEmail(
|
|
context.Background(),
|
|
q["ID"].(int32),
|
|
job.ReminderType,
|
|
q["CustomerEmail"].(string),
|
|
fmt.Sprintf(job.Subject, q["EnquiryRef"]),
|
|
job.Template,
|
|
templateData,
|
|
nil,
|
|
)
|
|
if err != nil {
|
|
fmt.Printf("Error sending %s for quote %v: %v\n", job.ReminderType.String(), q["ID"], err)
|
|
} else {
|
|
fmt.Printf("%s sent and recorded for quote %v\n", job.ReminderType.String(), q["ID"])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// SendQuoteReminderEmail checks if a reminder of the given type has already been sent for the quote, sends the email if not, and records it.
|
|
func (h *QuotesHandler) SendQuoteReminderEmail(ctx context.Context, quoteID int32, reminderType QuoteReminderType, recipient string, subject string, templateName string, templateData map[string]interface{}, username *string) error {
|
|
// Safeguard: check for valid recipient
|
|
if strings.TrimSpace(recipient) == "" {
|
|
return fmt.Errorf("recipient email is required")
|
|
}
|
|
// Safeguard: check for valid template data
|
|
if templateData == nil {
|
|
return fmt.Errorf("template data is required")
|
|
}
|
|
// Safeguard: check for valid reminder type
|
|
if reminderType != FirstReminder && reminderType != SecondReminder && reminderType != ThirdReminder {
|
|
return fmt.Errorf("invalid reminder type: %v", reminderType)
|
|
}
|
|
|
|
// Check if reminder already sent
|
|
reminders, err := h.queries.GetQuoteRemindersByType(ctx, db.GetQuoteRemindersByTypeParams{
|
|
QuoteID: quoteID,
|
|
ReminderType: int32(reminderType),
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to check existing reminders: %w", err)
|
|
}
|
|
|
|
// Exit if the email has already been sent
|
|
if len(reminders) > 0 {
|
|
return nil
|
|
}
|
|
|
|
// Send the email
|
|
err = h.emailService.SendTemplateEmail(
|
|
recipient,
|
|
subject,
|
|
templateName,
|
|
templateData,
|
|
nil, nil,
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to send email: %w", err)
|
|
}
|
|
|
|
// Record the reminder
|
|
var user sql.NullString
|
|
if username != nil {
|
|
user = sql.NullString{String: *username, Valid: true}
|
|
} else {
|
|
user = sql.NullString{Valid: false}
|
|
}
|
|
_, err = h.queries.InsertQuoteReminder(ctx, db.InsertQuoteReminderParams{
|
|
QuoteID: quoteID,
|
|
ReminderType: int32(reminderType),
|
|
DateSent: time.Now().UTC(),
|
|
Username: user,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to record reminder: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Helper: get reminder type as string
|
|
func reminderTypeString(reminderType int) string {
|
|
switch reminderType {
|
|
case 0:
|
|
return "No Reminder"
|
|
case 1:
|
|
return "First Reminder"
|
|
case 2:
|
|
return "Second Reminder"
|
|
case 3:
|
|
return "Final Reminder"
|
|
default:
|
|
return ""
|
|
}
|
|
}
|