parcoursmob/handlers/application/diags.go

package application

import (
	"context"
	// "encoding/json"
	"fmt"
	// "io"
	"net/http"
	// "strconv"
	"strings"
	"time"

	"git.coopgo.io/coopgo-apps/parcoursmob/utils/identification"
	// filestorage "git.coopgo.io/coopgo-apps/parcoursmob/utils/storage"
	diags "git.coopgo.io/coopgo-platform/diags/grpcapi"
	diagsstorage "git.coopgo.io/coopgo-platform/diags/storage"
	// groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
	// "git.coopgo.io/coopgo-platform/groups-management/storage"
	// mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	// "github.com/google/uuid"
	"github.com/gorilla/mux"
	"github.com/rs/zerolog/log"
	"google.golang.org/protobuf/types/known/structpb"
	"google.golang.org/protobuf/types/known/timestamppb"
)

type DiagsForm struct {
	Name            string          `json:"name" validate:"required"`
	Namespace       string          `json:"namespace" validate:"required"`
	JsonSchema      string          `json:"json_schema"`
	UiSchema        string          `json:"ui_schema"`
	Data            map[string]any  `json:"data"`
	Deleted         bool            `json:"deleted"`
}

func (h *ApplicationHandler) DiagsHome(w http.ResponseWriter, r *http.Request) {
	resp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), &diags.GetDiagsRequest{
		Namespaces: []string{"parcoursmob_diagnostiques"},
		Mindate:    timestamppb.New(time.Now().Add(-24 * time.Hour)),
	})

	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	responses := []diagsstorage.Diag{}

	for _, e := range resp.Diags {
		responses = append(responses, e.ToStorageType())
	}

	h.Renderer.DiagsHome(w, r, responses)
}

func (h *ApplicationHandler) DiagsHistory(w http.ResponseWriter, r *http.Request) {
	resp, err := h.services.GRPC.Diags.GetDiags(context.TODO(), &diags.GetDiagsRequest{
		Namespaces: []string{"parcoursmob_diagnostiques"},
		//Maxdate:    timestamppb.New(time.Now().Add(24 * time.Hour)),
	})

	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	responses := []diagsstorage.Diag{}

	for _, e := range resp.Diags {
		responses = append(responses, e.ToStorageType())
	}

	h.Renderer.DiagsHistory(w, r, responses)
}

func (h *ApplicationHandler) DiagsCreateDiag(w http.ResponseWriter, r *http.Request) {
	if r.Method == "POST" {
		// Get current group
		g := r.Context().Value(identification.GroupKey)
		if g == nil {
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		diagForm, err := parseDiagsForm(r)
		if err != nil {
			log.Error().Err(err).Msg("")
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		log.Debug().Any("diagFrom", diagForm).Msg("Form data submitted to create diag")

		data, _ := structpb.NewStruct(map[string]any{
		})

		request := &diags.CreateDiagRequest{
			Diag: &diags.Diag{
				Namespace:      "parcoursmob_diagnostiques",
				Name:           diagForm.Name,
				JsonSchema:     diagForm.JsonSchema,
				Data:           data,
				Deleted:        false,
			},
		}

		resp, err := h.services.GRPC.Diags.CreateDiag(context.TODO(), request)
		if err != nil {
			log.Error().Err(err).Msg("")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}


		http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound)
		return
	}

	h.Renderer.DiagsCreateDiag(w, r)
}

func (h *ApplicationHandler) DiagsDisplayDiag(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	diagid := vars["diagid"]

	request := &diags.GetDiagRequest{
		Id: diagid,
	}

	resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request)
	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	g := r.Context().Value(identification.GroupKey)
	if g == nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}


	h.Renderer.DiagsDisplayDiag(w, r, resp.Diag.ToStorageType())
}

func parseDiagsForm(r *http.Request) (*DiagsForm, error) {
	if err := r.ParseForm(); err != nil {
		return nil, err
	}

	formData := &DiagsForm{
		Name:           r.PostFormValue("name"),
		Namespace:      "parcoursmob_diagnostiques",
		JsonSchema:     r.PostFormValue("json_schema"),
		UiSchema:       r.PostFormValue("ui_schema"),
		Data:           map[string]any{},
		Deleted:        false,
	}

	return formData, nil
}

func (h *ApplicationHandler) DiagsUpdateDiag(w http.ResponseWriter, r *http.Request) {
	adm := strings.Split(r.URL.Path, "/")
	diagID := adm[3]
	request := &diags.GetDiagRequest{
		Id: diagID,
	}

	resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request)
	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	if r.Method == "POST" {
		g := r.Context().Value(identification.GroupKey)
		if g == nil {
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		diagForm, err := parseDiagsForm(r)
		if err != nil {
			log.Error().Err(err).Msg("")
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		data, _ := structpb.NewStruct(map[string]any{})

		request := &diags.UpdateDiagRequest{
			Diag: &diags.Diag{
				Namespace:      "parcoursmob_diagnostiques",
				Id:             diagID,
				Name:           diagForm.Name,
				JsonSchema:     diagForm.JsonSchema,
				UiSchema: 	 	diagForm.UiSchema,
				Data:           data,

			},
		}

		resp, err := h.services.GRPC.Diags.UpdateDiag(context.TODO(), request)

		if err != nil {
			log.Error().Err(err).Msg("")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/app/diags/%s", resp.Diag.Id), http.StatusFound)
		return
	}
	h.Renderer.DiagsUpdateDiag(w, r, resp.Diag.ToStorageType())
}

func (h *ApplicationHandler) DiagsDeleteDiag(w http.ResponseWriter, r *http.Request) {

	vars := mux.Vars(r)
	diagID := vars["diagid"]
	request := &diags.GetDiagRequest{
		Id: diagID,
	}

	resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request)
	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	if r.Method == "POST" {

		request := &diags.UpdateDiagRequest{
			Diag: &diags.Diag{
				Namespace:      resp.Diag.Namespace,
				Id:             resp.Diag.Id,
				Name:           resp.Diag.Name,
				JsonSchema:     resp.Diag.JsonSchema,
				UiSchema:	 	resp.Diag.UiSchema,
				Data:           resp.Diag.Data,
				Deleted:        true,
			},
		}

		_, err := h.services.GRPC.Diags.UpdateDiag(context.TODO(), request)

		if err != nil {
			log.Error().Err(err).Msg("")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		http.Redirect(w, r, "/app/diags/", http.StatusFound)
		return
	}
	h.Renderer.DiagsDeleteDiag(w, r, resp.Diag.ToStorageType())
}

func (h *ApplicationHandler) DiagsHistoryDiag(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	diagId := vars["diagid"]
	request := &diags.GetDiagRequest{
		Id: diagId,
	}

	resp, err := h.services.GRPC.Diags.GetDiag(context.TODO(), request)
	if err != nil {
		log.Error().Err(err).Msg("")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	h.Renderer.DiagsHistoryDiag(w, r, resp.Diag.ToStorageType())
}