refactor(controller):完成部分控制器向fiber框架的迁移。

controller/abstract.go

@@ -4,12 +4,12 @@ import (
 	"electricity_bill_calc/exceptions"
 	"electricity_bill_calc/model"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 )
 
-func _retreiveSession(c *gin.Context) (*model.Session, error) {
+func _retreiveSession(c *fiber.Ctx) (*model.Session, error) {
-	session, exists := c.Get("session")
+	session := c.Locals("session")
-	if !exists {
+	if session == nil {
 		return nil, exceptions.NewUnauthorizedError("用户会话不存在")
 	}
 	userSession, ok := session.(*model.Session)

controller/charge.go

@@ -80,7 +80,7 @@ func modifyChargeState(c *fiber.Ctx) error {
 	if err := c.BodyParser(formData); err != nil {
 		return result.UnableToParse("无法解析提交的数据。")
 	}
-	requestUserID := c.Params("uid", "")
+	requestUserID := c.Params("uid")
 	requestChargeSeq, err := strconv.Atoi(c.Params("seq", "-1"))
 	if err != nil || requestChargeSeq == -1 {
 		return result.Error(http.StatusNotAcceptable, "参数[记录流水号]解析错误。")

controller/end_user.go

@@ -12,77 +12,70 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 	"github.com/samber/lo"
 	"github.com/shopspring/decimal"
 )
 
-func InitializeEndUserController(router *gin.Engine) {
+func InitializeEndUserController(router *fiber.App) {
-	router.GET("/report/:rid/submeter", security.EnterpriseAuthorize, fetchEndUserInReport)
+	router.Get("/report/:rid/submeter", security.EnterpriseAuthorize, fetchEndUserInReport)
-	router.GET("/report/:rid/meter/template", downloadEndUserRegisterTemplate)
+	router.Get("/report/:rid/meter/template", downloadEndUserRegisterTemplate)
-	router.POST("/report/:rid/meter/batch", security.EnterpriseAuthorize, uploadEndUserRegisterTemplate)
+	router.Post("/report/:rid/meter/batch", security.EnterpriseAuthorize, uploadEndUserRegisterTemplate)
-	router.PUT("/report/:rid/submeter/:pid/:mid", security.EnterpriseAuthorize, modifyEndUserRegisterRecord)
+	router.Put("/report/:rid/submeter/:pid/:mid", security.EnterpriseAuthorize, modifyEndUserRegisterRecord)
-	router.GET("/end/user/adjusts", security.MustAuthenticated, statEndUserInPeriod)
+	router.Get("/end/user/adjusts", security.MustAuthenticated, statEndUserInPeriod)
 }
 
-func fetchEndUserInReport(c *gin.Context) {
+func fetchEndUserInReport(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
-	keyword := c.DefaultQuery("keyword", "")
+	keyword := c.Query("keyword")
-	requestPage, err := strconv.Atoi(c.DefaultQuery("page", "1"))
+	requestPage, err := strconv.Atoi(c.Query("page", "1"))
 	if err != nil {
-		result.NotAccept("查询参数[page]格式不正确。")
+		return result.NotAccept("查询参数[page]格式不正确。")
-		return
 	}
 	endUsers, totalItem, err := service.EndUserService.SearchEndUserRecord(requestReportId, keyword, requestPage)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
-	result.Json(
+	return result.Json(
 		http.StatusOK,
 		"已获取到符合条件的终端用户集合",
 		response.NewPagedResponse(requestPage, totalItem).ToMap(),
-		gin.H{"meters": endUsers},
+		fiber.Map{"meters": endUsers},
 	)
 }
 
-func downloadEndUserRegisterTemplate(c *gin.Context) {
+func downloadEndUserRegisterTemplate(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
 	users, err := service.EndUserService.AllEndUserRecord(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	reportIndex, err := service.ReportService.RetreiveReportIndex(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	park, err := service.ParkService.FetchParkDetail(reportIndex.ParkId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	meterType, err := service.ReportService.RetreiveParkEndUserMeterType(requestReportId)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 
 	if meterType == -1 {
-		result.NotFound("未能确定用户表计类型。")
+		return result.NotFound("未能确定用户表计类型。")
-		return
 	}
 
 	c.Status(http.StatusOK)
-	c.Header("Content-Type", "application/octet-stream")
+	c.Set("Content-Type", "application/octet-stream")
-	c.Header("Content-Transfer-Encoding", "binary")
+	c.Set("Content-Transfer-Encoding", "binary")
-	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=抄表记录-%s-%s.xlsx", park.Name, reportIndex.Period.Format("2006-01")))
+	c.Set("Content-Disposition", fmt.Sprintf("attachment; filename=抄表记录-%s-%s.xlsx", park.Name, reportIndex.Period.Format("2006-01")))
 
 	gen := lo.Ternary[excel.ExcelTemplateGenerator](
 		meterType == 0,
@@ -91,50 +84,45 @@ func downloadEndUserRegisterTemplate(c *gin.Context) {
 	)
 	defer gen.Close()
 	gen.WriteMeterData(users)
-	gen.WriteTo(c.Writer)
+	gen.WriteTo(c.Response().BodyWriter())
+	return nil
 }
 
-func uploadEndUserRegisterTemplate(c *gin.Context) {
+func uploadEndUserRegisterTemplate(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	meterType, err := service.ReportService.RetreiveParkEndUserMeterType(requestReportId)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if meterType == -1 {
-		result.NotFound("未能确定用户表计类型。")
+		return result.NotFound("未能确定用户表计类型。")
-		return
 	}
 
 	uploadedFile, err := c.FormFile("data")
 	if err != nil {
-		result.NotAccept("没有接收到上传的档案文件。")
+		return result.NotAccept("没有接收到上传的档案文件。")
-		return
 	}
 	archiveFile, err := uploadedFile.Open()
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 
 	if meterType == 0 {
 		errs := service.EndUserService.BatchImportNonPVRegister(requestReportId, archiveFile)
 		if errs.Len() > 0 {
-			result.Json(http.StatusInternalServerError, "上传抄表文件存在解析错误", gin.H{"errors": errs.Errs})
+			return result.Json(http.StatusInternalServerError, "上传抄表文件存在解析错误", fiber.Map{"errors": errs.Errs})
-			return
 		}
 	} else {
 		errs := service.EndUserService.BatchImportPVRegister(requestReportId, archiveFile)
 		if errs.Len() > 0 {
-			result.Json(http.StatusInternalServerError, "上传抄表文件存在解析错误", gin.H{"errors": errs.Errs})
+			return result.Json(http.StatusInternalServerError, "上传抄表文件存在解析错误", fiber.Map{"errors": errs.Errs})
-			return
 		}
 	}
-	result.Json(http.StatusOK, "已经成功完成抄表记录的导入。", gin.H{"errors": make([]error, 0)})
+	return result.Json(http.StatusOK, "已经成功完成抄表记录的导入。", fiber.Map{"errors": make([]error, 0)})
 }
 
 type ModifyEndUserRegisterFormData struct {
@@ -148,29 +136,28 @@ type ModifyEndUserRegisterFormData struct {
 	AdjustValley          decimal.NullDecimal `json:"adjustValley" form:"adjustValley"`
 }
 
-func modifyEndUserRegisterRecord(c *gin.Context) {
+func modifyEndUserRegisterRecord(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	meterType, err := service.ReportService.RetreiveParkEndUserMeterType(requestReportId)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if meterType == -1 {
-		result.NotFound("未能确定用户表计类型。")
+		return result.NotFound("未能确定用户表计类型。")
-		return
 	}
-	requestParkId := c.Param("pid")
+	requestParkId := c.Params("pid")
-	requestMeterId := c.Param("mid")
+	requestMeterId := c.Params("mid")
 	formData := new(ModifyEndUserRegisterFormData)
-	c.BindJSON(formData)
+	if err := c.BodyParser(formData); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	meter, err := service.EndUserService.FetchSpecificEndUserRecord(requestReportId, requestParkId, requestMeterId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	if formData.CurrentPeriodOverall.Valid {
 		meter.CurrentPeriodOverall = formData.CurrentPeriodOverall.Decimal
@@ -198,61 +185,53 @@ func modifyEndUserRegisterRecord(c *gin.Context) {
 	}
 	valid, err := meter.Validate()
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if !valid {
-		result.NotAccept("抄表数据合法性验证失败。")
+		return result.NotAccept("抄表数据合法性验证失败。")
-		return
 	}
 	ctx, cancel := global.TimeoutContext()
 	defer cancel()
 	tx, err := global.DB.BeginTx(ctx, &sql.TxOptions{})
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	err = service.EndUserService.UpdateEndUserRegisterRecord(&tx, &ctx, *meter)
 	if err != nil {
 		tx.Rollback()
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	err = tx.Commit()
 	if err != nil {
 		tx.Rollback()
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Success("指定终端用户抄表记录已经更新。")
+	return result.Success("指定终端用户抄表记录已经更新。")
 }
 
-func statEndUserInPeriod(c *gin.Context) {
+func statEndUserInPeriod(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	session, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return result.Unauthorized(err.Error())
-		return
 	}
 	requestUser := lo.
 		If(session.Type == model.USER_TYPE_ENT, session.Uid).
-		Else(c.DefaultQuery("user", ""))
+		Else(c.Query("user"))
-	requestPark := c.DefaultQuery("park", "")
+	requestPark := c.Query("park")
 	if len(requestPark) > 0 && session.Type == model.USER_TYPE_ENT {
-		if !ensureParkBelongs(c, result, requestPark) {
+		if ensure, err := ensureParkBelongs(c, &result, requestPark); !ensure {
-			result.Unauthorized("不能获取不属于自己的园区。")
+			return err
-			return
 		}
 	}
-	startDate := c.DefaultQuery("start", "")
+	startDate := c.Query("start")
-	endDate := c.DefaultQuery("end", "")
+	endDate := c.Query("end")
 	stat, err := service.EndUserService.StatEndUserRecordInPeriod(requestUser, requestPark, startDate, endDate)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Success(
+	return result.Success(
 		"已经完成终端用户的费用统计",
-		gin.H{"details": stat},
+		fiber.Map{"details": stat},
 	)
 }

controller/region.go

@@ -5,40 +5,36 @@ import (
 	"electricity_bill_calc/service"
 	"net/http"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 )
 
-func InitializeRegionController(router *gin.Engine) {
+func InitializeRegionController(router *fiber.App) {
-	router.GET("/region/:rid", fetchRegions)
+	router.Get("/region/:rid", fetchRegions)
-	router.GET("/regions/:rid", fetchAllLeveledRegions)
+	router.Get("/regions/:rid", fetchAllLeveledRegions)
 }
 
-func fetchRegions(c *gin.Context) {
+func fetchRegions(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestParentId := c.Param("rid")
+	requestParentId := c.Params("rid")
 	regions, err := service.RegionService.FetchSubRegions(requestParentId)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if len(regions) == 0 {
-		result.Json(http.StatusNotFound, "未能获取到相关的行政区划。", gin.H{"regions": make([]string, 0)})
+		return result.Json(http.StatusNotFound, "未能获取到相关的行政区划。", fiber.Map{"regions": make([]string, 0)})
-		return
 	}
-	result.Json(http.StatusOK, "已经获取到相关的行政区划。", gin.H{"regions": regions})
+	return result.Json(http.StatusOK, "已经获取到相关的行政区划。", fiber.Map{"regions": regions})
 }
 
-func fetchAllLeveledRegions(c *gin.Context) {
+func fetchAllLeveledRegions(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestRegionCode := c.Param("rid")
+	requestRegionCode := c.Params("rid")
 	regions, err := service.RegionService.FetchAllParentRegions(requestRegionCode)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if len(regions) == 0 {
-		result.Json(http.StatusNotFound, "未能获取到相关的行政区划。", gin.H{"regions": make([]string, 0)})
+		return result.Json(http.StatusNotFound, "未能获取到相关的行政区划。", fiber.Map{"regions": make([]string, 0)})
-		return
 	}
-	result.Json(http.StatusOK, "以及获取到相关的行政区划。", gin.H{"regions": regions})
+	return result.Json(http.StatusOK, "以及获取到相关的行政区划。", fiber.Map{"regions": regions})
 }

controller/report.go

@@ -11,124 +11,111 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 	"github.com/jinzhu/copier"
 	"github.com/samber/lo"
 	"github.com/shopspring/decimal"
 )
 
-func InitializeReportController(router *gin.Engine) {
+func InitializeReportController(router *fiber.App) {
-	router.GET("/reports/with/drafts", security.EnterpriseAuthorize, fetchNewestReportOfParkWithDraft)
+	router.Get("/reports/with/drafts", security.EnterpriseAuthorize, fetchNewestReportOfParkWithDraft)
-	router.POST("/park/:pid/report", security.EnterpriseAuthorize, initializeNewReport)
+	router.Post("/park/:pid/report", security.EnterpriseAuthorize, initializeNewReport)
-	router.GET("/report/:rid/step/state", security.EnterpriseAuthorize, fetchReportStepStates)
+	router.Get("/report/:rid/step/state", security.EnterpriseAuthorize, fetchReportStepStates)
-	router.GET("/report/:rid/summary", security.EnterpriseAuthorize, fetchReportParkSummary)
+	router.Get("/report/:rid/summary", security.EnterpriseAuthorize, fetchReportParkSummary)
-	router.PUT("/report/:rid/summary", security.EnterpriseAuthorize, fillReportSummary)
+	router.Put("/report/:rid/summary", security.EnterpriseAuthorize, fillReportSummary)
-	router.GET("/report/:rid/summary/calculate", security.EnterpriseAuthorize, testCalculateReportSummary)
+	router.Get("/report/:rid/summary/calculate", security.EnterpriseAuthorize, testCalculateReportSummary)
-	router.POST("/report/:rid/summary/calculate", security.EnterpriseAuthorize, progressReportSummary)
+	router.Post("/report/:rid/summary/calculate", security.EnterpriseAuthorize, progressReportSummary)
-	router.PUT("/report/:rid/step/meter/register", security.EnterpriseAuthorize, progressEndUserRegister)
+	router.Put("/report/:rid/step/meter/register", security.EnterpriseAuthorize, progressEndUserRegister)
-	router.POST("/report/:rid/publish", security.EnterpriseAuthorize, publishReport)
+	router.Post("/report/:rid/publish", security.EnterpriseAuthorize, publishReport)
-	router.GET("/reports", security.MustAuthenticated, searchReports)
+	router.Get("/reports", security.MustAuthenticated, searchReports)
-	router.GET("/report/:rid", security.MustAuthenticated, fetchReportPublicity)
+	router.Get("/report/:rid", security.MustAuthenticated, fetchReportPublicity)
-	router.POST("/report/:rid/calculate", security.EnterpriseAuthorize, calculateReport)
+	router.Post("/report/:rid/calculate", security.EnterpriseAuthorize, calculateReport)
 }
 
-func ensureReportBelongs(c *gin.Context, result *response.Result, requestReportId string) bool {
+func ensureReportBelongs(c *fiber.Ctx, result *response.Result, requestReportId string) (bool, error) {
 	_, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return false, result.Unauthorized(err.Error())
-		return false
 	}
 	requestReport, err := service.ReportService.RetreiveReportIndex(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return false, result.NotFound(err.Error())
-		return false
 	}
 	if requestReport == nil {
-		result.NotFound("指定报表未能找到。")
+		return false, result.NotFound("指定报表未能找到。")
-		return false
 	}
 	return ensureParkBelongs(c, result, requestReport.ParkId)
 }
 
-func fetchNewestReportOfParkWithDraft(c *gin.Context) {
+func fetchNewestReportOfParkWithDraft(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	userSession, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return result.Unauthorized(err.Error())
-		return
 	}
 	parks, err := service.ReportService.FetchParksWithNewestReport(userSession.Uid)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Json(http.StatusOK, "已获取到指定用户下所有园区的最新报表记录。", gin.H{"parks": parks})
+	return result.Json(http.StatusOK, "已获取到指定用户下所有园区的最新报表记录。", fiber.Map{"parks": parks})
 }
 
-func initializeNewReport(c *gin.Context) {
+func initializeNewReport(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestParkId := c.Param("pid")
+	requestParkId := c.Params("pid")
 	userSession, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return result.Unauthorized(err.Error())
-		return
 	}
-	if !ensureParkBelongs(c, result, requestParkId) {
+	if ensure, err := ensureParkBelongs(c, &result, requestParkId); !ensure {
-		return
+		return err
 	}
 	requestPeriod := c.Query("period")
 	reportPeriod, err := time.Parse("2006-01", requestPeriod)
 	if err != nil {
-		result.NotAccept("提供的初始化期数格式不正确。")
+		return result.NotAccept("提供的初始化期数格式不正确。")
-		return
 	}
 	valid, err := service.ReportService.IsNewPeriodValid(userSession.Uid, requestParkId, reportPeriod)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if !valid {
-		result.NotAccept("只能初始化已发布报表下一个月份的新报表。")
+		return result.NotAccept("只能初始化已发布报表下一个月份的新报表。")
-		return
 	}
 	newId, err := service.ReportService.InitializeNewReport(requestParkId, reportPeriod)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Created("新一期报表初始化成功。", gin.H{"reportId": newId})
+	return result.Created("新一期报表初始化成功。", fiber.Map{"reportId": newId})
 }
 
-func fetchReportStepStates(c *gin.Context) {
+func fetchReportStepStates(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	requestReport, err := service.ReportService.RetreiveReportIndex(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
-	result.Json(http.StatusOK, "已经获取到指定报表的填写状态。", gin.H{"steps": requestReport.StepState})
+	return result.Json(http.StatusOK, "已经获取到指定报表的填写状态。", fiber.Map{"steps": requestReport.StepState})
 }
 
-func fetchReportParkSummary(c *gin.Context) {
+func fetchReportParkSummary(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	if summary == nil {
-		result.NotFound("指定报表未能找到。")
+		return result.NotFound("指定报表未能找到。")
-		return
 	}
-	result.Json(http.StatusOK, "已经获取到指定报表中的园区概况。", gin.H{"summary": summary})
+	return result.Json(http.StatusOK, "已经获取到指定报表中的园区概况。", fiber.Map{"summary": summary})
 }
 
 type ReportSummaryFormData struct {
@@ -144,176 +131,171 @@ type ReportSummaryFormData struct {
 	AdjustFee   decimal.Decimal `json:"adjustFee" from:"adjustFee"`
 }
 
-func fillReportSummary(c *gin.Context) {
+func fillReportSummary(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	formData := new(ReportSummaryFormData)
-	c.BindJSON(formData)
+	if err := c.BodyParser(formData); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	originSummary, err := service.ReportService.RetreiveReportSummary(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return 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.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Updated("指定电费公示报表中的园区概况基本数据已经完成更新。")
+	return result.Updated("指定电费公示报表中的园区概况基本数据已经完成更新。")
 }
 
-func testCalculateReportSummary(c *gin.Context) {
+func testCalculateReportSummary(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return 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", "consumptionFee"})})
+	return result.Json(
+		http.StatusOK,
+		"已完成园区概况的试计算。",
+		fiber.Map{
+			"result": lo.PickByKeys(
+				calcResults,
+				[]string{"overallPrice", "criticalPrice", "peakPrice", "flat", "flatFee", "flatPrice", "valleyPrice", "consumptionFee"},
+			),
+		},
+	)
 }
 
-func progressReportSummary(c *gin.Context) {
+func progressReportSummary(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	err := service.ReportService.CalculateSummaryAndFinishStep(requestReportId)
 	if err != nil {
 		if nfErr, ok := err.(exceptions.NotFoundError); ok {
-			result.NotFound(nfErr.Error())
+			return result.NotFound(nfErr.Error())
 		} else {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
 		}
-		return
 	}
-	result.Success("已经完成园区概况的计算，并可以进行到下一步骤。")
+	return result.Success("已经完成园区概况的计算，并可以进行到下一步骤。")
 }
 
-func progressEndUserRegister(c *gin.Context) {
+func progressEndUserRegister(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	err = service.ReportService.ProgressReportRegisterEndUser(*report)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Success("终端用户抄表编辑步骤已经完成。")
+	return result.Success("终端用户抄表编辑步骤已经完成。")
 }
 
-func publishReport(c *gin.Context) {
+func publishReport(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
 	err = service.ReportService.PublishReport(*report)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Success("指定的公示报表已经发布。")
+	return result.Success("指定的公示报表已经发布。")
 }
 
-func searchReports(c *gin.Context) {
+func searchReports(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	session, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return result.Unauthorized(err.Error())
-		return
 	}
 	requestUser := lo.
 		If(session.Type == model.USER_TYPE_ENT, session.Uid).
-		Else(c.DefaultQuery("user", ""))
+		Else(c.Query("user"))
-	requestPark := c.DefaultQuery("park", "")
+	requestPark := c.Query("park")
 	if len(requestPark) > 0 && session.Type == model.USER_TYPE_ENT {
-		if !ensureParkBelongs(c, result, requestPark) {
+		if ensure, err := ensureParkBelongs(c, &result, requestPark); !ensure {
-			return
+			return err
 		}
 	}
-	requestPeriodString := c.DefaultQuery("period", "")
+	requestPeriodString := c.Query("period")
 	var requestPeriod *time.Time = nil
 	if len(requestPeriodString) > 0 {
 		parsedPeriod, err := time.Parse("2006-01", requestPeriodString)
 		if err != nil {
-			result.NotAccept("参数[period]的格式不正确。")
+			return result.NotAccept("参数[period]的格式不正确。")
-			return
 		}
 		requestPeriod = lo.ToPtr(parsedPeriod)
 	}
-	requestKeyword := c.DefaultQuery("keyword", "")
+	requestKeyword := c.Query("keyword")
-	requestPage, err := strconv.Atoi(c.DefaultQuery("page", "1"))
+	requestPage, err := strconv.Atoi(c.Query("page", "1"))
 	if err != nil {
-		result.NotAccept("查询参数[page]格式不正确。")
+		return result.NotAccept("查询参数[page]格式不正确。")
-		return
 	}
-	requestAllReports, err := strconv.ParseBool(c.DefaultQuery("all", "false"))
+	requestAllReports, err := strconv.ParseBool(c.Query("all", "false"))
 	if err != nil {
-		result.NotAccept("查询参数[all]格式不正确。")
+		return result.NotAccept("查询参数[all]格式不正确。")
-		return
 	}
 	records, totalItems, err := service.ReportService.SearchReport(requestUser, requestPark, requestKeyword, requestPeriod, requestPage, !requestAllReports)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
-	result.Success(
+	return result.Success(
 		"已经取得符合条件的公示报表记录。",
 		response.NewPagedResponse(requestPage, totalItems).ToMap(),
-		gin.H{"reports": records},
+		fiber.Map{"reports": records},
 	)
 }
 
-func fetchReportPublicity(c *gin.Context) {
+func fetchReportPublicity(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
 	publicity, err := service.ReportService.AssembleReportPublicity(requestReportId)
 	if err != nil {
 		if nfErr, ok := err.(exceptions.NotFoundError); ok {
-			result.NotFound(nfErr.Error())
+			return result.NotFound(nfErr.Error())
-			return
 		} else {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 	}
-	result.Success("已经取得指定公示报表的发布版本。", tools.ConvertStructToMap(publicity))
+	return result.Success("已经取得指定公示报表的发布版本。", tools.ConvertStructToMap(publicity))
 }
 
-func calculateReport(c *gin.Context) {
+func calculateReport(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	err := service.CalculateService.ComprehensivelyCalculateReport(requestReportId)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Success("指定公示报表中的数据已经计算完毕。")
+	return result.Success("指定公示报表中的数据已经计算完毕。")
 }

controller/statistics.go

@@ -7,34 +7,32 @@ import (
 	"electricity_bill_calc/service"
 	"net/http"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 )
 
-func InitializeStatisticsController(router *gin.Engine) {
+func InitializeStatisticsController(router *fiber.App) {
-	router.GET("/audits", security.OPSAuthorize, currentAuditAmount)
+	router.Get("/audits", security.OPSAuthorize, currentAuditAmount)
-	router.GET("/stat/reports", security.MustAuthenticated, statReports)
+	router.Get("/stat/reports", security.MustAuthenticated, statReports)
 }
 
-func currentAuditAmount(c *gin.Context) {
+func currentAuditAmount(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	amount, err := service.WithdrawService.AuditWaits()
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Json(http.StatusOK, "已经获取到指定的统计信息。", gin.H{
+	return result.Json(http.StatusOK, "已经获取到指定的统计信息。", fiber.Map{
 		"amounts": map[string]int64{
 			"withdraw": amount,
 		},
 	})
 }
 
-func statReports(c *gin.Context) {
+func statReports(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	session, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return result.Unauthorized(err.Error())
-		return
 	}
 	var (
 		enterprises int64 = 0
@@ -44,34 +42,29 @@ func statReports(c *gin.Context) {
 	if session.Type != 0 {
 		enterprises, err = service.StatisticsService.EnabledEnterprises()
 		if err != nil {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 		parks, err = service.StatisticsService.EnabledParks()
 		if err != nil {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 		reports, err = service.StatisticsService.ParksNewestState()
 		if err != nil {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 	} else {
 		parks, err = service.StatisticsService.EnabledParks(session.Uid)
 		if err != nil {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 		reports, err = service.StatisticsService.ParksNewestState(session.Uid)
 		if err != nil {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 	}
 
-	result.Json(http.StatusOK, "已经完成园区报告的统计。", gin.H{
+	return result.Json(http.StatusOK, "已经完成园区报告的统计。", fiber.Map{
-		"statistics": gin.H{
+		"statistics": fiber.Map{
 			"enterprises": enterprises,
 			"parks":       parks,
 			"reports":     reports,

controller/user.go

@@ -13,23 +13,23 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 	"github.com/shopspring/decimal"
 )
 
-func InitializeUserController(router *gin.Engine) {
+func InitializeUserController(router *fiber.App) {
-	router.DELETE("/password/:uid", security.OPSAuthorize, invalidUserPassword)
+	router.Delete("/password/:uid", security.OPSAuthorize, invalidUserPassword)
-	router.DELETE("/login", security.MustAuthenticated, logout)
+	router.Delete("/login", security.MustAuthenticated, logout)
-	router.PUT("/password", resetUserPassword)
+	router.Put("/password", resetUserPassword)
-	router.GET("/accounts", security.OPSAuthorize, listPagedUser)
+	router.Get("/accounts", security.OPSAuthorize, listPagedUser)
-	router.POST("/login", login)
+	router.Post("/login", login)
-	router.PUT("/account/enabled/state", security.OPSAuthorize, switchUserEnabling)
+	router.Put("/account/enabled/state", security.OPSAuthorize, switchUserEnabling)
-	router.POST("/account", security.OPSAuthorize, createOPSAndManagementAccount)
+	router.Post("/account", security.OPSAuthorize, createOPSAndManagementAccount)
-	router.GET("/account/:uid", security.MustAuthenticated, getUserDetail)
+	router.Get("/account/:uid", security.MustAuthenticated, getUserDetail)
-	router.POST("/enterprise", security.OPSAuthorize, createEnterpriseAccount)
+	router.Post("/enterprise", security.OPSAuthorize, createEnterpriseAccount)
-	router.PUT("/account/:uid", security.OPSAuthorize, modifyAccountDetail)
+	router.Put("/account/:uid", security.OPSAuthorize, modifyAccountDetail)
-	router.GET("/enterprise/quick/search", security.OPSAuthorize, quickSearchEnterprise)
+	router.Get("/enterprise/quick/search", security.OPSAuthorize, quickSearchEnterprise)
-	router.GET("/expiration", security.EnterpriseAuthorize, fetchExpiration)
+	router.Get("/expiration", security.EnterpriseAuthorize, fetchExpiration)
 }
 
 type _LoginFormData struct {
@@ -38,16 +38,15 @@ type _LoginFormData struct {
 	Type     int8   `json:"type"`
 }
 
-func login(c *gin.Context) {
+func login(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	loginData := new(_LoginFormData)
-	err := c.BindJSON(loginData)
+	if err := c.BodyParser(loginData); err != nil {
-	if err != nil {
+		return result.Error(http.StatusInternalServerError, "表单解析失败。")
-		result.Error(http.StatusInternalServerError, "表单解析失败。")
-		return
 	}
 	var (
 		session *model.Session
+		err     error
 	)
 	if loginData.Type == model.USER_TYPE_ENT {
 		session, err = service.UserService.ProcessEnterpriseUserLogin(loginData.Username, loginData.Password)
@@ -57,51 +56,43 @@ func login(c *gin.Context) {
 	if err != nil {
 		if authError, ok := err.(*exceptions.AuthenticationError); ok {
 			if authError.NeedReset {
-				result.LoginNeedReset()
+				return result.LoginNeedReset()
-				return
 			}
-			result.Error(int(authError.Code), authError.Message)
+			return result.Error(int(authError.Code), authError.Message)
-			return
 		} else {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 	}
-	result.LoginSuccess(session)
+	return result.LoginSuccess(session)
 }
 
-func logout(c *gin.Context) {
+func logout(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	session, exists := c.Get("session")
+	session := c.Locals("session")
-	if !exists {
+	if session == nil {
-		result.Success("用户会话已结束。")
+		return result.Success("用户会话已结束。")
-		return
 	}
 	_, err := cache.ClearSession(session.(*model.Session).Token)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Success("用户已成功登出系统。")
+	return result.Success("用户已成功登出系统。")
 }
 
-func invalidUserPassword(c *gin.Context) {
+func invalidUserPassword(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	targetUserId := c.Param("uid")
+	targetUserId := c.Params("uid")
 	verifyCode, err := service.UserService.InvalidUserPassword(targetUserId)
 	if _, ok := err.(exceptions.NotFoundError); ok {
-		result.NotFound("未找到指定用户。")
+		return result.NotFound("未找到指定用户。")
-		return
 	}
 	if _, ok := err.(exceptions.UnsuccessfulOperationError); ok {
-		result.NotAccept("未能成功更新用户的密码。")
+		return result.NotAccept("未能成功更新用户的密码。")
-		return
 	}
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Json(http.StatusAccepted, "用户密码已经失效", gin.H{"verify": verifyCode})
+	return result.Json(http.StatusAccepted, "用户密码已经失效", fiber.Map{"verify": verifyCode})
 }
 
 type _ResetPasswordFormData struct {
@@ -110,47 +101,42 @@ type _ResetPasswordFormData struct {
 	NewPassword string `json:"newPass"`
 }
 
-func resetUserPassword(c *gin.Context) {
+func resetUserPassword(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	resetForm := new(_ResetPasswordFormData)
-	c.BindJSON(resetForm)
+	if err := c.BodyParser(resetForm); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	verified, err := service.UserService.VerifyUserPassword(resetForm.Username, resetForm.VerifyCode)
 	if _, ok := err.(exceptions.NotFoundError); ok {
-		result.NotFound("指定的用户不存在。")
+		return result.NotFound("指定的用户不存在。")
-		return
 	}
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if !verified {
-		result.Error(http.StatusUnauthorized, "验证码不正确。")
+		return result.Error(http.StatusUnauthorized, "验证码不正确。")
-		return
 	}
 	completed, err := service.UserService.ResetUserPassword(resetForm.Username, resetForm.NewPassword)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	if completed {
-		result.Updated("用户凭据已更新。")
+		return result.Updated("用户凭据已更新。")
-		return
 	}
-	result.NotAccept("用户凭据未能成功更新。")
+	return result.NotAccept("用户凭据未能成功更新。")
 }
 
-func listPagedUser(c *gin.Context) {
+func listPagedUser(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestPage, err := strconv.Atoi(c.DefaultQuery("page", "1"))
+	requestPage, err := strconv.Atoi(c.Query("page", "1"))
 	if err != nil {
-		result.NotAccept("查询参数[page]格式不正确。")
+		return result.NotAccept("查询参数[page]格式不正确。")
-		return
 	}
-	requestKeyword := c.DefaultQuery("keyword", "")
+	requestKeyword := c.Query("keyword")
-	requestUserType, err := strconv.Atoi(c.DefaultQuery("type", "-1"))
+	requestUserType, err := strconv.Atoi(c.Query("type", "-1"))
 	if err != nil {
-		result.NotAccept("查询参数[type]格式不正确。")
+		return result.NotAccept("查询参数[type]格式不正确。")
-		return
 	}
 	var requestUserStat *bool
 	state, err := strconv.ParseBool(c.Query("state"))
@@ -161,14 +147,13 @@ func listPagedUser(c *gin.Context) {
 	}
 	users, total, err := service.UserService.ListUserDetail(requestKeyword, requestUserType, requestUserStat, requestPage)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
-	result.Json(
+	return result.Json(
 		http.StatusOK,
 		"已取得符合条件的用户集合。",
 		response.NewPagedResponse(requestPage, total).ToMap(),
-		gin.H{"accounts": users},
+		fiber.Map{"accounts": users},
 	)
 }
 
@@ -177,21 +162,21 @@ type _UserStateChangeFormData struct {
 	Enabled bool   `json:"enabled" form:"enabled"`
 }
 
-func switchUserEnabling(c *gin.Context) {
+func switchUserEnabling(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	switchForm := new(_UserStateChangeFormData)
-	c.BindJSON(switchForm)
+	if err := c.BodyParser(switchForm); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	err := service.UserService.SwitchUserState(switchForm.UserID, switchForm.Enabled)
 	if err != nil {
 		if nfErr, ok := err.(*exceptions.NotFoundError); ok {
-			result.NotFound(nfErr.Message)
+			return result.NotFound(nfErr.Message)
-			return
 		} else {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 	}
-	result.Updated("用户状态已经更新。")
+	return result.Updated("用户状态已经更新。")
 }
 
 type _OPSAccountCreationFormData struct {
@@ -202,18 +187,18 @@ type _OPSAccountCreationFormData struct {
 	Type     int     `json:"type" form:"type"`
 }
 
-func createOPSAndManagementAccount(c *gin.Context) {
+func createOPSAndManagementAccount(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	creationForm := new(_OPSAccountCreationFormData)
-	c.BindJSON(creationForm)
+	if err := c.BodyParser(creationForm); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	exists, err := service.UserService.IsUsernameExists(creationForm.Username)
 	if exists {
-		result.Conflict("指定的用户名已经被使用了。")
+		return result.Conflict("指定的用户名已经被使用了。")
-		return
 	}
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	newUser := new(model.User)
 	newUser.Username = creationForm.Username
@@ -227,30 +212,27 @@ func createOPSAndManagementAccount(c *gin.Context) {
 	newUserDetail.ServiceExpiration, _ = model.ParseDate("2099-12-31")
 	verifyCode, err := service.UserService.CreateUser(newUser, newUserDetail)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	cache.AbolishRelation("user")
-	result.Json(http.StatusCreated, "用户已经成功创建。", gin.H{"verify": verifyCode})
+	return result.Json(http.StatusCreated, "用户已经成功创建。", fiber.Map{"verify": verifyCode})
 }
 
-func getUserDetail(c *gin.Context) {
+func getUserDetail(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	targetUserId := c.Param("uid")
+	targetUserId := c.Params("uid")
 	exists, err := service.UserService.IsUserExists(targetUserId)
 	if !exists {
-		result.NotFound("指定的用户不存在。")
+		return result.NotFound("指定的用户不存在。")
-		return
 	}
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
 	}
 	userDetail, err := service.UserService.FetchUserDetail(targetUserId)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Json(http.StatusOK, "用户详细信息已获取到。", gin.H{"user": userDetail})
+	return result.Json(http.StatusOK, "用户详细信息已获取到。", fiber.Map{"user": userDetail})
 }
 
 type _EnterpriseCreationFormData struct {
@@ -263,18 +245,18 @@ type _EnterpriseCreationFormData struct {
 	UnitServiceFee *string `json:"unitServiceFee" form:"unitServiceFee"`
 }
 
-func createEnterpriseAccount(c *gin.Context) {
+func createEnterpriseAccount(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	creationForm := new(_EnterpriseCreationFormData)
-	c.BindJSON(creationForm)
+	if err := c.BodyParser(creationForm); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	exists, err := service.UserService.IsUsernameExists(creationForm.Username)
 	if exists {
-		result.Conflict("指定的用户名已经被使用了。")
+		return result.Conflict("指定的用户名已经被使用了。")
-		return
 	}
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	newUser := new(model.User)
 	newUser.Username = creationForm.Username
@@ -286,18 +268,16 @@ func createEnterpriseAccount(c *gin.Context) {
 	newUserDetail.Phone = creationForm.Phone
 	newUserDetail.UnitServiceFee, err = decimal.NewFromString(*creationForm.UnitServiceFee)
 	if err != nil {
-		result.BadRequest("用户月服务费无法解析。")
+		return result.BadRequest("用户月服务费无法解析。")
-		return
 	}
 	newUserDetail.ServiceExpiration = model.NewEmptyDate()
 
 	verifyCode, err := service.UserService.CreateUser(newUser, newUserDetail)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	cache.AbolishRelation("user")
-	result.Json(http.StatusCreated, "用户已经成功创建。", gin.H{"verify": verifyCode})
+	return result.Json(http.StatusCreated, "用户已经成功创建。", fiber.Map{"verify": verifyCode})
 }
 
 type _AccountModificationFormData struct {
@@ -309,19 +289,19 @@ type _AccountModificationFormData struct {
 	UnitServiceFee *string `json:"unitServiceFee" form:"unitServiceFee"`
 }
 
-func modifyAccountDetail(c *gin.Context) {
+func modifyAccountDetail(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	targetUserId := c.Param("uid")
+	targetUserId := c.Params("uid")
 	modForm := new(_AccountModificationFormData)
-	c.BindJSON(modForm)
+	if err := c.BodyParser(modForm); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	exists, err := service.UserService.IsUserExists(targetUserId)
 	if !exists {
-		result.NotFound("指定的用户不存在。")
+		return result.NotFound("指定的用户不存在。")
-		return
 	}
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	newUserInfo := new(model.UserDetail)
 	newUserInfo.Id = targetUserId
@@ -336,43 +316,42 @@ func modifyAccountDetail(c *gin.Context) {
 	newUserInfo.Phone = modForm.Phone
 	newUserInfo.UnitServiceFee, err = decimal.NewFromString(*modForm.UnitServiceFee)
 	if err != nil {
-		result.BadRequest("用户月服务费无法解析。")
+		return result.BadRequest("用户月服务费无法解析。")
-		return
 	}
 	_, err = global.DB.NewUpdate().Model(newUserInfo).
 		WherePK().
 		Column("name", "abbr", "region", "address", "contact", "phone", "unit_service_fee").
-		Exec(c)
+		Exec(c.Context())
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
 	cache.AbolishRelation(fmt.Sprintf("user:%s", targetUserId))
-	result.Updated("指定用户的信息已经更新。")
+	return result.Updated("指定用户的信息已经更新。")
 }
 
-func quickSearchEnterprise(c *gin.Context) {
+func quickSearchEnterprise(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	keyword := c.Query("keyword")
 	searchResult, err := service.UserService.SearchLimitUsers(keyword, 6)
 	if err != nil {
-		result.Error(http.StatusInternalServerError, err.Error())
+		return result.Error(http.StatusInternalServerError, err.Error())
-		return
 	}
-	result.Json(http.StatusOK, "已查询到存在符合条件的企业", gin.H{"users": searchResult})
+	return result.Json(http.StatusOK, "已查询到存在符合条件的企业", fiber.Map{"users": searchResult})
 }
 
-func fetchExpiration(c *gin.Context) {
+func fetchExpiration(c *fiber.Ctx) error {
 	result := response.NewResult(c)
 	session, err := _retreiveSession(c)
 	if err != nil {
-		result.Unauthorized(err.Error())
+		return result.Unauthorized(err.Error())
-		return
 	}
 	user, err := service.UserService.FetchUserDetail(session.Uid)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
-	result.Json(http.StatusOK, "已经取得用户的服务期限信息", gin.H{"expiration": user.ServiceExpiration.Format("2006-01-02")})
+	return result.Json(
+		http.StatusOK,
+		"已经取得用户的服务期限信息",
+		fiber.Map{"expiration": user.ServiceExpiration.Format("2006-01-02")},
+	)
 }

controller/withdraw.go

@@ -8,59 +8,53 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gofiber/fiber/v2"
 )
 
-func InitializeWithdrawController(router *gin.Engine) {
+func InitializeWithdrawController(router *fiber.App) {
-	router.DELETE("/publicity/:pid", security.EnterpriseAuthorize, applyReportWithdraw)
+	router.Delete("/publicity/:pid", security.EnterpriseAuthorize, applyReportWithdraw)
-	router.GET("/withdraws", security.OPSAuthorize, fetchWithdrawsWaitingAutdit)
+	router.Get("/withdraws", security.OPSAuthorize, fetchWithdrawsWaitingAutdit)
-	router.PUT("/withdraw/:rid", security.OPSAuthorize, auditWithdraw)
+	router.Put("/withdraw/:rid", security.OPSAuthorize, auditWithdraw)
 }
 
-func applyReportWithdraw(c *gin.Context) {
+func applyReportWithdraw(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("pid")
+	requestReportId := c.Params("pid")
-	if !ensureReportBelongs(c, result, requestReportId) {
+	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
-		return
+		return err
 	}
 	deleted, err := service.WithdrawService.ApplyWithdraw(requestReportId)
 	if err != nil {
 		if nfErr, ok := err.(exceptions.NotFoundError); ok {
-			result.NotFound(nfErr.Error())
+			return result.NotFound(nfErr.Error())
-			return
 		} else if ioErr, ok := err.(exceptions.ImproperOperateError); ok {
-			result.NotAccept(ioErr.Error())
+			return result.NotAccept(ioErr.Error())
-			return
 		} else {
-			result.Error(http.StatusInternalServerError, err.Error())
+			return result.Error(http.StatusInternalServerError, err.Error())
-			return
 		}
 	}
 	if !deleted {
-		result.Error(http.StatusInternalServerError, "未能完成公示报表的申请撤回操作。")
+		return result.Error(http.StatusInternalServerError, "未能完成公示报表的申请撤回操作。")
-		return
 	}
-	result.Success("指定的公示报表已经申请撤回。")
+	return result.Success("指定的公示报表已经申请撤回。")
 }
 
-func fetchWithdrawsWaitingAutdit(c *gin.Context) {
+func fetchWithdrawsWaitingAutdit(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	keyword := c.DefaultQuery("keyword", "")
+	keyword := c.Query("keyword")
-	requestPage, err := strconv.Atoi(c.DefaultQuery("page", "1"))
+	requestPage, err := strconv.Atoi(c.Query("page", "1"))
 	if err != nil {
-		result.NotAccept("查询参数[page]格式不正确。")
+		return result.NotAccept("查询参数[page]格式不正确。")
-		return
 	}
 	reports, totalitems, err := service.WithdrawService.FetchPagedWithdrawApplies(requestPage, keyword)
 	if err != nil {
-		result.NotFound(err.Error())
+		return result.NotFound(err.Error())
-		return
 	}
-	result.Json(
+	return result.Json(
 		http.StatusOK,
 		"已经取得符合条件的等待审核的撤回申请。",
 		response.NewPagedResponse(requestPage, totalitems).ToMap(),
-		gin.H{"records": reports},
+		fiber.Map{"records": reports},
 	)
 }
 
@@ -68,19 +62,20 @@ type WithdrawAuditFormData struct {
 	Audit bool `json:"audit" form:"audit"`
 }
 
-func auditWithdraw(c *gin.Context) {
+func auditWithdraw(c *fiber.Ctx) error {
 	result := response.NewResult(c)
-	requestReportId := c.Param("rid")
+	requestReportId := c.Params("rid")
 	formData := new(WithdrawAuditFormData)
-	c.BindJSON(formData)
+	if err := c.BodyParser(formData); err != nil {
+		return result.UnableToParse("无法解析提交的数据。")
+	}
 	err := service.WithdrawService.AuditWithdraw(requestReportId, formData.Audit)
 	if err != nil {
 		if nfErr, ok := err.(exceptions.NotFoundError); ok {
-			result.NotFound(nfErr.Error())
+			return result.NotFound(nfErr.Error())
 		} else {
-			result.NotAccept(err.Error())
+			return result.NotAccept(err.Error())
 		}
-		return
 	}
-	result.Success("指定公示报表的撤回申请已经完成审核")
+	return result.Success("指定公示报表的撤回申请已经完成审核")
 }

response/user_response.go

@@ -13,19 +13,19 @@ type LoginResponse struct {
 	Session   *model.Session `json:"session"`
 }
 
-func (r *Result) LoginSuccess(session *model.Session) {
+func (r Result) LoginSuccess(session *model.Session) error {
 	res := &LoginResponse{}
 	res.Code = http.StatusOK
 	res.Message = "用户已成功登录。"
 	res.NeedReset = false
 	res.Session = session
-	r.Ctx.Status(fiber.StatusOK).JSON(res)
+	return r.Ctx.Status(fiber.StatusOK).JSON(res)
 }
 
-func (r *Result) LoginNeedReset() {
+func (r Result) LoginNeedReset() error {
 	res := &LoginResponse{}
 	res.Code = http.StatusUnauthorized
 	res.Message = "用户凭据已失效。"
 	res.NeedReset = true
-	r.Ctx.Status(fiber.StatusOK).JSON(res)
+	return r.Ctx.Status(fiber.StatusOK).JSON(res)
 }