electricity_bill_calc_service/controller/park.go

package controller

import (
	"electricity_bill_calc/logger"
	"electricity_bill_calc/repository"
	"electricity_bill_calc/response"
	"electricity_bill_calc/security"
	"electricity_bill_calc/vo"
	"net/http"

	"github.com/gofiber/fiber/v2"
	"go.uber.org/zap"
)

var parkLog = logger.Named("Handler", "Park")

func InitializeParkHandlers(router *fiber.App) {
	router.Get("/park", security.EnterpriseAuthorize, listParksBelongsToCurrentUser)
	router.Post("/park", security.EnterpriseAuthorize, createPark)
	router.Get("/park/belongs/:uid", security.OPSAuthorize, listParksBelongsTo)
	router.Get("/park/:pid", security.EnterpriseAuthorize, fetchParkDetail)
	router.Put("/park/:pid", security.EnterpriseAuthorize, modifySpecificPark)
	router.Delete("/park/:pid", security.EnterpriseAuthorize, deleteSpecificPark)
	router.Put("/park/:pid/enabled", security.EnterpriseAuthorize, modifyParkEnabling)
	router.Get("/park/:pid/building", security.EnterpriseAuthorize, listBuildingsBelongsToPark)
	router.Post("/park/:pid/building", security.EnterpriseAuthorize, createBuildingInPark)
	router.Put("/park/:pid/building/:bid", security.EnterpriseAuthorize, modifySpecificBuildingInPark)
	router.Delete("/park/:pid/building/:bid", security.EnterpriseAuthorize, deletedParkBuilding)
	router.Put("/park/:pid/building/:bid/enabled", security.EnterpriseAuthorize, modifyParkBuildingEnabling)
}

