pm/controllers/final/final.go

package final

import (
	"fmt"
	"github.com/gogf/gf/v2/util/gconv"
	"zhiyuan/models"
	"zhiyuan/models/final"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"

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

/*
*
派单工人
*/
func TableDispatchWorker(c *gin.Context) {
	siteId, _ := db.ToInt64(c.Param("site_id"))
	if siteId <= 0 {
		app.ErrorMsg(c, "id must be a number", nil)
		return
	}

	var editForm form.WorkSiteNodeWorkerID
	if app.Bind(c, &editForm) != nil {
		return
	}

	var worker models.Worker
	db.GetModel(map[string]interface{}{
		"id": editForm.WorkerID,
	}, &worker)

	if worker.ID == 0 {
		app.ErrorMsg(c, "工人不存在", nil)
	}

	err := db.UpdateModels(db.Type(final.MatPickWork{}), map[string]interface{}{
		"id":      editForm.WorkID,
		"site_id": siteId,
		//"room_type":       editForm.RoomType,
		//"confirm_type in": []string{"worker", "both"},
	}, map[string]interface{}{
		"worker_id":    worker.ID,
		"order_status": 2, //0：未接单 1：已接单 2：等待中 3:拒绝
	})

	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}

	app.Success(c, nil)
}

func TableCollect(c *gin.Context) {
	id, _ := db.ToInt64(c.Param("id"))

	types := make([]final.FinalType, 0)
	db.GetModel(map[string]interface{}{}, &types)

	var s db.Select
	s.TableName = "zy_work_site"
	s.Select = map[string]string{
		"username": "username",
		"phone":    "phone",
		"village":  "village",
		"address":  "address",
		"room_no":  "room_no",
		"area":     "area",
	}
	/*for _, t := range types {
		s.Select[t.Id]
	}*/
	s.LeftJoin = []db.Join{{
		TableName: "zy_final_site_table",
		As:        "table",
		On: []string{
			"`table`.`site_id` = `zy_work_site`.`id`",
			"`table`.`state` > 1",
		},
	}, {
		TableName: "zy_final_site_item",
		As:        "item",
		On:        []string{"`item`.`table_id` = `table`.`id`"},
	}}

	if id != 0 {
		s.Where = append(s.Where, fmt.Sprintf("`table`.`collect_id` = %s", s.Param(id)))
	} else {
		s.Having = append(s.Having, "sum(if(`table`.`state` = 2, 1, 0)) > 0")
	}
	s.GroupBy = "`zy_work_site`.`id`"
}

func SelectMaterialList(c *gin.Context) {
	var post map[string]interface{}

	model := final.FinalMatMobile{}
	if err := c.ShouldBindJSON(&post); err != nil {
		//app.ErrorMsg(c, err.Error(), nil)
		//return
	}

	where := make(map[string]interface{})
	itemid, _ := db.ToInt64(c.Param("id"))
	var item final.FinalMaterialItem
	db.GetModel(map[string]interface{}{
		"id":         itemid,
		"deleted_at": 0,
	}, &item)
	if item.ID == 0 {
		where["1"] = 1
	} else {
		post["type_id"] = item.MatTypeId
		supplierid := item.SelectSupplier()
		if supplierid != 0 {
			where["supplier_id"] = supplierid
		}
	}

	s := db.ModelQuery(db.Type(model), post, false)
	db.WhereParse(&s, where)
	deleted := model.DeletedField()
	if deleted != "" {
		s.Where = append(s.Where, fmt.Sprintf("`%s`.`%s` = 0", model.TableName(), deleted))
	}
	if !model.ListPrivilege(c, post, &s) {
		app.ErrorMsg(c, "没有权限", nil)
		return
	}
	query, params := s.Query()
	list, err := db.QueryMap(query, params, model.DB())
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if list == nil {
		list = make([]map[string]interface{}, 0)
	}
	data := gin.H{
		"list": list,
	}
	if model.Count() {
		count, err := db.GetCount(s, model.DB())
		if err != nil {
			app.ErrorMsg(c, err.Error(), nil)
			return
		}
		data["count"] = count
	}
	app.Success(c, data)
}

