sgeConsent.go

package models

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

	"forge.grandlyon.com/web-et-numerique/factory/llle_project/backoffice-server/internal/common"
	"forge.grandlyon.com/web-et-numerique/factory/llle_project/backoffice-server/internal/constants"
	"github.com/google/uuid"
	"gorm.io/gorm"
)

type Base struct {
	ID        string `gorm:"primary_key;"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt gorm.DeletedAt `sql:"index"`
}

func (b *Base) BeforeCreate(tx *gorm.DB) (err error) {
	b.ID = uuid.NewString()
	return
}

type SgeConsent struct {
	Base
	Firstname      string    `json:"firstname"`
	Lastname       string    `json:"lastname"`
	Address        string    `json:"address"`
	PointID        string    `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"`
}

type UpdateSgeConsentBody struct {
	ServiceID int `json:"serviceID"`
}

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

	var consent SgeConsent
	err = dh.sqlClient.First(&consent, "id = ?", 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(constants.ContentType, constants.Json)
	json.NewEncoder(w).Encode(consent)

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

func (dh *DataHandler) PostSgeConsent(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 SgeConsent
	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(3, 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(constants.ContentType, constants.Json)
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(consent)

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

func (dh *DataHandler) UpdateSgeConsent(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 SgeConsent
	err = dh.sqlClient.First(&consent, "id = ?", id).Error
	if err != nil {
		http.Error(w, "couldn't find consent", http.StatusNotFound)
		log.Println(err.Error())
		return
	}
	// Get service ID
	decoder := json.NewDecoder(r.Body)
	var body UpdateSgeConsentBody
	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(constants.ContentType, constants.Json)
	json.NewEncoder(w).Encode(consent)

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

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

	var consent = SgeConsent{}
	err = dh.sqlClient.First(&consent, "id = ?", 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)
		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 : %v | %v", id, r.RemoteAddr)
}

func (dh *DataHandler) SearchSgeConsent(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(SgeConsent{}).Where("point_id LIKE ?", "%"+search+"%").Count(&totalRows)
	offset := page * limit

	var consents []SgeConsent
	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      []SgeConsent `json:"rows"`
	}
	pagination.TotalRows = totalRows
	pagination.Rows = consents

	w.Header().Set(constants.ContentType, constants.Json)
	json.NewEncoder(w).Encode(pagination)

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