pm/controllers/material/bid/order.go

package bid

import (
	"strings"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/param/material"
	bidParam "zhiyuan/pkg/param/material/bid"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
	"zhiyuan/services/material/bid"
	"zhiyuan/services/material/pkg"
	"zhiyuan/services/structs"

	"github.com/gin-gonic/gin"
)

func OrderAdd(c *gin.Context) {
	var form form.MaterialBidOrderAdd
	if app.Bind(c, &form) != nil {
		return
	}
	form.AdminID = c.GetInt("adminID")
	id, err := bid.AddOrder(form)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, gin.H{"id": id})
}

func OrderEdit(c *gin.Context) {
	orderID := utils.StrTo(c.Param("id")).MustInt()
	if orderID <= 0 {
		app.Error(c, "订单 id 有误")
		return
	}
	var form form.MaterialBidOrderAdd
	if app.Bind(c, &form) != nil {
		return
	}
	id, err := bid.EditOrder(form, orderID)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, gin.H{"id": id})
}

func OrderDel(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "订单 id 有误")
		return
	}
	if err := bid.DelOrder(id); err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderList(c *gin.Context) {
	page := app.HandlePageNum(c)
	where := map[string]interface{}{"_orderby": "id desc", "admin_id": c.GetInt("adminID"), "deleted_at": 0}
	if state := utils.ToInt(c.Query("state")); state >= 0 {
		where["state"] = state
	}
	if area := utils.ToInt(c.Query("area")); area >= 0 {
		areaMap := bidParam.GetAreaMap()
		where["house_area >"] = areaMap[area].Min
		where["house_area <="] = areaMap[area].Max
	}
	if keyword := c.Query("keyword"); keyword != "" {
		if _, err := utils.StrTo(keyword).Float64(); err == nil {
			where["_or"] = []map[string]interface{}{
				{"customer_phone like": "%" + keyword + "%"},
				{"house_address like": "%" + keyword + "%"},
			}
		} else {
			where["_or"] = []map[string]interface{}{
				{"customer_name like": "%" + keyword + "%"},
				{"house_address like": "%" + keyword + "%"},
			}
		}
	}
	orderList := make([]structs.MaterialBidOrderList, 0)
	if _, err := bid.GetOrders(where, nil, page, &orderList); err != nil {
		app.Error(c, err.Error())
		return
	}
	pkgMap := make(map[int]string)
	if pkgList, _ := pkg.GetPkgs(nil, []string{"id, pkg_name"}, app.Page{}, nil); pkgList != nil {
		for _, v := range pkgList {
			pkgMap[v.ID] = v.PkgName
		}
	}
	roomTypeMap := material.GetRoomTypeMap(true)
	orderStatusMap := bidParam.GetOrderStateMap()
	for k, v := range orderList {
		if pkgName, ok := pkgMap[v.PkgID]; ok {
			v.PkgName = pkgName
		}
		v.StateName = orderStatusMap[v.State].Name
		v.StateColor = orderStatusMap[v.State].Color
		v.Auth = structs.MaterialBidOrderAuth{
			Edit: utils.IsContain(bidParam.OrderAllow.Edit, v.State),
		}
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD HH:mm")
		styleName := make([]string, 0)
		var houseStyle []structs.HouseStyle
		utils.JsonDecode(v.HouseStyle).To(&houseStyle)
		for _, house := range houseStyle {
			styleName = append(styleName, utils.ToStr(house.Num)+roomTypeMap[house.Type])
		}
		v.HouseStyle = strings.Join(styleName, "")
		orderList[k] = v
	}
	app.Success(c, orderList)
}

func OrderInfo(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.Error(c, "工单 id 为空")
	}
	var orderInfo structs.MaterialBidOrderList
	if _, err := bid.GetOrder(map[string]interface{}{"id": id}, nil, &orderInfo); err != nil {
		app.Error(c, err.Error())
	}
	roomTypeMap := material.GetRoomTypeMap(true)
	var houseStyle []structs.HouseStyle
	utils.JsonDecode(orderInfo.HouseStyle).To(&houseStyle)
	styleName := make([]string, 0)
	for _, house := range houseStyle {
		styleName = append(styleName, utils.ToStr(house.Num)+roomTypeMap[house.Type])
	}
	orderInfo.RoomText = strings.Join(styleName, "")
	utils.JsonDecode(orderInfo.HouseStyle).To(&orderInfo.HouseStyleDecode)
	utils.JsonDecode(orderInfo.Param).To(&orderInfo.ParamDecode)
	utils.JsonDecode(orderInfo.Customize).To(&orderInfo.CustomizeDecode)
	utils.JsonDecode(orderInfo.CustomizePriceDetail).To(&orderInfo.CustomizePriceDecode)
	utils.JsonDecode(orderInfo.PackagePriceDetail).To(&orderInfo.PackagePriceDecode)
	utils.JsonDecode(orderInfo.InclusivePriceDetail).To(&orderInfo.InclusivePriceDecode)
	utils.JsonDecode(orderInfo.ToiletPriceDetail).To(&orderInfo.ToiletPriceDecode)
	bidMap := make(map[int]*structs.MaterialBidList)
	bidList := make([]*structs.MaterialBidList, 0)
	if _, err := bid.GetBidList(map[string]interface{}{"pkg_id": orderInfo.PkgID}, nil, app.Page{}, &bidList); err == nil {
		for _, v := range bidList {
			bidMap[v.ID] = v
		}
	}
	app.Success(c, gin.H{
		"orderInfo": orderInfo,
		"bidList":   bidMap,
	})
}