popertotsandSisyphus
e7fd9c89eb
Normalize error message casing to lowercase for consistency across auth, bookings, services, customer relationship, and profile handlers. Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent) Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
1012 lines
30 KiB
Go
1012 lines
30 KiB
Go
package user
|
|
|
|
import (
|
|
"bytes"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/kovidgoyal/imaging"
|
|
"golang.org/x/crypto/bcrypt"
|
|
"golang.org/x/text/cases"
|
|
"golang.org/x/text/language"
|
|
|
|
"crussell/db"
|
|
"crussell/handlers/auth"
|
|
"crussell/internal/images"
|
|
"crussell/internal/s3"
|
|
"crussell/internal/validators"
|
|
"crussell/mw"
|
|
)
|
|
|
|
func getEnv(key, fallback string) string {
|
|
if val := os.Getenv(key); val != "" {
|
|
return val
|
|
}
|
|
return fallback
|
|
}
|
|
|
|
var titleCaser = cases.Title(language.English)
|
|
|
|
type UserProfile struct {
|
|
ID string `json:"id"`
|
|
Email string `json:"email"`
|
|
FirstName string `json:"firstName"`
|
|
LastName string `json:"lastName"`
|
|
Phone *string `json:"phone,omitempty"`
|
|
DateOfBirth *string `json:"dateOfBirth,omitempty"`
|
|
Role string `json:"role"`
|
|
LoyaltyStamps int `json:"loyaltyStamps"`
|
|
ReferralCode string `json:"referralCode"`
|
|
ReferralCodeUses int `json:"referralCodeUses"`
|
|
ProfilePicURL *string `json:"profilePicUrl,omitempty"`
|
|
}
|
|
|
|
type UpdateProfileRequest struct {
|
|
FirstName string `json:"firstName" validate:"required,min=1,max=50"`
|
|
LastName string `json:"lastName" validate:"required,min=1,max=50"`
|
|
Phone string `json:"phone" validate:"required"`
|
|
}
|
|
|
|
type AdminUserDetail struct {
|
|
ID string `json:"id"`
|
|
Email *string `json:"email,omitempty"`
|
|
FirstName string `json:"firstName"`
|
|
LastName string `json:"lastName"`
|
|
FullName string `json:"fullName"`
|
|
Phone *string `json:"phone,omitempty"`
|
|
DateOfBirth *string `json:"dateOfBirth,omitempty"`
|
|
ProfilePicURL *string `json:"profilePicUrl,omitempty"`
|
|
AccountRole string `json:"accountRole"`
|
|
AccountType string `json:"accountType"`
|
|
LoyaltyStamps int `json:"loyaltyStamps"`
|
|
ReferralCode string `json:"referralCode"`
|
|
ReferralCodeUses int `json:"referralCodeUses"`
|
|
LastLoginAt *string `json:"lastLoginAt,omitempty"`
|
|
CreatedAt string `json:"createdAt"`
|
|
UpdatedAt string `json:"updatedAt"`
|
|
Notes *string `json:"notes,omitempty" validate:"omitempty,max=1000000"`
|
|
|
|
// GDPR consent fields
|
|
PrivacyPolicyConsent bool `json:"privacyPolicyConsent"`
|
|
PolicyConsentUpdatedAt *string `json:"policyConsentUpdatedAt,omitempty"`
|
|
DataRetentionConsent bool `json:"dataRetentionConsent"`
|
|
DataConsentUpdatedAt *string `json:"dataConsentUpdatedAt,omitempty"`
|
|
|
|
// Social logins
|
|
SocialLogins []SocialLogin `json:"socialLogins,omitempty"`
|
|
}
|
|
|
|
type SocialLogin struct {
|
|
Provider string `json:"provider"`
|
|
CreatedAt string `json:"createdAt"`
|
|
}
|
|
|
|
type UserListItem struct {
|
|
ID string `json:"id"`
|
|
FullName string `json:"fullName"`
|
|
Email *string `json:"email,omitempty"`
|
|
Phone *string `json:"phone,omitempty"`
|
|
AccountRole string `json:"account_role"`
|
|
}
|
|
|
|
type UserListResponse struct {
|
|
Users []UserListItem `json:"users"`
|
|
Total int `json:"total"`
|
|
Page int `json:"page"`
|
|
PerPage int `json:"perPage"`
|
|
TotalPages int `json:"totalPages"`
|
|
}
|
|
|
|
// GET /api/user/profile
|
|
func GetProfileHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := mw.GetUserID(r.Context())
|
|
if !ok {
|
|
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
var user UserProfile
|
|
err := db.DB.QueryRow(r.Context(), `
|
|
SELECT
|
|
id, email, n_first_name, n_last_name, phone,
|
|
date_of_birth::text, account_role, loyalty_stamps,
|
|
referral_code, profile_pic_url,
|
|
(SELECT COUNT(*) FROM user_referrals WHERE referrer_id = users.id AND claimed_booking_id IS NOT NULL) AS referral_code_uses
|
|
FROM users
|
|
WHERE id = $1
|
|
`, userID).Scan(
|
|
&user.ID, &user.Email, &user.FirstName, &user.LastName,
|
|
&user.Phone, &user.DateOfBirth, &user.Role,
|
|
&user.LoyaltyStamps, &user.ReferralCode, &user.ProfilePicURL, &user.ReferralCodeUses,
|
|
)
|
|
|
|
if err != nil {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(user)
|
|
}
|
|
|
|
// PUT /api/user/profile
|
|
// updateCardDAV updates an existing contact in SabreDAV using user ID
|
|
func updateCardDAV(userID, firstName, lastName, email, phone, dob, profilePicURL string) error {
|
|
filename := fmt.Sprintf("%s.vcf", userID)
|
|
url := fmt.Sprintf("http://nginx/dav/addressbooks/principals/default/default/%s", filename)
|
|
|
|
timestamp := time.Now().UTC().Format("20060102T150405Z")
|
|
uid := fmt.Sprintf("%s@example.com", userID)
|
|
|
|
var photoLine string
|
|
if profilePicURL != "" {
|
|
photoLine = fmt.Sprintf("PHOTO;VALUE=URI:%s", profilePicURL)
|
|
}
|
|
|
|
vcard := fmt.Sprintf(`BEGIN:VCARD
|
|
VERSION:3.0
|
|
UID:%s
|
|
FN:%s %s
|
|
N:%s;%s;;;
|
|
EMAIL;TYPE=INTERNET:%s
|
|
TEL;TYPE=CELL:%s
|
|
BDAY:%s
|
|
%s
|
|
REV:%s
|
|
END:VCARD`, uid, firstName, lastName, lastName, firstName, email, phone, dob, photoLine, timestamp)
|
|
|
|
// PUT updated vCard
|
|
req, err := http.NewRequest("PUT", url, bytes.NewBufferString(vcard))
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
req.Header.Set("Content-Type", "text/vcard; charset=utf-8")
|
|
davPassword := os.Getenv("DAV_ADMIN_PASSWORD")
|
|
if davPassword == "" {
|
|
davPassword = "admin"
|
|
}
|
|
req.SetBasicAuth("admin", davPassword)
|
|
|
|
client := &http.Client{Timeout: 10 * time.Second}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to update CardDAV: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
|
return fmt.Errorf("CardDAV returned status: %d", resp.StatusCode)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// PUT /api/user/profile
|
|
func UpdateProfileHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID, _ := mw.GetUserID(r.Context())
|
|
|
|
var req UpdateProfileRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validators.Validate.Struct(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Normalize input
|
|
req.FirstName = strings.TrimSpace(req.FirstName)
|
|
req.LastName = strings.TrimSpace(req.LastName)
|
|
req.Phone = strings.TrimSpace(req.Phone)
|
|
|
|
// Required fields
|
|
if req.FirstName == "" || req.LastName == "" || req.Phone == "" {
|
|
http.Error(w, "first name, last name and phone are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Validate names (unicode letters, spaces, hyphen, apostrophe, dot)
|
|
nameRegex := regexp.MustCompile(`^[\p{L}\p{M}\s\-'\.]+$`)
|
|
|
|
if !nameRegex.MatchString(req.FirstName) || !nameRegex.MatchString(req.LastName) {
|
|
http.Error(w, "invalid characters in name", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Validate lengths
|
|
if len(req.FirstName) < 1 || len(req.FirstName) > 50 {
|
|
http.Error(w, "first name must be 1-50 characters", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if len(req.LastName) < 1 || len(req.LastName) > 50 {
|
|
http.Error(w, "last name must be 1-50 characters", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Normalize phone (strip spaces, hyphens, brackets)
|
|
req.Phone = strings.Map(func(r rune) rune {
|
|
if (r >= '0' && r <= '9') || r == '+' {
|
|
return r
|
|
}
|
|
return -1
|
|
}, req.Phone)
|
|
|
|
// Validate UK phone number
|
|
phone, err := auth.ValidateUKPhoneNumber(req.Phone)
|
|
if err != nil {
|
|
http.Error(w, "invalid phone number format", http.StatusBadRequest)
|
|
return
|
|
}
|
|
req.Phone = strings.TrimSpace(phone)
|
|
|
|
// Title case names
|
|
req.FirstName = titleCaser.String(strings.ToLower(req.FirstName))
|
|
req.LastName = titleCaser.String(strings.ToLower(req.LastName))
|
|
|
|
// Fetch user's email and DOB for CardDAV update
|
|
var email string
|
|
var dob sql.NullTime
|
|
var profilePicURL sql.NullString
|
|
err = db.DB.QueryRow(r.Context(), `
|
|
SELECT email, date_of_birth, profile_pic_url FROM users WHERE id = $1
|
|
`, userID).Scan(&email, &dob, &profilePicURL)
|
|
|
|
if err != nil {
|
|
log.Printf("Failed to fetch user %s: %v", userID, err)
|
|
http.Error(w, "failed to fetch user data", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Update DB
|
|
_, err = db.DB.Exec(r.Context(), `
|
|
UPDATE users
|
|
SET n_first_name = $1, n_last_name = $2, phone = $3, updated_at = NOW()
|
|
WHERE id = $4
|
|
`, req.FirstName, req.LastName, req.Phone, userID)
|
|
|
|
if err != nil {
|
|
http.Error(w, "update failed", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Update CardDAV (non-blocking)
|
|
go func() {
|
|
var dobStr string
|
|
if dob.Valid {
|
|
dobStr = dob.Time.Format("2006-01-02")
|
|
}
|
|
if err := updateCardDAV(userID, req.FirstName, req.LastName, email, req.Phone, dobStr, profilePicURL.String); err != nil {
|
|
fmt.Printf("Warning: Failed to update CardDAV contact for user %s: %v\n", userID, err)
|
|
}
|
|
}()
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// GET /api/admin/users/{id}
|
|
func GetAdminUserHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID := chi.URLParam(r, "id")
|
|
if userID == "" || !validators.IsValidID(userID) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
// Fetch user details
|
|
var user AdminUserDetail
|
|
err := db.DB.QueryRow(r.Context(), `
|
|
SELECT
|
|
id, email, n_first_name, n_last_name, fn, phone,
|
|
date_of_birth::text, profile_pic_url,
|
|
account_role, account_type, loyalty_stamps, referral_code,
|
|
last_login_at::text, created_at::text, updated_at::text, notes,
|
|
privacy_policy_and_terms_consent,
|
|
policy_consent_updated_at::text,
|
|
data_retention_consent,
|
|
data_consent_updated_at::text
|
|
FROM users
|
|
WHERE id = $1
|
|
`, userID).Scan(
|
|
&user.ID, &user.Email, &user.FirstName, &user.LastName, &user.FullName,
|
|
&user.Phone, &user.DateOfBirth, &user.ProfilePicURL,
|
|
&user.AccountRole, &user.AccountType, &user.LoyaltyStamps, &user.ReferralCode,
|
|
&user.LastLoginAt, &user.CreatedAt, &user.UpdatedAt, &user.Notes,
|
|
&user.PrivacyPolicyConsent, &user.PolicyConsentUpdatedAt,
|
|
&user.DataRetentionConsent, &user.DataConsentUpdatedAt,
|
|
)
|
|
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
log.Printf("Failed to fetch user %s: %v", userID, err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Fetch referral code uses count
|
|
err = db.DB.QueryRow(r.Context(), `
|
|
SELECT COUNT(*)
|
|
FROM user_referrals
|
|
WHERE referrer_id = $1 AND claimed_booking_id IS NOT NULL
|
|
`, userID).Scan(&user.ReferralCodeUses)
|
|
if err != nil {
|
|
log.Printf("Failed to fetch referral code uses for user %s: %v", userID, err)
|
|
user.ReferralCodeUses = 0
|
|
}
|
|
|
|
// Fetch social logins
|
|
socialRows, err := db.DB.Query(r.Context(), `
|
|
SELECT provider, created_at::text
|
|
FROM user_social_logins
|
|
WHERE user_id = $1
|
|
ORDER BY created_at ASC
|
|
`, userID)
|
|
if err != nil {
|
|
log.Printf("Failed to fetch social logins for user %s: %v", userID, err)
|
|
} else {
|
|
defer socialRows.Close()
|
|
|
|
var socialLogins []SocialLogin
|
|
for socialRows.Next() {
|
|
var sl SocialLogin
|
|
if err := socialRows.Scan(&sl.Provider, &sl.CreatedAt); err != nil {
|
|
log.Printf("Failed to scan social login for user %s: %v", userID, err)
|
|
continue
|
|
}
|
|
socialLogins = append(socialLogins, sl)
|
|
}
|
|
|
|
if len(socialLogins) > 0 {
|
|
user.SocialLogins = socialLogins
|
|
}
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusOK)
|
|
if err := json.NewEncoder(w).Encode(user); err != nil {
|
|
log.Printf("Failed to encode user response: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
// GET /api/admin/users
|
|
func ListAdminUsersHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Parse query parameters
|
|
query := r.URL.Query()
|
|
searchTerm := query.Get("q")
|
|
|
|
// Pagination parameters
|
|
page := 1
|
|
perPage := 10
|
|
|
|
if pageStr := query.Get("page"); pageStr != "" {
|
|
if p, err := strconv.Atoi(pageStr); err == nil && p > 0 {
|
|
page = p
|
|
}
|
|
}
|
|
|
|
if perPageStr := query.Get("per_page"); perPageStr != "" {
|
|
if pp, err := strconv.Atoi(perPageStr); err == nil && pp > 0 && pp <= 100 {
|
|
perPage = pp
|
|
}
|
|
}
|
|
|
|
offset := (page - 1) * perPage
|
|
|
|
// Build query based on whether search is provided
|
|
var countQuery string
|
|
var listQuery string
|
|
var countArgs []interface{}
|
|
var listArgs []interface{}
|
|
|
|
if searchTerm != "" {
|
|
// Search in name, email, or phone
|
|
searchPattern := "%" + searchTerm + "%"
|
|
|
|
countQuery = `
|
|
SELECT COUNT(*)
|
|
FROM users
|
|
WHERE fn ILIKE $1
|
|
OR email ILIKE $1
|
|
OR phone ILIKE $1
|
|
`
|
|
countArgs = []interface{}{searchPattern}
|
|
|
|
listQuery = `
|
|
SELECT u.id, u.fn, u.email, u.phone, u.account_role
|
|
FROM users u
|
|
LEFT JOIN bookings b ON u.id = b.user_id
|
|
WHERE u.fn ILIKE $1
|
|
OR u.email ILIKE $1
|
|
OR u.phone ILIKE $1
|
|
GROUP BY u.id, u.fn, u.email, u.phone, u.account_role, u.created_at
|
|
ORDER BY COUNT(b.id) DESC, u.created_at DESC
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
listArgs = []interface{}{searchPattern, perPage, offset}
|
|
} else {
|
|
// No search - get all users, sorted by booking count
|
|
countQuery = `SELECT COUNT(*) FROM users`
|
|
countArgs = []interface{}{}
|
|
|
|
listQuery = `
|
|
SELECT u.id, u.fn, u.email, u.phone, u.account_role
|
|
FROM users u
|
|
LEFT JOIN bookings b ON u.id = b.user_id
|
|
GROUP BY u.id, u.fn, u.email, u.phone, u.account_role, u.created_at
|
|
ORDER BY COUNT(b.id) DESC, u.created_at DESC
|
|
LIMIT $1 OFFSET $2
|
|
`
|
|
listArgs = []interface{}{perPage, offset}
|
|
}
|
|
|
|
// Get total count
|
|
var total int
|
|
err := db.DB.QueryRow(r.Context(), countQuery, countArgs...).Scan(&total)
|
|
if err != nil {
|
|
log.Printf("Failed to count users: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Get users list
|
|
rows, err := db.DB.Query(r.Context(), listQuery, listArgs...)
|
|
if err != nil {
|
|
log.Printf("Failed to fetch users: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
var users []UserListItem
|
|
for rows.Next() {
|
|
var user UserListItem
|
|
err := rows.Scan(
|
|
&user.ID,
|
|
&user.FullName,
|
|
&user.Email,
|
|
&user.Phone,
|
|
&user.AccountRole,
|
|
)
|
|
if err != nil {
|
|
log.Printf("Failed to scan user row: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
users = append(users, user)
|
|
}
|
|
|
|
// Handle empty results
|
|
if users == nil {
|
|
users = []UserListItem{}
|
|
}
|
|
|
|
// Calculate total pages
|
|
totalPages := (total + perPage - 1) / perPage
|
|
if totalPages == 0 {
|
|
totalPages = 1
|
|
}
|
|
|
|
response := UserListResponse{
|
|
Users: users,
|
|
Total: total,
|
|
Page: page,
|
|
PerPage: perPage,
|
|
TotalPages: totalPages,
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusOK)
|
|
if err := json.NewEncoder(w).Encode(response); err != nil {
|
|
log.Printf("Failed to encode users response: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
type ChangePasswordRequest struct {
|
|
CurrentPassword string `json:"current_password" validate:"required,max=72"`
|
|
NewPassword string `json:"new_password" validate:"required,min=8,max=72"`
|
|
}
|
|
|
|
func ChangePasswordHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := mw.GetUserID(r.Context())
|
|
if !ok {
|
|
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
var req ChangePasswordRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validators.Validate.Struct(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.CurrentPassword == "" || req.NewPassword == "" {
|
|
http.Error(w, "current password and new password are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if len(req.NewPassword) < 8 {
|
|
http.Error(w, "password must be at least 8 characters", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if len(req.NewPassword) > 72 {
|
|
http.Error(w, "password must be less than 72 characters", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.NewPassword == req.CurrentPassword {
|
|
http.Error(w, "new password must be different from current password", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var passwordHash string
|
|
err := db.DB.QueryRow(r.Context(), `SELECT password_hash FROM users WHERE id = $1`, userID).Scan(&passwordHash)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
log.Printf("Failed to fetch password hash for user %s: %v", userID, err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if err := bcrypt.CompareHashAndPassword([]byte(passwordHash), []byte(req.CurrentPassword)); err != nil {
|
|
http.Error(w, "current password is incorrect", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
newHash, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
log.Printf("Failed to hash new password for user %s: %v", userID, err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
_, err = db.DB.Exec(r.Context(), `UPDATE users SET password_hash = $1, updated_at = NOW() WHERE id = $2`, string(newHash), userID)
|
|
if err != nil {
|
|
log.Printf("Failed to update password for user %s: %v", userID, err)
|
|
http.Error(w, "failed to update password", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// ServiceForPatchTest represents a service that requires a patch test
|
|
type ServiceForPatchTest struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
PatchTestID string `json:"patchTestId"`
|
|
NoticeDurationHours int `json:"noticeDurationHours"`
|
|
ExpiryMonths int `json:"expiryMonths"`
|
|
}
|
|
|
|
// GET /api/admin/users/{id}/patch-tests/eligible
|
|
// Returns services that require a patch test which the user hasn't completed yet
|
|
func GetEligiblePatchTestServicesHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID := chi.URLParam(r, "id")
|
|
if userID == "" || !validators.IsValidID(userID) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
// Get services that require a patch test but user hasn't completed
|
|
// This queries patch_tests to find which services require patch tests,
|
|
// then excludes those the user already has valid records for
|
|
rows, err := db.DB.Query(r.Context(), `
|
|
SELECT DISTINCT s.id, s.name, pt.id, pt.notice_duration_hours, pt.expiry_months
|
|
FROM services s
|
|
JOIN patch_tests pt ON s.id = ANY(pt.service_ids)
|
|
WHERE s.is_active = true
|
|
AND pt.id NOT IN (
|
|
SELECT pt_inner.id
|
|
FROM patch_tests pt_inner
|
|
JOIN user_patch_tests upt ON pt_inner.id = upt.patch_test_id
|
|
WHERE upt.user_id = $1
|
|
AND upt.tested_at + (pt_inner.expiry_months || ' months')::interval > NOW()
|
|
)
|
|
ORDER BY s.name ASC
|
|
`, userID)
|
|
if err != nil {
|
|
log.Printf("Failed to fetch eligible patch test services: %v", err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
var services []ServiceForPatchTest
|
|
for rows.Next() {
|
|
var s ServiceForPatchTest
|
|
if err := rows.Scan(&s.ID, &s.Name, &s.PatchTestID, &s.NoticeDurationHours, &s.ExpiryMonths); err != nil {
|
|
log.Printf("Failed to scan service: %v", err)
|
|
continue
|
|
}
|
|
services = append(services, s)
|
|
}
|
|
|
|
if services == nil {
|
|
services = []ServiceForPatchTest{}
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(services)
|
|
}
|
|
|
|
type AddPatchTestRequest struct {
|
|
PatchTestID string `json:"patch_test_id" validate:"required"`
|
|
}
|
|
|
|
// POST /api/admin/users/{id}/patch-tests
|
|
// Records that a user has taken a patch test
|
|
func AddPatchTestHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID := chi.URLParam(r, "id")
|
|
if userID == "" || !validators.IsValidID(userID) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
var req AddPatchTestRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err := validators.Validate.Struct(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if req.PatchTestID == "" {
|
|
http.Error(w, "patch_test_id is required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Verify patch test exists
|
|
var patchTestID string
|
|
err := db.DB.QueryRow(r.Context(), `SELECT id FROM patch_tests WHERE id = $1`, req.PatchTestID).Scan(&patchTestID)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
http.Error(w, "patch test not found", http.StatusBadRequest)
|
|
return
|
|
}
|
|
log.Printf("Failed to verify patch test: %v", err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Insert or update user_patch_tests record
|
|
_, err = db.DB.Exec(r.Context(), `
|
|
INSERT INTO user_patch_tests (user_id, patch_test_id, tested_at)
|
|
VALUES ($1, $2, NOW())
|
|
ON CONFLICT (user_id, patch_test_id) DO UPDATE SET tested_at = NOW()
|
|
`, userID, req.PatchTestID)
|
|
if err != nil {
|
|
log.Printf("Failed to add patch test: %v", err)
|
|
http.Error(w, "failed to add patch test", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusCreated)
|
|
}
|
|
|
|
// UserPatchTest represents a user's patch test record
|
|
type UserPatchTest struct {
|
|
ID string `json:"id"`
|
|
PatchTestID string `json:"patchTestId"`
|
|
PatchTestName string `json:"patchTestName"`
|
|
TestedAt time.Time `json:"testedAt"`
|
|
ValidUntil time.Time `json:"validUntil"`
|
|
}
|
|
|
|
// GET /api/admin/users/{user_id}/patch-tests
|
|
// Returns all patch test records for a user
|
|
func GetUserPatchTestsHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID := chi.URLParam(r, "user_id")
|
|
if userID == "" || !validators.IsValidID(userID) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
rows, err := db.DB.Query(r.Context(), `
|
|
SELECT upt.id, upt.patch_test_id, pt.name, upt.tested_at, upt.tested_at + (pt.expiry_months || ' months')::interval as valid_until
|
|
FROM user_patch_tests upt
|
|
JOIN patch_tests pt ON upt.patch_test_id = pt.id
|
|
WHERE upt.user_id = $1
|
|
ORDER BY upt.tested_at DESC
|
|
`, userID)
|
|
if err != nil {
|
|
log.Printf("Failed to get patch tests: %v", err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
var tests []UserPatchTest
|
|
for rows.Next() {
|
|
var t UserPatchTest
|
|
if err := rows.Scan(&t.ID, &t.PatchTestID, &t.PatchTestName, &t.TestedAt, &t.ValidUntil); err != nil {
|
|
log.Printf("Failed to scan patch test: %v", err)
|
|
continue
|
|
}
|
|
tests = append(tests, t)
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(tests)
|
|
}
|
|
|
|
// DELETE /api/admin/users/{user_id}/patch-tests/{test_id}
|
|
func DeletePatchTestHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID := chi.URLParam(r, "user_id")
|
|
testID := chi.URLParam(r, "test_id")
|
|
if userID == "" || !validators.IsValidID(userID) {
|
|
http.Error(w, "user not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
if testID == "" || !validators.IsValidID(testID) {
|
|
http.Error(w, "Patch test not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
// testID in this context is the user_patch_tests.id (BIGSERIAL)
|
|
result, err := db.DB.Exec(r.Context(), `
|
|
DELETE FROM user_patch_tests WHERE id = $1 AND user_id = $2
|
|
`, testID, userID)
|
|
if err != nil {
|
|
log.Printf("Failed to delete patch test: %v", err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if result.RowsAffected() == 0 {
|
|
http.Error(w, "patch test not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
type UploadProfilePicResponse struct {
|
|
URL string `json:"url"`
|
|
}
|
|
|
|
func UploadProfilePictureHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := r.Context().Value(mw.UserIDKey).(string)
|
|
if !ok || userID == "" {
|
|
http.Error(w, "Authentication required", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
if s3.Client == nil {
|
|
log.Printf("S3 client not initialized")
|
|
http.Error(w, "Storage not configured", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
r.ParseMultipartForm(10 << 20)
|
|
|
|
file, _, err := r.FormFile("file")
|
|
if err != nil {
|
|
log.Printf("Failed to get file: %v", err)
|
|
http.Error(w, "No file provided", http.StatusBadRequest)
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
fileBytes, err := io.ReadAll(file)
|
|
if err != nil {
|
|
log.Printf("Failed to read file: %v", err)
|
|
http.Error(w, "Failed to read file", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if _, err := images.ValidateImageBytes(fileBytes); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
ext := ".jpg"
|
|
key := fmt.Sprintf("profiles/%s%s", userID, ext)
|
|
|
|
fileBytes, err = processProfileImage(fileBytes)
|
|
if err != nil {
|
|
log.Printf("Failed to process image: %v", err)
|
|
http.Error(w, "Failed to process image", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
bucket := getEnv("S3_PROFILE_PICS_BUCKET", "crussell-profile-pics")
|
|
|
|
if err := s3.Client.Upload(r.Context(), bucket, key, bytes.NewReader(fileBytes), "image/jpeg"); err != nil {
|
|
log.Printf("Failed to upload profile picture to S3: %v", err)
|
|
http.Error(w, "Failed to upload image", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
url, err := s3.Client.GetURL(r.Context(), bucket, key)
|
|
if err != nil {
|
|
log.Printf("Failed to get URL: %v", err)
|
|
http.Error(w, "Failed to get image URL", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
_, err = db.DB.Exec(r.Context(), `UPDATE users SET profile_pic_url = $1 WHERE id = $2`, url, userID)
|
|
if err != nil {
|
|
log.Printf("Failed to update user profile pic: %v", err)
|
|
http.Error(w, "Failed to save profile picture", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(UploadProfilePicResponse{URL: url})
|
|
}
|
|
|
|
func processProfileImage(data []byte) ([]byte, error) {
|
|
img, err := imaging.Decode(bytes.NewReader(data), imaging.AutoOrientation(true))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to decode image: %w", err)
|
|
}
|
|
|
|
img = imaging.Thumbnail(img, 350, 350, imaging.Linear)
|
|
|
|
var buf bytes.Buffer
|
|
err = imaging.Encode(&buf, img, imaging.JPEG, imaging.JPEGQuality(85))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to encode image: %w", err)
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
type ContactInfo struct {
|
|
Name string `json:"name"`
|
|
Role string `json:"role"`
|
|
Phone string `json:"phone"`
|
|
Email string `json:"email"`
|
|
ProfilePicURL *string `json:"profilePicUrl,omitempty"`
|
|
}
|
|
|
|
type NotificationPreferencesResponse struct {
|
|
EmailEnabled bool `json:"emailEnabled"`
|
|
SMSEnabled bool `json:"smsEnabled"`
|
|
BrowserPushEnabled bool `json:"browserPushEnabled"`
|
|
}
|
|
|
|
type UpdateNotificationPreferencesRequest struct {
|
|
EmailEnabled *bool `json:"emailEnabled"`
|
|
SMSEnabled *bool `json:"smsEnabled"`
|
|
BrowserPushEnabled *bool `json:"browserPushEnabled"`
|
|
}
|
|
|
|
// GET /api/user/notification-preferences
|
|
func GetNotificationPreferencesHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := mw.GetUserID(r.Context())
|
|
if !ok {
|
|
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
var prefs NotificationPreferencesResponse
|
|
err := db.DB.QueryRow(r.Context(), `
|
|
SELECT email_enabled, sms_enabled, browser_push_enabled
|
|
FROM user_notification_preferences
|
|
WHERE user_id = $1
|
|
`, userID).Scan(&prefs.EmailEnabled, &prefs.SMSEnabled, &prefs.BrowserPushEnabled)
|
|
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
prefs = NotificationPreferencesResponse{
|
|
EmailEnabled: true,
|
|
SMSEnabled: true,
|
|
BrowserPushEnabled: true,
|
|
}
|
|
} else {
|
|
log.Printf("Failed to fetch notification preferences for user %s: %v", userID, err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(prefs)
|
|
}
|
|
|
|
// PUT /api/user/notification-preferences
|
|
func UpdateNotificationPreferencesHandler(w http.ResponseWriter, r *http.Request) {
|
|
userID, ok := mw.GetUserID(r.Context())
|
|
if !ok {
|
|
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
var req UpdateNotificationPreferencesRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var exists bool
|
|
err := db.DB.QueryRow(r.Context(), `
|
|
SELECT EXISTS(SELECT 1 FROM user_notification_preferences WHERE user_id = $1)
|
|
`, userID).Scan(&exists)
|
|
if err != nil {
|
|
log.Printf("Failed to check notification preferences for user %s: %v", userID, err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if exists {
|
|
_, err = db.DB.Exec(r.Context(), `
|
|
UPDATE user_notification_preferences SET
|
|
email_enabled = COALESCE($2, email_enabled),
|
|
sms_enabled = COALESCE($3, sms_enabled),
|
|
browser_push_enabled = COALESCE($4, browser_push_enabled),
|
|
updated_at = NOW()
|
|
WHERE user_id = $1
|
|
`, userID, req.EmailEnabled, req.SMSEnabled, req.BrowserPushEnabled)
|
|
} else {
|
|
_, err = db.DB.Exec(r.Context(), `
|
|
INSERT INTO user_notification_preferences (user_id, email_enabled, sms_enabled, browser_push_enabled, updated_at)
|
|
VALUES ($1, COALESCE($2, true), COALESCE($3, true), COALESCE($4, true), NOW())
|
|
`, userID, req.EmailEnabled, req.SMSEnabled, req.BrowserPushEnabled)
|
|
}
|
|
|
|
if err != nil {
|
|
log.Printf("Failed to update notification preferences for user %s: %v", userID, err)
|
|
http.Error(w, "server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// GET /api/contact
|
|
func GetContactInfoHandler(w http.ResponseWriter, r *http.Request) {
|
|
var contact ContactInfo
|
|
err := db.DB.QueryRow(r.Context(), `
|
|
SELECT
|
|
COALESCE(n_first_name, '') || ' ' || COALESCE(n_last_name, '') as name,
|
|
COALESCE(phone, ''),
|
|
COALESCE(email, ''),
|
|
profile_pic_url
|
|
FROM users
|
|
WHERE account_role = 'admin'
|
|
ORDER BY created_at ASC
|
|
LIMIT 1
|
|
`).Scan(&contact.Name, &contact.Phone, &contact.Email, &contact.ProfilePicURL)
|
|
|
|
if err != nil {
|
|
log.Printf("Failed to get contact info: %v", err)
|
|
http.Error(w, "contact not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
contact.Role = "Owner / Beauty Specialist"
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(contact)
|
|
}
|