erp_server/app/admin/apis/dispatchmanage/dispatch.go

package dispatchmanage

import (
	"errors"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	model "go-admin/app/admin/models"
	orm "go-admin/common/global"
	"go-admin/tools/app"
	"net/http"
	"time"
)

func ErpDispatchTaskCreate(c *gin.Context) {
	req := struct {
		Sn          string `json:"sn"`
		FromStoreId uint32 `json:"from_store_id"`
		ToStoreId   uint32 `json:"to_store_id"`
		MakerId     uint32 `json:"maker_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	fromStore, err := model.GetStore(req.FromStoreId)
	if err != nil {
		logger.Error("from store err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}

	toStore, err := model.GetStore(req.ToStoreId)
	if err != nil {
		logger.Error("to store err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	userInfo, err := model.GetUserInfo(req.MakerId)
	if err != nil {
		logger.Error("user info err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	dispatchTask := &model.ErpDispatchTask{
		Sn:            model.NewErpDispatchTaskSn(),
		FromStoreId:   fromStore.ID,
		FromStoreName: fromStore.Name,
		ToStoreId:     toStore.ID,
		ToStoreName:   toStore.Name,
		MakerId:       userInfo.Uid,
		MakerName:     userInfo.ShopAssistantName,
		MakerTime:     time.Now(),
		AuditorId:     0,
		AuditorName:   "",
		AuditorTime:   time.Time{},
		State:         1,
	}

	err = orm.Eloquent.Create(dispatchTask).Error
	if err != nil {
		logger.Error("create commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}

	app.OK(c, dispatchTask, "")
	return
}

func ErpDispatchTaskList(c *gin.Context) {
	req := &model.DispatchTaskListReq{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	resp, err := req.List()
	if err != nil {
		logger.Error("erp dispatch task list err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, resp, "")
	return
}

func ErpDispatchTaskDetail(c *gin.Context) {
	req := struct {
		ErpDispatchTaskId uint32 `json:"erp_dispatch_task_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	var dispatchTask model.ErpDispatchTask
	qs := orm.Eloquent.Table("erp_dispatch_task")
	if req.ErpDispatchTaskId != 0 {
		qs = qs.Where("id=?", req.ErpDispatchTaskId)
	}
	err := qs.Find(&dispatchTask).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	var erpDispatchTaskCommodities []model.ErpDispatchTaskCommodity
	err = orm.Eloquent.Table("erp_dispatch_task_commodity").Where("dispatch_task_id=?", dispatchTask.ID).Find(&erpDispatchTaskCommodities).Error
	if err != nil {
		logger.Error("erp dispatch task commodities err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	dispatchTask.TaskCommodities = erpDispatchTaskCommodities

	app.OK(c, dispatchTask, "")
	return
}

func ErpDispatchTaskDel(c *gin.Context) {
	req := struct {
		ErpDispatchTaskId uint32 `json:"erp_dispatch_task_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	err := orm.Eloquent.Table("erp_dispatch_task").Where("id=?", req.ErpDispatchTaskId).Delete(&model.ErpDispatchTask{}).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, nil, "删除成功")
	return
}

func ErpDispatchTaskEdit(c *gin.Context) {
	req := struct {
		Id              uint32                           `json:"id" binding:"required"`
		Sn              string                           `json:"sn"`
		FromStoreId     uint32                           `json:"from_store_id"`
		ToStoreId       uint32                           `json:"to_store_id"`
		MakerId         uint32                           `json:"maker_id"`
		TaskCommodities []model.ErpDispatchTaskCommodity `json:"task_commodities"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}

	var dispatchTaskOrigin model.ErpDispatchTask
	err := orm.Eloquent.Table("erp_dispatch_task").Where("id=?", req.Id).Find(&dispatchTaskOrigin).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
		return
	}
	dispatchTask := &model.ErpDispatchTask{
		Sn:            dispatchTaskOrigin.Sn,
		FromStoreId:   req.FromStoreId,
		FromStoreName: dispatchTaskOrigin.FromStoreName,
		ToStoreId:     req.ToStoreId,
		ToStoreName:   dispatchTaskOrigin.ToStoreName,
		MakerId:       req.MakerId,
		MakerName:     dispatchTaskOrigin.MakerName,
		MakerTime:     dispatchTaskOrigin.MakerTime,
		AuditorId:     dispatchTaskOrigin.AuditorId,
		AuditorName:   dispatchTaskOrigin.AuditorName,
		AuditorTime:   dispatchTaskOrigin.AuditorTime,
		State:         dispatchTaskOrigin.State,
	}
	dispatchTask.ID = req.Id
	if req.FromStoreId != dispatchTaskOrigin.FromStoreId {
		fromStore, err := model.GetStore(req.FromStoreId)
		if err != nil {
			logger.Error("from store err:", err)
			app.Error(c, http.StatusInternalServerError, err, "编辑失败")
			return
		}
		dispatchTask.FromStoreName = fromStore.Name
	}
	if req.ToStoreId != dispatchTaskOrigin.ToStoreId {
		toStore, err := model.GetStore(req.ToStoreId)
		if err != nil {
			logger.Error("to store err:", err)
			app.Error(c, http.StatusInternalServerError, err, "编辑失败")
			return
		}
		dispatchTask.ToStoreName = toStore.Name
	}
	if req.MakerId != dispatchTaskOrigin.MakerId {
		userInfo, err := model.GetUserInfo(req.MakerId)
		if err != nil {
			logger.Error("user info err:", err)
			app.Error(c, http.StatusInternalServerError, err, "编辑失败")
			return
		}
		dispatchTask.MakerName = userInfo.ShopAssistantName
	}

	begin := orm.Eloquent.Begin()
	err = begin.Table("erp_dispatch_task_commodity").Where("dispatch_task_id=?", dispatchTask.ID).
		Delete(&model.ErpDispatchTaskCommodity{}).Error
	if err != nil {
		begin.Rollback()
		logger.Error("erp dispatch task commodity del err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
	}
	err = begin.Save(dispatchTask).Error
	if err != nil {
		begin.Rollback()
		logger.Error("erp dispatch task commodity save err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
	}
	err = begin.Create(&req.TaskCommodities).Error
	if err != nil {
		begin.Rollback()
		logger.Error("create task commodities err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
	}
	dispatchTask.TaskCommodities = req.TaskCommodities

	app.OK(c, dispatchTask, "")
	return
}

func ErpDispatchTaskDeliver(c *gin.Context) {
	req := struct {
		ErpDispatchTaskId uint32 `json:"erp_dispatch_task_id"`
		ExpressNo         string `json:"express_no"`
		Remark            string `json:"remark"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	//var dispatchTaskOrigin model.ErpDispatchTask
	err := orm.Eloquent.Table("erp_dispatch_task").Where("id=?", req.ErpDispatchTaskId).Updates(map[string]interface{}{
		"state":      3,
		"express_no": req.ExpressNo,
		"remark":     req.Remark,
	}).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
		return
	}

	var dispatchTask model.ErpDispatchTask
	qs := orm.Eloquent.Table("erp_dispatch_task")
	if req.ErpDispatchTaskId != 0 {
		qs = qs.Where("id=?", req.ErpDispatchTaskId)
	}
	err = qs.Find(&dispatchTask).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	var erpDispatchTaskCommodities []model.ErpDispatchTaskCommodity
	err = orm.Eloquent.Table("erp_dispatch_task_commodity").Where("dispatch_task_id=?", dispatchTask.ID).Find(&erpDispatchTaskCommodities).Error
	if err != nil {
		logger.Error("erp dispatch task commodities err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}
	dispatchTask.TaskCommodities = erpDispatchTaskCommodities

	app.OK(c, dispatchTask, "")
	return
}

func ErpDispatchTaskAuditor(c *gin.Context) {
	req := struct {
		ErpDispatchTaskId uint32 `json:"erp_dispatch_task_id"`
		AuditorId         uint32 `json:"auditor_id"`
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
		return
	}
	userInfo, err := model.GetUserInfo(req.AuditorId)
	if err != nil {
		logger.Error("user info err:", err)
		app.Error(c, http.StatusInternalServerError, err, "创建失败")
		return
	}
	err = orm.Eloquent.Table("erp_dispatch_task").Where("id=?", req.ErpDispatchTaskId).Updates(map[string]interface{}{
		"state":        2,
		"auditor_id":   req.AuditorId,
		"auditor_name": userInfo.ShopAssistantName,
		"auditor_time": time.Now(),
	}).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "编辑失败")
		return
	}
	var dispatchTask model.ErpDispatchTask
	qs := orm.Eloquent.Table("erp_dispatch_task")
	if req.ErpDispatchTaskId != 0 {
		qs = qs.Where("id=?", req.ErpDispatchTaskId)
	}
	err = qs.Find(&dispatchTask).Error
	if err != nil {
		logger.Error("erp commodity err:", err)
		app.Error(c, http.StatusInternalServerError, err, "获取失败")
		return
	}

	app.OK(c, dispatchTask, "")
	return
}