370 lines
13 KiB
Go
370 lines
13 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/email"
|
||
"code.springupsoftware.com/cmc/cmc-sales/internal/cmc/templates"
|
||
)
|
||
|
||
// Helper: returns date string or empty if zero
|
||
func formatDate(t time.Time, layout string) string {
|
||
if t.IsZero() || t.Year() == 1970 {
|
||
return ""
|
||
}
|
||
return t.Format(layout)
|
||
}
|
||
|
||
// 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
|
||
}
|
||
|
||
// 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 }
|
||
|
||
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 }
|
||
|
||
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
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
// 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(),
|
||
"DateIssued": formatDate(q.GetDateIssued(), "2006-01-02"),
|
||
"ValidUntil": formatDate(q.GetValidUntil(), "2006-01-02"),
|
||
"ValidUntilRelative": relative,
|
||
"DaysUntilExpiry": daysUntil,
|
||
"DaysSinceExpiry": daysSince,
|
||
"LatestReminderSent": formatDate(q.GetReminderSent(), "2006-01-02 15:04:05"),
|
||
"LatestReminderType": reminderTypeString(int(q.GetReminderType())),
|
||
}
|
||
}
|
||
|
||
type QuotesHandler struct {
|
||
queries *db.Queries
|
||
tmpl *templates.TemplateManager
|
||
emailService *email.EmailService // Add email service
|
||
}
|
||
|
||
func NewQuotesHandler(queries *db.Queries, tmpl *templates.TemplateManager, emailService *email.EmailService) *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,
|
||
}
|
||
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, "Quote Validity Notice – Quote Ref #: ", "quotes/first_reminder.html"},
|
||
{-7, SecondReminder, "Quote Expired – 2nd Notice for Quote Ref #: ", "quotes/second_reminder.html"},
|
||
{-60, ThirdReminder, "Final Reminder – Quote Ref #: ", "quotes/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
|
||
}
|
||
for _, q := range quotes {
|
||
templateData := map[string]interface{}{
|
||
"CustomerName": "Test Customer",
|
||
"SubmissionDate": q["DateIssued"],
|
||
"QuoteRef": q["EnquiryRef"],
|
||
"SenderName": "Test Sender",
|
||
"SenderPosition": "Sales Manager",
|
||
"CompanyName": "Test Company",
|
||
}
|
||
err := h.SendQuoteReminderEmail(
|
||
context.Background(),
|
||
q["ID"].(int32),
|
||
job.ReminderType,
|
||
"test@example.com",
|
||
job.Subject+fmt.Sprint(q["ID"]),
|
||
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 {
|
||
// 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)
|
||
}
|
||
if len(reminders) > 0 {
|
||
return fmt.Errorf("reminder of type %s already sent for quote %d", reminderType.String(), quoteID)
|
||
}
|
||
|
||
// 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(),
|
||
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 ""
|
||
}
|
||
}
|