astra-events/handler/event.go

package handler

import (
	"astra-events/model"
	"astra-events/pkg/utils"
	"astra-events/services"
	"fmt"
	"github.com/google/uuid"
	"github.com/hashicorp/go-set"
	"github.com/labstack/echo/v4"
	"net/http"
)

// swagger:route POST /events/ Events CreateEvent
//
// responses:
//   200: Event

func (h *Handler) CreateEvent(c echo.Context) (err error) {
	var person *model.PersonalInformation
	event := new(model.CreateEvent)
	authorId, err := uuid.Parse(c.Request().Header.Get("UserId"))
	orgId, err := uuid.Parse(c.Request().Header.Get("UserOrganizationId"))
	if err != nil {
		return c.NoContent(http.StatusUnauthorized)
	}

	err = c.Bind(&event)
	err = h.Validator.Struct(event)

	if err != nil {
		return c.HTML(http.StatusBadRequest, fmt.Sprintf("Err(s):\n%+v\n", err))
	}

	if event.Person.ID.ID() != 0 {
		person, err = services.GetPerson(event.Person.ID, c.Request().Header)
		if err != nil || person.ID != event.Person.ID {
			return c.NoContent(http.StatusBadRequest)
		}
	} else {
		newPerson := model.PersonalInformationCreate{
			FirstName:  event.Person.FirstName,
			LastName:   event.Person.LastName,
			Patronymic: event.Person.Patronymic,
			Contacts: []model.Contact{
				{
					Category: "PHONE",
					Value:    event.Person.Phone,
				},
			},
		}

		person, err = services.CreatePerson(newPerson, c.Request().Header)
		if err != nil || person.ID.ID() == 0 {
			return c.NoContent(http.StatusBadRequest)
		}
	}

	usersMap, err := services.GetUsers([]uuid.UUID{event.MedicId, authorId}, c.Request().Header)

	if err != nil || len(usersMap) == 0 {
		return c.HTML(http.StatusBadGateway, "Error get users")
	}

	medic := usersMap[event.MedicId]
	author := usersMap[authorId]

	newEvent, err := utils.TypeConverter[model.Event](event)

	newEvent.OrgId = orgId
	newEvent.MedicId = event.MedicId
	newEvent.AuthorId = authorId
	newEvent.PersonId = person.ID
	newEvent.Person = *person

	tx := h.DB.Create(&newEvent)

	if tx.RowsAffected == 0 {
		return c.NoContent(http.StatusBadGateway)
	}

	newEvent.Author = author
	newEvent.Medic = medic

	return c.JSON(http.StatusCreated, newEvent)
}

// swagger:route GET /events/ Events GetEvents
//
// responses:
//   200: []Event

func (h *Handler) GetEvents(c echo.Context) (err error) {
	var events []model.Event
	query := c.Request().URL.Query()
	_, _, filterMap := utils.GetFilterParams(query)
	orgId, err := uuid.Parse(c.Request().Header.Get("UserOrganizationId"))

	if err != nil {
		return c.NoContent(http.StatusUnauthorized)
	}

	tx := h.DB.Where("org_id = ?", orgId)

	if len(filterMap) > 0 {
		tx = tx.Where("start >= ?", filterMap["start"]).Where("\"end\" <= ?", filterMap["end"])
	}

	tx.Find(&events)

	ids := set.New[uuid.UUID](len(events) * 2)

	for _, event := range events {
		ids.Insert(event.MedicId)
		ids.Insert(event.AuthorId)
	}

	usersMap, err := services.GetUsers(ids.Slice(), c.Request().Header)
	if err != nil {
		return c.HTML(http.StatusBadGateway, err.Error())
	}

	for i, event := range events {
		events[i].Author = usersMap[event.AuthorId]
		events[i].Medic = usersMap[event.MedicId]
	}

	return c.JSON(http.StatusOK, events)
}

// swagger:route GET /events/{uuid} Events GetEvent
//
// responses:
//   200: Event

func (h *Handler) GetEvent(c echo.Context) error {
	var event model.Event
	id := c.Param("id")
	orgId, err := uuid.Parse(c.Request().Header.Get("UserOrganizationId"))

	if err != nil {
		return c.NoContent(http.StatusUnauthorized)
	}

	tx := h.DB.Where("org_id = ?", orgId).First(&event, id)

	if tx.RowsAffected == 0 {
		return c.NoContent(http.StatusNotFound)
	}

	usersMap, err := services.GetUsers([]uuid.UUID{event.MedicId, event.AuthorId}, c.Request().Header)

	if err != nil {
		return c.HTML(http.StatusBadGateway, err.Error())
	}

	medic := usersMap[event.MedicId]
	author := usersMap[event.AuthorId]

	event.Medic = medic
	event.Author = author

	return c.JSON(http.StatusOK, event)
}

// swagger:route DELETE /events/{uuid} Events DeleteEvent
//
// responses:
//   200

func (h *Handler) DeleteEvent(c echo.Context) error {
	id := c.Param("id")
	orgId, err := uuid.Parse(c.Request().Header.Get("UserOrganizationId"))

	if err != nil {
		return c.NoContent(http.StatusUnauthorized)
	}

	tx := h.DB.Where("org_id = ?", orgId).Delete(&model.Event{}, id)

	if tx.RowsAffected == 0 {
		return c.NoContent(http.StatusNotFound)
	}

	return c.NoContent(http.StatusOK)
}