func SelectMaterial(c *gin.Context) {
	var editForm form.SelectMaterialFrom
	if app.Bind(c, &editForm) != nil {
		return
	}

	var item final.FinalMaterialItem
	db.GetModel(map[string]interface{}{
		"id":         editForm.ItemId,
		"deleted_at": 0,
	}, &item)
	if item.ID == 0 {
		app.ErrorMsg(c, "选材项目不存在", nil)
		return
	}

	supplierid := item.SelectSupplier()

	if editForm.MatId != 0 {
		var mat final.FinalMat
		db.GetModel(map[string]interface{}{
			"id":         editForm.MatId,
			"deleted_at": 0,
		}, &mat)
		if mat.ID == 0 {
			app.ErrorMsg(c, "材料不存在", nil)
			return
		}

		if supplierid != 0 && mat.SupplierId != supplierid {
			app.ErrorMsg(c, "只能选相同材料商的材料", nil)
			return
		}
	}

	db.UpdateModel(db.Type(item), item.ID, map[string]interface{}{
		"mat_id": editForm.MatId,
	})

	app.Success(c, nil)
}

func SelectWorkList(c *gin.Context) {
	var post map[string]interface{}

	model := final.MatPickWorkClient{}
	if err := c.ShouldBindJSON(&post); err != nil {

	}

	where := make(map[string]interface{})
	where["site_id"] = post["site_id"]

	s := db.ModelQuery(db.Type(model), post, false)
	s.Select = map[string]string{
		"id":                       "`zy_mat_pick_work`.`id`",
		"site_id":                  "`zy_mat_pick_work`.`site_id`",
		"pkg_id":                   "`zy_mat_pick_work`.`pkg_id`",
		"pick_id":                  "`zy_mat_pick_work`.`pick_id`",
		"room_type":                "`zy_mat_pick_work`.`room_type`",
		"standard":                 "`quality`.`photograph`",
		"cycle":                    "`quality`.`days`",
		"pick_name":                "`quality`.`content`",
		"worker_id":                "`zy_mat_pick_work`.`worker_id`",
		"name":                     "`worker`.`name`",
		"worker_start_at":          "`zy_mat_pick_work`.`worker_start_at`",
		"worker_status":            "`zy_mat_pick_work`.`worker_status`",
		"manager_status":           "`zy_mat_pick_work`.`manager_status`",
		"worker_confirm_at":        "`zy_mat_pick_work`.`worker_confirm_at`",
		"manager_confirm_at":       "`zy_mat_pick_work`.`manager_confirm_at`",
		"example_at":               "`zy_mat_pick_work`.`example_at`",
		"item_status":              "`zy_mat_pick_work`.`item_status`",
		"order_status":             "`zy_mat_pick_work`.`order_status`",
		"pictures":                 "`zy_mat_pick_work`.`pictures`",
		"content":                  "`zy_mat_pick_work`.`content`",
		"acceptance_failed_remark": "`zy_mat_pick_work`.`acceptance_failed_remark`",
		"order_acceptance_at":      "`zy_mat_pick_work`.`order_acceptance_at`",
	}
	db.WhereParse(&s, where)
	deleted := model.DeletedField()
	if deleted != "" {
		s.Where = append(s.Where, fmt.Sprintf("`%s`.`%s` = 0", model.TableName(), deleted))
	}
	s.OrderBy = "`qualityA`.`id`,`quality`.`id` asc"
	// join查询
	s.LeftJoin = []db.Join{
		{
			TableName: "zy_final_site",
			As:        "site",
			On:        []string{"`site`.`id` = " + model.TableName() + ".`site_id`"},
		},
		{
			TableName: "zy_worker",
			As:        "worker",
			On:        []string{"`worker`.`id` = " + model.TableName() + ".`worker_id`"},
		},
		{
			TableName: "zy_work_quality_accept_item", //任务小类表
			As:        "quality",
			On:        []string{"`quality`.`id` = " + model.TableName() + ".`pick_id`"},
		},
		{
			TableName: "zy_work_quality_accept", //任务大类表
			As:        "qualityA",
			On:        []string{"`qualityA`.`id` =  `quality`.`quality_accept_id`"},
		},
		//{
		//	TableName: "zy_task_submission", //项目经理提交表
		//	As:        "submission",
		//	On:        []string{"`submission`.`work_id` = " + model.TableName() + ".`id`"},
		//},
		//{
		//	TableName: "zy_task_comments", //留言表
		//	As:        "comments",
		//	On:        []string{"`comments`.`work_id` = " + model.TableName() + ".`id`"},
		//},
	}
	query, params := s.Query()
	list, err := db.QueryMap(query, params, model.DB())
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if list == nil {
		list = make([]map[string]interface{}, 0)
	}

	workIds := make([]int, 0)
	var oneLevel []int
	oneLevelMapCount := make(map[int][]int) //每个类有多少个任务
	oneLevelcompleteMap := make(map[int][]int)
	for _, v := range list {
		oneLevel = utils.AppendUniqueInt(oneLevel, gconv.Int(v["room_type"]))
		workIds = utils.AppendUniqueInt(workIds, gconv.Int(v["id"]))
		oneLevelMapCount[gconv.Int(v["room_type"])] = append(oneLevelMapCount[gconv.Int(v["room_type"])], gconv.Int(v["id"]))
		if gconv.Int(v["item_status"]) == 1 {
			oneLevelcompleteMap[gconv.Int(v["room_type"])] = append(oneLevelcompleteMap[gconv.Int(v["room_type"])], gconv.Int(v["id"]))
		}
	}

	//获取当前工地的一级目录
	var accepts []models.WorkQualityAccept
	db.GetModel(map[string]interface{}{"id in": oneLevel}, &accepts)
	oneLevelcompleteMapCount := make(map[int]int)
	for _, v := range accepts {
		if len(oneLevelcompleteMap[gconv.Int(v.ID)]) > 0 {
			oneLevelcompleteMapCount[gconv.Int(v.ID)] = len(oneLevelcompleteMap[gconv.Int(v.ID)])
		} else {
			oneLevelcompleteMapCount[gconv.Int(v.ID)] = 0
		}
	}

	//延期审核记录
	//var workExtension []final.WorkExtension
	//db.GetModel(map[string]interface{}{
	//	"work_id in": workIds,
	//}, &workExtension)
	//
	//workExtensionMap := map[int][]final.WorkExtension{}
	//for _, item := range workExtension {
	//	workExtensionMap[item.WorkId] = append(workExtensionMap[item.WorkId], item)
	//}
	//
	//for _, v := range list {
	//	if workExtensionMap[gconv.Int(v["id"])] != nil {
	//		v["workExtensionMap"] = workExtensionMap[gconv.Int(v["id"])]
	//	}
	//}

	fmt.Sprint("workIds:", workIds)
	//找到项目经理提交记录表
	var taskSubmission []models.TaskSubmission
	db.GetModel(map[string]interface{}{
		"work_id in": workIds,
	}, &taskSubmission)

	taskSubmissionMapLog := map[int64][]models.TaskSubmission{}
	for _, item := range taskSubmission {
		taskSubmissionMapLog[item.WorkId] = append(taskSubmissionMapLog[item.WorkId], item)
	}

	for _, v := range list {
		if taskSubmissionMapLog[gconv.Int64(v["id"])] != nil {
			v["taskSubmissionLog"] = taskSubmissionMapLog[gconv.Int64(v["id"])]
		}
	}

	//找到留言记录表
	var taskComments []models.TaskComments
	db.GetModel(map[string]interface{}{
		"work_id in": workIds,
	}, &taskComments)
	fmt.Println(taskComments)

	taskCommentsMapLog := map[int64][]models.TaskComments{}
	for _, item := range taskComments {
		taskCommentsMapLog[item.WorkId] = append(taskCommentsMapLog[item.WorkId], item)
	}

	for _, v := range list {
		if taskCommentsMapLog[gconv.Int64(v["id"])] != nil {
			v["taskCommentsLog"] = taskCommentsMapLog[gconv.Int64(v["id"])]
		}
	}

	data := gin.H{
		"list":                     list,
		"oneLevel":                 accepts,
		"taskSubmissionLog":        taskSubmissionMapLog,
		"taskCommentsLog":          taskComments,
		"oneLevelMapCount":         oneLevelMapCount,
		"oneLevelcompleteMapCount": oneLevelcompleteMapCount,
	}

	if model.Count() {
		count, err := db.GetCount(s, model.DB())
		if err != nil {
			app.ErrorMsg(c, err.Error(), nil)
			return
		}
		data["count"] = count
	}
	app.Success(c, data)
}