electricity_bill_calc_service/controller/maintenance_fee.go

package controller

import (
	"electricity_bill_calc/model"
	"electricity_bill_calc/response"
	"electricity_bill_calc/security"
	"electricity_bill_calc/service"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/jinzhu/copier"
	"github.com/shopspring/decimal"
)

type _MaintenanceFeeController struct {
	Router *gin.Engine
}

var MaintenanceFeeController *_MaintenanceFeeController

func InitializeMaintenanceFeeController(router *gin.Engine) {
	MaintenanceFeeController = &_MaintenanceFeeController{
		Router: router,
	}

	MaintenanceFeeController.Router.GET("/maintenance/fee", security.EnterpriseAuthorize, listMaintenanceFees)
	MaintenanceFeeController.Router.POST("/maintenance/fee", security.EnterpriseAuthorize, createMaintenanceFeeRecord)
	MaintenanceFeeController.Router.PUT("/maintenance/fee/:mid", security.EnterpriseAuthorize, modifyMaintenanceFeeRecord)
	MaintenanceFeeController.Router.PUT("/maintenance/fee/:mid/enabled", security.EnterpriseAuthorize, changeMaintenanceFeeState)
	MaintenanceFeeController.Router.DELETE("/maintenance/fee/:mid", security.EnterpriseAuthorize, deleteMaintenanceFee)
}

func listMaintenanceFees(c *gin.Context) {
	result := response.NewResult(c)
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	requestPark := c.DefaultQuery("park", "")
	if len(requestPark) > 0 {
		sure, err := service.ParkService.EnsurePark(userSession.Uid, requestPark)
		if err != nil {
			result.Error(http.StatusInternalServerError, err.Error())
			return
		}
		if !sure {
			result.Unauthorized("不能访问不属于自己的园区。")
			return
		}
		fees, err := service.MaintenanceFeeService.ListMaintenanceFees([]string{requestPark})
		if err != nil {
			result.Error(http.StatusInternalServerError, err.Error())
			return
		}
		result.Json(http.StatusOK, "已获取指定园区下的维护费记录", gin.H{"fees": fees})
	} else {
		parkIds, err := service.ParkService.AllParkIds(userSession.Uid)
		if err != nil {
			result.Error(http.StatusInternalServerError, err.Error())
			return
		}
		fees, err := service.MaintenanceFeeService.ListMaintenanceFees(parkIds)
		if err != nil {
			result.Error(http.StatusInternalServerError, err.Error())
			return
		}
		result.Json(http.StatusOK, "已获取指定用户下的所有维护费记录。", gin.H{"fees": fees})
	}
}

type _FeeCreationFormData struct {
	ParkId string          `json:"parkId" form:"parkId"`
	Name   string          `json:"name" form:"name"`
	Fee    decimal.Decimal `json:"fee" form:"fee"`
	Memo   *string         `json:"memo" form:"memo"`
}

func createMaintenanceFeeRecord(c *gin.Context) {
	result := response.NewResult(c)
	formData := new(_FeeCreationFormData)
	c.BindJSON(formData)
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	sure, err := service.ParkService.EnsurePark(userSession.Uid, formData.ParkId)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	if !sure {
		result.Unauthorized("不能访问不属于自己的园区。")
		return
	}
	newMaintenanceFee := &model.MaintenanceFee{}
	copier.Copy(newMaintenanceFee, formData)
	err = service.MaintenanceFeeService.CreateMaintenanceFeeRecord(*newMaintenanceFee)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Created("新维护费记录已经创建。")
}

type _FeeModificationFormData struct {
	Fee  decimal.Decimal `json:"fee" form:"fee"`
	Memo *string         `json:"memo" form:"memo"`
}

func modifyMaintenanceFeeRecord(c *gin.Context) {
	result := response.NewResult(c)
	requestFee := c.Param("mid")
	formData := new(_FeeModificationFormData)
	c.BindJSON(formData)
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	sure, err := service.MaintenanceFeeService.EnsureFeeBelongs(userSession.Uid, requestFee)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	if !sure {
		result.Unauthorized("所操作维护费记录不属于当前用户。")
		return
	}
	newFeeState := new(model.MaintenanceFee)
	copier.Copy(newFeeState, formData)
	err = service.MaintenanceFeeService.ModifyMaintenanceFee(*newFeeState)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Updated("指定维护费条目已更新。")
}

type _FeeStateFormData struct {
	Enabled bool `json:"enabled" form:"enabled"`
}

func changeMaintenanceFeeState(c *gin.Context) {
	result := response.NewResult(c)
	requestFee := c.Param("mid")
	formData := new(_FeeStateFormData)
	c.BindJSON(formData)
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	sure, err := service.MaintenanceFeeService.EnsureFeeBelongs(userSession.Uid, requestFee)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	if !sure {
		result.Unauthorized("所操作维护费记录不属于当前用户。")
		return
	}
	err = service.MaintenanceFeeService.ChangeMaintenanceFeeState(requestFee, formData.Enabled)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Updated("指定维护费条目状态已更新。")
}

func deleteMaintenanceFee(c *gin.Context) {
	result := response.NewResult(c)
	requestFee := c.Param("mid")
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	sure, err := service.MaintenanceFeeService.EnsureFeeBelongs(userSession.Uid, requestFee)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	if !sure {
		result.Unauthorized("所操作维护费记录不属于当前用户。")
		return
	}
	err = service.MaintenanceFeeService.DeleteMaintenanceFee(requestFee)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Deleted("指定维护费条目已删除。")
}