// 列出隶属于当前用户的全部园区
func listParksBelongsToCurrentUser(c *fiber.Ctx) error {
	result := response.NewResult(c)
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("列出当前用的全部园区，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	parkLog.Info("列出当前用户下的全部园区", zap.String("user id", session.Uid))
	parks, err := repository.ParkRepository.ListAllParks(session.Uid)
	if err != nil {
		parkLog.Error("无法获取园区列表。", zap.String("user id", session.Uid))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success("已获取到指定用户的下的园区", fiber.Map{"parks": parks})
}

// 列出隶属于指定用户的全部园区
func listParksBelongsTo(c *fiber.Ctx) error {
	result := response.NewResult(c)
	userId := c.Params("uid")
	parkLog.Info("列出指定用户下的全部园区", zap.String("user id", userId))
	parks, err := repository.ParkRepository.ListAllParks(userId)
	if err != nil {
		parkLog.Error("无法获取园区列表。", zap.String("user id", userId))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success("已获取到指定用户的下的园区", fiber.Map{"parks": parks})
}

// 获取指定园区的详细信息
func fetchParkDetail(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	parkLog.Info("获取指定园区的详细信息", zap.String("park id", parkId))
	park, err := repository.ParkRepository.RetrieveParkDetail(parkId)
	if err != nil {
		parkLog.Error("无法获取园区信息。", zap.String("park id", parkId))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success("已获取到指定园区的详细信息", fiber.Map{"park": park})
}

// 创建一个新的园区
func createPark(c *fiber.Ctx) error {
	result := response.NewResult(c)
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("创建一个新的园区，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	parkLog.Info("创建一个新的园区", zap.String("user id", session.Uid))
	creationForm := new(vo.ParkInformationForm)
	if err := c.BodyParser(creationForm); err != nil {
		parkLog.Error("无法解析园区表单数据。", zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	park, err := creationForm.TryIntoPark()
	if err != nil {
		parkLog.Error("无法将园区表单数据转换为园区对象。", zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	ok, err := repository.ParkRepository.CreatePark(session.Uid, park)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法创建新的园区。", zap.String("user id", session.Uid))
		return result.NotAccept("无法创建新的园区。")
	case err != nil:
		parkLog.Error("无法创建新的园区。", zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Created("已创建一个新的园区")
}

// 修改指定园区的信息
func modifySpecificPark(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("修改指定园区的信息，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	parkForm := new(vo.ParkInformationForm)
	if err := c.BodyParser(parkForm); err != nil {
		parkLog.Error("无法解析园区表单数据。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	park, err := parkForm.TryIntoPark()
	if err != nil {
		parkLog.Error("无法将园区表单数据转换为园区对象。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	ok, err := repository.ParkRepository.UpdatePark(parkId, park)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法更新园区信息。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法更新园区信息。")
	case err != nil:
		parkLog.Error("无法更新园区信息。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("已更新指定园区的详细信息")
}

// 修改指定园区的可用性
func modifyParkEnabling(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("修改指定园区的可用性，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	stateForm := new(vo.StateForm)
	if err := c.BodyParser(stateForm); err != nil {
		parkLog.Error("无法解析园区表单数据。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	ok, err := repository.ParkRepository.EnablingPark(parkId, stateForm.Enabled)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法更新园区可用性。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法更新园区可用性。")
	case err != nil:
		parkLog.Error("无法更新园区可用性。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("已更新指定园区的可用性。")
}

// 删除指定的园区
func deleteSpecificPark(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("删除指定的园区，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	ok, err := repository.ParkRepository.DeletePark(parkId)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法删除园区。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法删除园区。")
	case err != nil:
		parkLog.Error("无法删除园区。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success("已删除指定的园区")
}

// 列出指定园区中已经登记的建筑
func listBuildingsBelongsToPark(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("列出指定园区中已经登记的建筑，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	ok, err := repository.ParkRepository.IsParkBelongs(parkId, session.Uid)
	switch {
	case err != nil:
		parkLog.Error("无法判断园区是否隶属于当前用户。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	case err == nil && !ok:
		parkLog.Error("用户试图访问不属于自己的园区。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.Forbidden("您无权访问该园区。")
	}
	buildings, err := repository.ParkRepository.RetrieveParkBuildings(parkId)
	if err != nil {
		parkLog.Error("无法获取园区中的建筑列表。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success("已获取到指定园区中的建筑列表", fiber.Map{"buildings": buildings})
}

// 在指定园区中创建一个新的建筑
func createBuildingInPark(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("在指定园区中创建一个新的建筑，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	buildingForm := new(vo.ParkBuildingInformationForm)
	if err := c.BodyParser(buildingForm); err != nil {
		parkLog.Error("无法解析建筑表单数据。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	ok, err := repository.ParkRepository.CreateParkBuilding(parkId, buildingForm.Name, &buildingForm.Floors)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法创建新的建筑。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法创建新的建筑。")
	case err != nil:
		parkLog.Error("无法创建新的建筑。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Created("已创建一个新的建筑")
}

// 修改指定园区中的指定建筑的信息
func modifySpecificBuildingInPark(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	buildingId := c.Params("bid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("修改指定园区中的指定建筑的信息，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	buildingForm := new(vo.ParkBuildingInformationForm)
	if err := c.BodyParser(buildingForm); err != nil {
		parkLog.Error("无法解析建筑表单数据。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	ok, err := repository.ParkRepository.ModifyParkBuilding(buildingId, parkId, buildingForm.Name, &buildingForm.Floors)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法更新建筑信息。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法更新建筑信息。")
	case err != nil:
		parkLog.Error("无法更新建筑信息。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("已更新指定建筑的信息")
}

// 修改指定园区中指定建筑的可用性
func modifyParkBuildingEnabling(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	buildingId := c.Params("bid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("修改指定园区中指定建筑的可用性，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	stateForm := new(vo.StateForm)
	if err := c.BodyParser(stateForm); err != nil {
		parkLog.Error("无法解析建筑表单数据。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.NotAccept(err.Error())
	}
	ok, err := repository.ParkRepository.EnablingParkBuilding(buildingId, parkId, stateForm.Enabled)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法更新建筑可用性。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法更新建筑可用性。")
	case err != nil:
		parkLog.Error("无法更新建筑可用性。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("已更新指定建筑的可用性")
}

// 删除指定园区中的指定建筑
func deletedParkBuilding(c *fiber.Ctx) error {
	result := response.NewResult(c)
	parkId := c.Params("pid")
	buildingId := c.Params("bid")
	session, err := _retreiveSession(c)
	if err != nil {
		parkLog.Error("删除指定园区中的指定建筑，无法获取当前用户的会话。")
		return result.Unauthorized(err.Error())
	}
	if pass, err := checkParkBelongs(parkId, parkLog, c, &result); !pass {
		return err
	}
	ok, err := repository.ParkRepository.DeleteParkBuilding(buildingId, parkId)
	switch {
	case err == nil && !ok:
		parkLog.Error("无法删除建筑。", zap.String("park id", parkId), zap.String("user id", session.Uid))
		return result.NotAccept("无法删除建筑。")
	case err != nil:
		parkLog.Error("无法删除建筑。", zap.String("park id", parkId), zap.String("user id", session.Uid), zap.Error(err))
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Deleted("已删除指定的建筑")
}