tajniak81
535 lines
16 KiB
Go
535 lines
16 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"carcontrol/api/internal/auth"
|
|
"carcontrol/api/internal/models"
|
|
)
|
|
|
|
// deletionCooldown is how long an account-deletion request sits before it can
|
|
// be finalized, giving the user a window to change their mind.
|
|
const deletionCooldown = 3 * 24 * time.Hour
|
|
|
|
// userRecord is the PocketBase-facing shape of a user (mixes PocketBase's own
|
|
// camelCase system fields with our snake_case custom ones).
|
|
type userRecord struct {
|
|
ID string `json:"id"`
|
|
Email string `json:"email"`
|
|
Verified bool `json:"verified"`
|
|
Name string `json:"name"`
|
|
Avatar string `json:"avatar"`
|
|
Bio string `json:"bio"`
|
|
Theme string `json:"theme"`
|
|
Locale string `json:"locale"`
|
|
DateFormat string `json:"date_format"`
|
|
FontSize string `json:"font_size"`
|
|
DeletionRequestedAt string `json:"deletion_requested_at"`
|
|
Role string `json:"role"`
|
|
Created string `json:"created"`
|
|
}
|
|
|
|
func (rec userRecord) toModel() models.User {
|
|
u := models.User{
|
|
ID: rec.ID,
|
|
Email: rec.Email,
|
|
Verified: rec.Verified,
|
|
Name: rec.Name,
|
|
Bio: rec.Bio,
|
|
HasAvatar: rec.Avatar != "",
|
|
Theme: orDefault(rec.Theme, "system"),
|
|
Locale: orDefault(rec.Locale, "en-US"),
|
|
DateFormat: orDefault(rec.DateFormat, "YMD"),
|
|
FontSize: orDefault(rec.FontSize, "medium"),
|
|
Role: orDefault(rec.Role, "user"),
|
|
Created: rec.Created,
|
|
}
|
|
if t := parsePBDate(rec.DeletionRequestedAt); !t.IsZero() {
|
|
u.DeletionRequestedAt = &t
|
|
}
|
|
return u
|
|
}
|
|
|
|
func orDefault(v, fallback string) string {
|
|
if v == "" {
|
|
return fallback
|
|
}
|
|
return v
|
|
}
|
|
|
|
func (s *Server) fetchUser(r *http.Request, id string) (*userRecord, error) {
|
|
var rec userRecord
|
|
if err := s.pb.GetOne(r.Context(), s.usersCollection, id, &rec); err != nil {
|
|
return nil, err
|
|
}
|
|
return &rec, nil
|
|
}
|
|
|
|
func (s *Server) handleGetMe(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
rec, err := s.fetchUser(r, claims.Sub)
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, rec.toModel())
|
|
}
|
|
|
|
type updateMeRequest struct {
|
|
Name *string `json:"name"`
|
|
Bio *string `json:"bio"`
|
|
Theme *string `json:"theme"`
|
|
Locale *string `json:"locale"`
|
|
DateFormat *string `json:"dateFormat"`
|
|
FontSize *string `json:"fontSize"`
|
|
}
|
|
|
|
var validThemes = map[string]bool{"light": true, "dark": true, "system": true}
|
|
var validDateFormats = map[string]bool{"YMD": true, "DMY_NUM": true, "DMY": true, "MDY": true}
|
|
var validFontSizes = map[string]bool{"small": true, "medium": true, "large": true}
|
|
|
|
// handleUpdateMe applies a partial update — only fields present in the request
|
|
// body are touched, so the Account/Profile/Appearance sections of the settings
|
|
// panel can each save independently without clobbering the others.
|
|
func (s *Server) handleUpdateMe(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
var in updateMeRequest
|
|
if err := decodeJSON(r, &in); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
payload := map[string]any{}
|
|
if in.Name != nil {
|
|
payload["name"] = *in.Name
|
|
}
|
|
if in.Bio != nil {
|
|
payload["bio"] = *in.Bio
|
|
}
|
|
if in.Theme != nil {
|
|
if !validThemes[*in.Theme] {
|
|
writeError(w, http.StatusBadRequest, "theme must be light, dark, or system")
|
|
return
|
|
}
|
|
payload["theme"] = *in.Theme
|
|
}
|
|
if in.Locale != nil {
|
|
payload["locale"] = *in.Locale
|
|
}
|
|
if in.DateFormat != nil {
|
|
if !validDateFormats[*in.DateFormat] {
|
|
writeError(w, http.StatusBadRequest, "dateFormat must be YMD, DMY, or MDY")
|
|
return
|
|
}
|
|
payload["date_format"] = *in.DateFormat
|
|
}
|
|
if in.FontSize != nil {
|
|
if !validFontSizes[*in.FontSize] {
|
|
writeError(w, http.StatusBadRequest, "fontSize must be small, medium, or large")
|
|
return
|
|
}
|
|
payload["font_size"] = *in.FontSize
|
|
}
|
|
|
|
var rec userRecord
|
|
if err := s.pb.Update(r.Context(), s.usersCollection, claims.Sub, payload, &rec); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, rec.toModel())
|
|
}
|
|
|
|
type changePasswordRequest struct {
|
|
OldPassword string `json:"oldPassword"`
|
|
NewPassword string `json:"newPassword"`
|
|
}
|
|
|
|
func (s *Server) handleChangePassword(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
var in changePasswordRequest
|
|
if err := decodeJSON(r, &in); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if in.OldPassword == "" {
|
|
writeError(w, http.StatusBadRequest, "current password is required")
|
|
return
|
|
}
|
|
if len(in.NewPassword) < 8 {
|
|
writeError(w, http.StatusBadRequest, "new password must be at least 8 characters")
|
|
return
|
|
}
|
|
|
|
// Verify the current password the same way login does, since the API
|
|
// Server otherwise only ever talks to PocketBase as a superuser.
|
|
if _, err := s.pb.AuthWithPassword(r.Context(), s.usersCollection, claims.Email, in.OldPassword); err != nil {
|
|
writeError(w, http.StatusUnauthorized, "current password is incorrect")
|
|
return
|
|
}
|
|
|
|
payload := map[string]any{"password": in.NewPassword, "passwordConfirm": in.NewPassword}
|
|
if err := s.pb.Update(r.Context(), s.usersCollection, claims.Sub, payload, nil); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
|
}
|
|
|
|
func (s *Server) handleUploadAvatar(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
if err := r.ParseMultipartForm(5 << 20); err != nil {
|
|
writeError(w, http.StatusBadRequest, "avatar upload must be under 5MB")
|
|
return
|
|
}
|
|
file, header, err := r.FormFile("avatar")
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, "missing avatar file")
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
data, err := io.ReadAll(file)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, "could not read upload")
|
|
return
|
|
}
|
|
|
|
if err := s.pb.UpdateMultipart(r.Context(), s.usersCollection, claims.Sub, nil, "avatar", header.Filename, data); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
rec, err := s.fetchUser(r, claims.Sub)
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, rec.toModel())
|
|
}
|
|
|
|
func (s *Server) handleDeleteAvatar(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
if err := s.pb.Update(r.Context(), s.usersCollection, claims.Sub, map[string]any{"avatar": ""}, nil); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (s *Server) handleGetAvatar(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
rec, err := s.fetchUser(r, claims.Sub)
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
if rec.Avatar == "" {
|
|
writeError(w, http.StatusNotFound, "no avatar set")
|
|
return
|
|
}
|
|
data, contentType, err := s.pb.GetFile(r.Context(), s.usersCollection, rec.ID, rec.Avatar)
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", contentType)
|
|
w.Header().Set("Cache-Control", "private, max-age=300")
|
|
w.Write(data)
|
|
}
|
|
|
|
func (s *Server) handleRequestVerification(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
if err := s.pb.RequestVerification(r.Context(), s.usersCollection, claims.Email); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]string{"status": "requested"})
|
|
}
|
|
|
|
// handleExportData bundles the account profile plus every car the user owns
|
|
// (with its service records and parts) into one downloadable JSON file. Cars
|
|
// merely shared with the user are not exported — only cars they own.
|
|
func (s *Server) handleExportData(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
user, err := s.fetchUser(r, claims.Sub)
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
|
|
carsRes, err := s.pb.List(r.Context(), colCars, url.Values{
|
|
"filter": {fmt.Sprintf("owner='%s'", claims.Sub)},
|
|
"sort": {"name"},
|
|
"perPage": {"200"},
|
|
})
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
var carRecs []carRecord
|
|
if err := json.Unmarshal(carsRes.Items, &carRecs); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
type carExport struct {
|
|
models.Car
|
|
ServiceRecords []models.ServiceRecord `json:"serviceRecords"`
|
|
Parts []models.Part `json:"parts"`
|
|
}
|
|
exportCars := make([]carExport, 0, len(carRecs))
|
|
for _, cr := range carRecs {
|
|
car := cr.toModel()
|
|
|
|
svcRes, err := s.pb.List(r.Context(), colServices, url.Values{
|
|
"filter": {fmt.Sprintf("car='%s'", car.ID)}, "sort": {"-date"}, "perPage": {"500"},
|
|
})
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
var svcRecs []serviceRecord
|
|
if err := json.Unmarshal(svcRes.Items, &svcRecs); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
services := make([]models.ServiceRecord, 0, len(svcRecs))
|
|
for _, sr := range svcRecs {
|
|
m := sr.toModel()
|
|
m.ComputeDerived(&car)
|
|
services = append(services, m)
|
|
}
|
|
|
|
partsRes, err := s.pb.List(r.Context(), colParts, url.Values{
|
|
"filter": {fmt.Sprintf("car='%s'", car.ID)}, "perPage": {"500"},
|
|
})
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
var partRecs []partRecord
|
|
if err := json.Unmarshal(partsRes.Items, &partRecs); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
parts := make([]models.Part, 0, len(partRecs))
|
|
for _, p := range partRecs {
|
|
parts = append(parts, p.toModel())
|
|
}
|
|
|
|
exportCars = append(exportCars, carExport{Car: car, ServiceRecords: services, Parts: parts})
|
|
}
|
|
|
|
out := map[string]any{
|
|
"exportedAt": time.Now().UTC().Format(time.RFC3339),
|
|
"account": user.toModel(),
|
|
"cars": exportCars,
|
|
}
|
|
|
|
filename := fmt.Sprintf("car-control-export-%s.json", time.Now().UTC().Format("2006-01-02"))
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Header().Set("Content-Disposition", `attachment; filename="`+filename+`"`)
|
|
_ = json.NewEncoder(w).Encode(out)
|
|
}
|
|
|
|
// importCar mirrors handleExportData's per-car shape. The "id" and the
|
|
// service records'/parts' "car" fields in the uploaded file are ignored —
|
|
// this always creates brand-new records, remapped to the newly created car,
|
|
// rather than trying to match or overwrite anything that already exists.
|
|
type importCar struct {
|
|
models.Car
|
|
ServiceRecords []models.ServiceRecord `json:"serviceRecords"`
|
|
Parts []models.Part `json:"parts"`
|
|
}
|
|
|
|
type importRequest struct {
|
|
Cars []importCar `json:"cars"`
|
|
}
|
|
|
|
type importResult struct {
|
|
CarsImported int `json:"carsImported"`
|
|
ServicesImported int `json:"servicesImported"`
|
|
PartsImported int `json:"partsImported"`
|
|
}
|
|
|
|
// handleImportData adds cars/service-records/parts from a previously exported
|
|
// JSON file (or a hand-built one in the same shape). It only ever creates new
|
|
// records — it does not merge with or overwrite existing shared household
|
|
// data. Deliberately lenient about unknown top-level fields (e.g. the
|
|
// export's "account"/"exportedAt"), since round-tripping the exact export
|
|
// file is the main use case.
|
|
func (s *Server) handleImportData(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
|
|
var in importRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid import file: "+err.Error())
|
|
return
|
|
}
|
|
if len(in.Cars) == 0 {
|
|
writeError(w, http.StatusBadRequest, "import file has no cars")
|
|
return
|
|
}
|
|
|
|
var result importResult
|
|
for _, ic := range in.Cars {
|
|
car := ic.Car
|
|
if car.Name == "" {
|
|
continue // skip malformed entries rather than failing the whole import
|
|
}
|
|
applyCarDefaults(&car)
|
|
|
|
// Imported cars are owned by the importing user, regardless of any
|
|
// owner in the file.
|
|
payload := carPayload(car)
|
|
payload["owner"] = claims.Sub
|
|
|
|
var rec carRecord
|
|
if err := s.pb.Create(r.Context(), colCars, payload, &rec); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
result.CarsImported++
|
|
|
|
for _, svc := range ic.ServiceRecords {
|
|
svc.Car = rec.ID
|
|
if err := s.pb.Create(r.Context(), colServices, servicePayload(svc), nil); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
result.ServicesImported++
|
|
}
|
|
for _, p := range ic.Parts {
|
|
p.Car = rec.ID
|
|
if err := s.pb.Create(r.Context(), colParts, partPayload(p), nil); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
result.PartsImported++
|
|
}
|
|
}
|
|
|
|
writeJSON(w, http.StatusOK, result)
|
|
}
|
|
|
|
type deleteAccountRequest struct {
|
|
ConfirmEmail string `json:"confirmEmail"`
|
|
}
|
|
|
|
// handleRequestDeletion starts the cooldown. The account is not touched yet —
|
|
// handleFinalizeDeletion is a separate, later call once the cooldown elapses.
|
|
func (s *Server) handleRequestDeletion(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
var in deleteAccountRequest
|
|
if err := decodeJSON(r, &in); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if !strings.EqualFold(strings.TrimSpace(in.ConfirmEmail), claims.Email) {
|
|
writeError(w, http.StatusBadRequest, "typed email does not match your account email")
|
|
return
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
payload := map[string]any{"deletion_requested_at": formatPBDate(now)}
|
|
if err := s.pb.Update(r.Context(), s.usersCollection, claims.Sub, payload, nil); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]any{
|
|
"deletionRequestedAt": now.Format(time.RFC3339),
|
|
"eligibleAt": now.Add(deletionCooldown).Format(time.RFC3339),
|
|
})
|
|
}
|
|
|
|
func (s *Server) handleCancelDeletion(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
payload := map[string]any{"deletion_requested_at": ""}
|
|
if err := s.pb.Update(r.Context(), s.usersCollection, claims.Sub, payload, nil); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]string{"status": "cancelled"})
|
|
}
|
|
|
|
// handleFinalizeDeletion actually deletes the account, but only once the
|
|
// cooldown started by handleRequestDeletion has elapsed. Deleting the user
|
|
// record cascades to their "sessions" rows (cascadeDelete relation); the
|
|
// shared cars/service-records/parts data is untouched, since it belongs to
|
|
// the household, not to one account.
|
|
func (s *Server) handleFinalizeDeletion(w http.ResponseWriter, r *http.Request) {
|
|
claims, ok := r.Context().Value(claimsKey).(*auth.Claims)
|
|
if !ok {
|
|
writeError(w, http.StatusUnauthorized, "not authenticated")
|
|
return
|
|
}
|
|
rec, err := s.fetchUser(r, claims.Sub)
|
|
if err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
requestedAt := parsePBDate(rec.DeletionRequestedAt)
|
|
if requestedAt.IsZero() {
|
|
writeError(w, http.StatusBadRequest, "no deletion request is pending")
|
|
return
|
|
}
|
|
if time.Now().UTC().Before(requestedAt.Add(deletionCooldown)) {
|
|
writeError(w, http.StatusForbidden, "the cooldown period has not elapsed yet")
|
|
return
|
|
}
|
|
if err := s.pb.Delete(r.Context(), s.usersCollection, claims.Sub); err != nil {
|
|
writePBError(w, err)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|