480 lines
15 KiB
Go
480 lines
15 KiB
Go
package controller
|
|
|
|
import (
|
|
"electricity_bill_calc/exceptions"
|
|
"electricity_bill_calc/model"
|
|
"electricity_bill_calc/response"
|
|
"electricity_bill_calc/security"
|
|
"electricity_bill_calc/service"
|
|
"electricity_bill_calc/tools"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/fufuok/utils"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/jinzhu/copier"
|
|
"github.com/samber/lo"
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
func InitializeReportController(router *gin.Engine) {
|
|
router.GET("/reports/with/drafts", security.EnterpriseAuthorize, fetchNewestReportOfParkWithDraft)
|
|
router.POST("/park/:pid/report", security.EnterpriseAuthorize, initializeNewReport)
|
|
router.GET("/report/:rid/step/state", security.EnterpriseAuthorize, fetchReportStepStates)
|
|
router.GET("/report/:rid/summary", security.EnterpriseAuthorize, fetchReportParkSummary)
|
|
router.PUT("/report/:rid/summary", security.EnterpriseAuthorize, fillReportSummary)
|
|
router.GET("/report/:rid/summary/calculate", security.EnterpriseAuthorize, testCalculateReportSummary)
|
|
router.POST("/report/:rid/summary/calculate", security.EnterpriseAuthorize, progressReportSummary)
|
|
router.GET("/report/:rid/maintenance", security.EnterpriseAuthorize, fetchWillDilutedFees)
|
|
router.POST("/report/:rid/maintenance", security.EnterpriseAuthorize, createTemporaryWillDilutedFee)
|
|
router.POST("/report/:rid/maintenance/import", security.EnterpriseAuthorize, importPredefinedMaintenanceFees)
|
|
router.PUT("/report/:rid/maintenance/:mid", security.EnterpriseAuthorize, modifyWillDilutedFee)
|
|
router.DELETE("/report/:rid/maintenance/:mid", security.EnterpriseAuthorize, deleteTemporaryWillDilutedFee)
|
|
router.PUT("/report/:rid/step/diluted/fees", security.EnterpriseAuthorize, progressReportWillDilutedFee)
|
|
router.PUT("/report/:rid/step/meter/register", security.EnterpriseAuthorize, progressEndUserRegister)
|
|
router.POST("/report/:rid/publish", security.EnterpriseAuthorize, publishReport)
|
|
router.GET("/reports", security.MustAuthenticated, searchReports)
|
|
router.GET("/report/:rid", security.MustAuthenticated, fetchReportPublicity)
|
|
router.POST("/report/:rid/calculate", security.EnterpriseAuthorize, calculateReport)
|
|
}
|
|
|
|
func ensureReportBelongs(c *gin.Context, result *response.Result, requestReportId string) bool {
|
|
_, err := _retreiveSession(c)
|
|
if err != nil {
|
|
result.Unauthorized(err.Error())
|
|
return false
|
|
}
|
|
requestReport, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return false
|
|
}
|
|
if requestReport == nil {
|
|
result.NotFound("指定报表未能找到。")
|
|
return false
|
|
}
|
|
return ensureParkBelongs(c, result, requestReport.ParkId)
|
|
}
|
|
|
|
func fetchNewestReportOfParkWithDraft(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
userSession, err := _retreiveSession(c)
|
|
if err != nil {
|
|
result.Unauthorized(err.Error())
|
|
return
|
|
}
|
|
parks, err := service.ReportService.FetchParksWithNewestReport(userSession.Uid)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Json(http.StatusOK, "已获取到指定用户下所有园区的最新报表记录。", gin.H{"parks": parks})
|
|
}
|
|
|
|
func initializeNewReport(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestParkId := c.Param("pid")
|
|
userSession, err := _retreiveSession(c)
|
|
if err != nil {
|
|
result.Unauthorized(err.Error())
|
|
return
|
|
}
|
|
if !ensureParkBelongs(c, result, requestParkId) {
|
|
return
|
|
}
|
|
requestPeriod := c.Query("period")
|
|
reportPeriod, err := time.Parse("2006-01", requestPeriod)
|
|
if err != nil {
|
|
result.NotAccept("提供的初始化期数格式不正确。")
|
|
return
|
|
}
|
|
valid, err := service.ReportService.IsNewPeriodValid(userSession.Uid, requestParkId, reportPeriod)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
if !valid {
|
|
result.NotAccept("只能初始化已发布报表下一个月份的新报表。")
|
|
return
|
|
}
|
|
newId, err := service.ReportService.InitializeNewReport(requestParkId, reportPeriod)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Created("新一期报表初始化成功。", gin.H{"reportId": newId})
|
|
}
|
|
|
|
func fetchReportStepStates(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
requestReport, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
result.Json(http.StatusOK, "已经获取到指定报表的填写状态。", gin.H{"steps": requestReport.StepState})
|
|
}
|
|
|
|
func fetchReportParkSummary(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
if summary == nil {
|
|
result.NotFound("指定报表未能找到。")
|
|
return
|
|
}
|
|
result.Json(http.StatusOK, "已经获取到指定报表中的园区概况。", gin.H{"summary": summary})
|
|
}
|
|
|
|
type ReportSummaryFormData struct {
|
|
Overall decimal.Decimal `json:"overall" form:"overall"`
|
|
OverallFee decimal.Decimal `json:"overallFee" form:"overallFee"`
|
|
Critical decimal.Decimal `json:"critical" form:"critical"`
|
|
CriticalFee decimal.Decimal `json:"criticalFee" form:"criticalFee"`
|
|
Peak decimal.Decimal `json:"peak" form:"peak"`
|
|
PeakFee decimal.Decimal `json:"peakFee" form:"peakFee"`
|
|
Valley decimal.Decimal `json:"valley" form:"valley"`
|
|
ValleyFee decimal.Decimal `json:"valleyFee" form:"valleyFee"`
|
|
BasicFee decimal.Decimal `json:"basicFee" form:"basicFee"`
|
|
AdjustFee decimal.Decimal `json:"adjustFee" from:"adjustFee"`
|
|
}
|
|
|
|
func fillReportSummary(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
formData := new(ReportSummaryFormData)
|
|
c.BindJSON(formData)
|
|
originSummary, err := service.ReportService.RetreiveReportSummary(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
copier.Copy(originSummary, formData)
|
|
originSummary.ReportId = requestReportId
|
|
err = service.ReportService.UpdateReportSummary(originSummary)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Updated("指定电费公示报表中的园区概况基本数据已经完成更新。")
|
|
}
|
|
|
|
func testCalculateReportSummary(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
summary.CalculatePrices()
|
|
calcResults := tools.ConvertStructToMap(summary)
|
|
result.Json(http.StatusOK, "已完成园区概况的试计算。", gin.H{"result": lo.PickByKeys(calcResults, []string{"overallPrice", "criticalPrice", "peakPrice", "flat", "flatFee", "flatPrice", "valleyPrice"})})
|
|
}
|
|
|
|
func progressReportSummary(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
err := service.ReportService.CalculateSummaryAndFinishStep(requestReportId)
|
|
if err != nil {
|
|
if nfErr, ok := err.(exceptions.NotFoundError); ok {
|
|
result.NotFound(nfErr.Error())
|
|
} else {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
}
|
|
return
|
|
}
|
|
result.Success("已经完成园区概况的计算，并可以进行到下一步骤。")
|
|
}
|
|
|
|
func fetchWillDilutedFees(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
fees, err := service.ReportService.FetchWillDulutedMaintenanceFees(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
result.Json(http.StatusOK, "待摊薄费用已经获取到。", gin.H{"fees": fees})
|
|
}
|
|
|
|
type DilutedFeeCreationFormData 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 createTemporaryWillDilutedFee(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
formData := new(DilutedFeeCreationFormData)
|
|
c.BindJSON(formData)
|
|
report, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
if formData.ParkId != report.ParkId {
|
|
result.NotAccept("选择的园区与公示报表所属的园区不一致。")
|
|
return
|
|
}
|
|
newWillDilutedFee := new(model.WillDilutedFee)
|
|
copier.Copy(newWillDilutedFee, formData)
|
|
newWillDilutedFee.ReportId = report.Id
|
|
err = service.ReportService.CreateTemporaryWillDilutedMaintenanceFee(*newWillDilutedFee)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Created("公示报表中所要使用的临时待摊薄费用已添加。")
|
|
}
|
|
|
|
func importPredefinedMaintenanceFees(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
report, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
maintenanceFees, err := service.MaintenanceFeeService.ListMaintenanceFees([]string{report.ParkId})
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
log.Printf("[cotroller] [debug] fees: %+v", maintenanceFees)
|
|
enabledMaintenanceFees := lo.Filter(
|
|
maintenanceFees,
|
|
func(elem model.MaintenanceFee, index int) bool {
|
|
return elem.Enabled
|
|
},
|
|
)
|
|
log.Printf("[cotroller] [debug] fees: %+v", enabledMaintenanceFees)
|
|
if len(enabledMaintenanceFees) == 0 {
|
|
result.NotFound("没有找到可供导入的配电维护费记录。")
|
|
return
|
|
}
|
|
dilutedFees := lo.Map(
|
|
enabledMaintenanceFees,
|
|
func(elem model.MaintenanceFee, index int) model.WillDilutedFee {
|
|
fee := &model.WillDilutedFee{
|
|
Id: utils.UUIDString(),
|
|
ReportId: report.Id,
|
|
SourceId: lo.ToPtr(elem.Id),
|
|
Name: elem.Name,
|
|
Fee: elem.Fee,
|
|
Memo: elem.Memo,
|
|
}
|
|
return *fee
|
|
},
|
|
)
|
|
err = service.ReportService.BatchSaveMaintenanceFee(report.Id, dilutedFees)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Created("预定义的配电维护费已经导入。")
|
|
}
|
|
|
|
type DilutedFeeModificationFormData struct {
|
|
Name *string `json:"name,omitempty" form:"name"`
|
|
Fee decimal.Decimal `json:"fee" form:"fee"`
|
|
Memo *string `json:"memo,omitempty" form:"memo"`
|
|
}
|
|
|
|
func modifyWillDilutedFee(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
requestFeeId := c.Param("mid")
|
|
formData := new(DilutedFeeModificationFormData)
|
|
c.BindJSON(formData)
|
|
updateValues := tools.ConvertStructToMap(formData)
|
|
err := service.ReportService.UpdateMaintenanceFee(requestFeeId, updateValues)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Updated("指定待摊薄费用信息已经更新。")
|
|
}
|
|
|
|
func deleteTemporaryWillDilutedFee(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
requestFeeId := c.Param("mid")
|
|
err := service.ReportService.DeleteWillDilutedFee(requestFeeId)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Deleted("指定待摊薄费用信息已经删除。")
|
|
}
|
|
|
|
func progressReportWillDilutedFee(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
report, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
err = service.ReportService.ProgressReportWillDilutedFee(*report)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Success("待摊薄费用编辑步骤已经完成。")
|
|
}
|
|
|
|
func progressEndUserRegister(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
report, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
err = service.ReportService.ProgressReportRegisterEndUser(*report)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Success("终端用户抄表编辑步骤已经完成。")
|
|
}
|
|
|
|
func publishReport(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
report, err := service.ReportService.RetreiveReportIndex(requestReportId)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
err = service.ReportService.PublishReport(*report)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Success("指定的公示报表已经发布。")
|
|
}
|
|
|
|
func searchReports(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
session, err := _retreiveSession(c)
|
|
if err != nil {
|
|
result.Unauthorized(err.Error())
|
|
return
|
|
}
|
|
requestUser := lo.
|
|
If(session.Type == model.USER_TYPE_ENT, session.Uid).
|
|
Else(c.DefaultQuery("user", ""))
|
|
requestPark := c.DefaultQuery("park", "")
|
|
if len(requestPark) > 0 && session.Type == model.USER_TYPE_ENT {
|
|
if !ensureParkBelongs(c, result, requestPark) {
|
|
return
|
|
}
|
|
}
|
|
requestPeriodString := c.DefaultQuery("period", "")
|
|
var requestPeriod *time.Time = nil
|
|
if len(requestPeriodString) > 0 {
|
|
parsedPeriod, err := time.Parse("2006-01", requestPeriodString)
|
|
if err != nil {
|
|
result.NotAccept("参数[period]的格式不正确。")
|
|
return
|
|
}
|
|
requestPeriod = lo.ToPtr(parsedPeriod)
|
|
}
|
|
requestKeyword := c.DefaultQuery("keyword", "")
|
|
requestPage, err := strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
if err != nil {
|
|
result.NotAccept("查询参数[page]格式不正确。")
|
|
return
|
|
}
|
|
records, totalItems, err := service.ReportService.SearchReport(requestUser, requestPark, requestKeyword, requestPeriod, requestPage)
|
|
if err != nil {
|
|
result.NotFound(err.Error())
|
|
return
|
|
}
|
|
result.Success(
|
|
"已经取得符合条件的公示报表记录。",
|
|
response.NewPagedResponse(requestPage, totalItems).ToMap(),
|
|
gin.H{"reports": records},
|
|
)
|
|
}
|
|
|
|
func fetchReportPublicity(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
publicity, err := service.ReportService.AssembleReportPublicity(requestReportId)
|
|
if err != nil {
|
|
if nfErr, ok := err.(exceptions.NotFoundError); ok {
|
|
result.NotFound(nfErr.Error())
|
|
return
|
|
} else {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
}
|
|
result.Success("已经取得指定公示报表的发布版本。", tools.ConvertStructToMap(publicity))
|
|
}
|
|
|
|
func calculateReport(c *gin.Context) {
|
|
result := response.NewResult(c)
|
|
requestReportId := c.Param("rid")
|
|
if !ensureReportBelongs(c, result, requestReportId) {
|
|
return
|
|
}
|
|
err := service.CalculateService.ComprehensivelyCalculateReport(requestReportId)
|
|
if err != nil {
|
|
result.Error(http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
result.Success("指定公示报表中的数据已经计算完毕。")
|
|
}
|