consent.go

package models

import (
	"encoding/json"
	"errors"
	"log"
	"net/http"
	"time"

	"forge.grandlyon.com/web-et-numerique/llle_project/backoffice-server/internal/common"
	"gorm.io/gorm"
)

type Consent struct {
	gorm.Model
	Firstname      string    `json:"firstname"`
	Lastname       string    `json:"lastname"`
	Address        string    `json:"address"`
	PointID        int       `json:"pointID"`
	PostalCode     string    `json:"postalCode"`
	City           string    `json:"city"`
	SafetyBoarding bool      `json:"safetyOnBoarding"`
	InseeCode      string    `json:"inseeCode"`
	EndDate        time.Time `json:"endDate"`
	ServiceID      int       `json:"serviceID,omitempty"`
}

func (dh *DataHandler) GetConsentById(w http.ResponseWriter, r *http.Request) {
	id, err := common.IdFromRequest(r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	var consent Consent
	err = dh.sqlClient.First(&consent, id).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			http.Error(w, "consent not found", http.StatusNotFound)
			return
		}
		http.Error(w, "error while finding consent", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(consent)

	log.Printf("| get consent | name : %v | %v", consent.Lastname, r.RemoteAddr)
}

func (dh *DataHandler) PostConsent(w http.ResponseWriter, r *http.Request) {
	if r.Body == http.NoBody {
		http.Error(w, "request body is empty", http.StatusBadRequest)
		return
	}

	decoder := json.NewDecoder(r.Body)
	var consent Consent
	err := decoder.Decode(&consent)
	if err != nil {
		http.Error(w, "couldn't parse body", http.StatusInternalServerError)
		log.Println(err.Error())
		return
	}
	consent.EndDate = time.Now().AddDate(1, 0, 0)

	// Create a consent in SQL
	err = dh.sqlClient.Create(&consent).Error
	if err != nil {
		http.Error(w, "couldn't create consent", http.StatusInternalServerError)
		log.Println(err.Error())
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(consent)

	log.Printf("| new consent | name : %v | %v", consent.Lastname, r.RemoteAddr)
}

func (dh *DataHandler) UpdateConsent(w http.ResponseWriter, r *http.Request) {
	if r.Body == http.NoBody {
		http.Error(w, "request body is empty", http.StatusBadRequest)
		return
	}
	id, err := common.IdFromRequest(r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Find consent
	var consent Consent
	err = dh.sqlClient.First(&consent, id).Error
	if err != nil {
		http.Error(w, "couldn't find consent", http.StatusInternalServerError)
		log.Println(err.Error())
		return
	}
	// Get service ID
	decoder := json.NewDecoder(r.Body)
	var body struct {
		ServiceID int `json:"serviceID"`
	}
	err = decoder.Decode(&body)
	if err != nil {
		http.Error(w, "couldn't parse body", http.StatusInternalServerError)
		return
	}
	if body.ServiceID <= 0 {
		http.Error(w, "invalid service id", http.StatusBadRequest)
		return
	}

	// Update and save consent
	consent.ServiceID = body.ServiceID
	err = dh.sqlClient.Save(&consent).Error
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Println(err.Error())
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(consent)

	log.Printf("| updated consent | name : %v | serviceID : %v | %v", consent.Lastname, consent.ServiceID, r.RemoteAddr)
}

func (dh *DataHandler) DeleteConsentById(w http.ResponseWriter, r *http.Request) {
	id, err := common.IdFromRequest(r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	var consent = Consent{}
	err = dh.sqlClient.First(&consent, id).Error
	if err != nil {
		http.Error(w, "couldn't find consent", http.StatusInternalServerError)
		log.Println(err.Error())
		return
	}

	// Update and save consent in MySQL
	consent.EndDate = time.Now()
	err = dh.sqlClient.Save(&consent).Error
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Println(err.Error())
		return
	}

	dh.sqlClient.Delete(&consent)

	log.Printf("| deleted consent | id : %d | %v", id, r.RemoteAddr)
}

func (dh *DataHandler) SearchConsent(w http.ResponseWriter, r *http.Request) {
	search := r.URL.Query().Get("search")

	page, limit, err := common.PageLimitFromRequest(r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	var totalRows int64
	dh.sqlClient.Unscoped().Model(Consent{}).Where("point_id LIKE ?", "%"+search+"%").Count(&totalRows)
	offset := page * limit

	var consents []Consent
	dh.sqlClient.Unscoped().Order("created_at desc").Offset(offset).Limit(limit).Where("point_id LIKE ?", "%"+search+"%").Find(&consents)

	var pagination struct {
		TotalRows int64     `json:"totalRows"`
		Rows      []Consent `json:"rows"`
	}
	pagination.TotalRows = totalRows
	pagination.Rows = consents

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(pagination)

	log.Printf("| get all consents | limit : %d | page : %d | %v", limit, page, r.RemoteAddr)

}