pm/services/work/worksitecheck/worksitecheck.go

package worksitecheck

import (
	"errors"
	"fmt"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/form"
	"zhiyuan/services/user"
	"zhiyuan/services/work/worksite"
	"zhiyuan/services/work/worksitenode"
)

var WorkSiteCheck models.WorkSiteCheck

func AddCheck(form form.WorkSiteCheckAdd, adminID int) (int64, error) {

	worksitenodeInfo, _ := worksitenode.GetInfoByID(form.SiteNodeId, nil, nil)
	if worksitenodeInfo == nil {
		return 0, errors.New("invalid worksitenode id")
	}
	if worksitenodeInfo.State == 3 {
		return 0, errors.New("节点已验收")
	}

	worksiteInfo, err := worksite.GetInfoByID(worksitenodeInfo.SiteId, nil, nil)
	if worksiteInfo == nil {
		return 0, errors.New("invalid worksite id")
	}
	if worksiteInfo.State != 1 {
		return 0, errors.New("项目未开工")
	}

	if form.Type == 0 {
		type WorkSiteProcessRequireList struct {
			ID int `json:"id"`
		}

		requireList := make([]WorkSiteProcessRequireList, 0)

		db.GetMultiRaw("SELECT `zy_work_process_require`.`id` from `zy_work_process_require` left join `zy_work_site_process_point` on `zy_work_site_process_point`.`require_id` = `zy_work_process_require`.`id` AND `zy_work_site_process_point`.`deleted_at`=0 AND `zy_work_site_process_point`.`site_node_id`={{site_node_id}} left join `zy_work_process` on `zy_work_process`.`id` = `zy_work_process_require`.`process_id` ", map[string]string{
			"where":     "`zy_work_process_require`.`id`>0 AND `zy_work_process_require`.`deleted_at`=0 AND `zy_work_process_require`.`state`=1 AND `zy_work_process`.`node_id`={{node_id}} AND FIND_IN_SET(`zy_work_process`.`id`, {{process_ids}}) AND ISNULL(`zy_work_site_process_point`.`id`)",
			"_order_by": "`zy_work_process_require`.`id` desc",
			"_group_by": "`zy_work_process_require`.`id`",
		}, map[string]interface{}{
			"site_node_id": worksitenodeInfo.ID,
			"node_id":      worksitenodeInfo.NodeId,
			"process_ids":  worksitenodeInfo.ProcessIds,
		}, &requireList)

		if len(requireList) != 0 {
			return 0, errors.New("存在图片未上传")
		}

		_, err = db.Update(models.WorkSiteNode{}.TableName(), map[string]interface{}{"id": form.SiteNodeId}, map[string]interface{}{"state": 2})
		if err != nil {
			return 0, err
		}
	}

	workSiteCheckMap := map[string]interface{}{
		"`site_id`":      worksitenodeInfo.SiteId,
		"`site_node_id`": form.SiteNodeId,
		"`type`":         form.Type,
		"`days`":         form.Days,
		"`pictures`":     form.Pictures,
		"`content`":      form.Content,
		"`admin_id`":     adminID,
	}
	workSiteCheckID, err := db.InsertOne(WorkSiteCheck.TableName(), workSiteCheckMap)
	if err != nil {
		return 0, err
	}
	return workSiteCheckID, nil
}

func AddSiteCheck(form form.WorkSiteCheckAddSite, adminID int) (int64, error) {

	worksiteInfo, err := worksite.GetInfoByID(form.SiteId, nil, nil)
	if worksiteInfo == nil {
		return 0, errors.New("invalid worksite id")
	}

	if form.Type == 2 {
		//now := time.Now().Unix()
		//if now >= int64(worksiteInfo.StartTime)+57600 && now <= int64(worksiteInfo.StartTime)+86400 {
		//	return 0, errors.New("停工暂不可用")
		//}

		s := db.ModelQuery(db.Type(models.WorkSiteNode{}), map[string]interface{}{
			"site_id": worksiteInfo.ID,
		}, true)
		db.WhereParse(&s, map[string]interface{}{
			"state >=": 2,
		})
		deleted := models.WorkSiteNode{}.DeletedField()
		if deleted != "" {
			s.Where = append(s.Where, fmt.Sprintf("`%s`.`%s` = 0", models.WorkSiteNode{}.TableName(), deleted))
		}
		query, params := s.Query()
		list, err := db.QueryMap(query, params, nil)
		if err != nil {
			return 0, err
		}
		if list == nil {
			list = make([]map[string]interface{}, 0)
		}
		if len(list) == 0 {
			return 0, errors.New("需先发起节点验收")
		}

	}

	workSiteCheckMap := map[string]interface{}{
		"`site_id`":      form.SiteId,
		"`site_node_id`": 0,
		"`type`":         form.Type,
		"`days`":         form.Days,
		"`pictures`":     form.Pictures,
		"`content`":      form.Content,
		"`admin_id`":     adminID,
	}
	workSiteCheckID, err := db.InsertOne(WorkSiteCheck.TableName(), workSiteCheckMap)
	if err != nil {
		return 0, err
	}
	return workSiteCheckID, nil
}

func CheckPass(id int, forms form.WorkSiteCheckFrom, adminID int) error {

	worksitecheck, err := GetInfoByID(id, nil, nil)
	if worksitecheck == nil {
		return errors.New("invalid worksitecheck id")
	}
	if worksitecheck.State != 0 && worksitecheck.State != 3 {
		return errors.New("验收状态错误")
	}

	worksiteInfo, err := worksite.GetInfoByID(worksitecheck.SiteId, nil, nil)
	if worksiteInfo == nil {
		return errors.New("invalid worksite id")
	}

	now := time.Now().Unix()
	state := 1
	check_id := "`check_id`"
	explain := "`explain`"
	switch worksitecheck.Type {
	case 0:

		worksitenodeInfo, err := worksitenode.GetInfoByID(worksitecheck.SiteNodeId, nil, nil)
		if worksitenodeInfo == nil {
			return errors.New("invalid worksitenode id")
		}

		type WorkSiteProcessRequireList struct {
			ID int `json:"id"`
		}

		requireList := make([]WorkSiteProcessRequireList, 0)

		db.GetMultiRaw("SELECT `zy_work_process_require`.`id` from `zy_work_process_require` left join `zy_work_site_process_point` on `zy_work_site_process_point`.`require_id` = `zy_work_process_require`.`id` AND `zy_work_site_process_point`.`deleted_at`=0 AND `zy_work_site_process_point`.`site_node_id`={{site_node_id}}  AND `zy_work_site_process_point`.`id` in (select max(`zy_work_site_process_point`.`id`) from `zy_work_site_process_point` where  `zy_work_site_process_point`.`deleted_at`=0 group by `zy_work_site_process_point`.`site_node_id`, `zy_work_site_process_point`.`require_id`) left join `zy_work_process` on `zy_work_process`.`id` = `zy_work_process_require`.`process_id` ", map[string]string{
			"where":     "`zy_work_process_require`.`id`>0 AND `zy_work_process_require`.`deleted_at`=0 AND `zy_work_process_require`.`state`=1 AND `zy_work_process`.`node_id`={{node_id}} AND FIND_IN_SET(`zy_work_process`.`id`, {{process_ids}}) AND (ISNULL(`zy_work_site_process_point`.`state`) OR `zy_work_site_process_point`.`state` != 1)",
			"_order_by": "`zy_work_process_require`.`id` desc",
			"_group_by": "`zy_work_process_require`.`id`",
		}, map[string]interface{}{
			"site_node_id": worksitenodeInfo.ID,
			"node_id":      worksitenodeInfo.NodeId,
			"process_ids":  worksitenodeInfo.ProcessIds,
		}, &requireList)
		if len(requireList) != 0 {
			return errors.New("存在图片未审核")
		}

		/*if worksitenodeInfo.QualityAcceptID != 0 {
			s := db.ModelQuery(db.Type(models.WorkSiteQualityAcceptItemModel{}), map[string]interface{}{
				"quality_accept_id": worksitenodeInfo.QualityAcceptID,
				"site_node_id":      worksitenodeInfo.ID,
			}, true)
			s.Where = append(s.Where, "(`siteitem`.`state` != 1 OR isnull(`siteitem`.`state`))")
			deleted := models.WorkSiteQualityAcceptItemModel{}.DeletedField()
			if deleted != "" {
				s.Where = append(s.Where, fmt.Sprintf("`%s`.`%s` = 0", models.WorkSiteQualityAcceptItemModel{}.TableName(), deleted))
			}
			query, params := s.Query()
			list, err := db.QueryMap(query, params, nil)
			if err != nil {
				return err
			}
			if list == nil {
				list = make([]map[string]interface{}, 0)
			}
			if len(list) != 0 {
				return errors.New("未完成质检")
			}
		}

		if worksitenodeInfo.ReturnVisitID != 0 && worksitenodeInfo.ReturnVisitContent == "" {
			return errors.New("未完成客服回访")
		}*/

		s := db.ModelQuery(db.Type(models.WorkSiteProblem{}), map[string]interface{}{
			"site_node_id": worksitenodeInfo.ID,
		}, true)
		db.WhereParse(&s, map[string]interface{}{
			"state !=": 6,
		})
		deleted := models.WorkSiteProblem{}.DeletedField()
		if deleted != "" {
			s.Where = append(s.Where, fmt.Sprintf("`%s`.`%s` = 0", models.WorkSiteProblem{}.TableName(), deleted))
		}
		query, params := s.Query()
		list, err := db.QueryMap(query, params, nil)
		if err != nil {
			return err
		}
		if list == nil {
			list = make([]map[string]interface{}, 0)
		}
		if len(list) != 0 {
			return errors.New("存在问题未完结")
		}

		_, err = db.Update(worksitenodeInfo.TableName(), map[string]interface{}{"id": worksitenodeInfo.ID}, map[string]interface{}{
			"real_endtime": now,
			"quality_time": time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, 1).Unix(),
			"state":        3,
		})
		if err != nil {
			return err
		}

		var model models.WorkSiteNode
		s = db.ModelQuery(db.Type(model), map[string]interface{}{
			"site_id": worksiteInfo.ID,
		}, true)
		db.WhereParse(&s, map[string]interface{}{
			"state !=": 3,
		})
		deleted = model.DeletedField()
		if deleted != "" {
			s.Where = append(s.Where, fmt.Sprintf("`%s`.`%s` = 0", model.TableName(), deleted))
		}
		query, params = s.Query()
		list, err = db.QueryMap(query, params, nil)
		if err != nil {
			return err
		}
		if list == nil {
			list = make([]map[string]interface{}, 0)
		}
		if len(list) == 0 {
			_, err = db.Update(worksiteInfo.TableName(), map[string]interface{}{"id": worksiteInfo.ID}, map[string]interface{}{
				"real_endtime": now,
				"state":        2,
			})
			if err != nil {
				return err
			}
			userID := user.CreateNewUser(worksiteInfo.Username, worksiteInfo.Phone)
			if userID > 0 {
				_, err := user.HouseAdd(form.HouseAdd{
					UserID:                 userID,
					Address:                worksiteInfo.Address + " " + worksiteInfo.Village,
					Designer:               worksiteInfo.DesignerId,
					Supervisor:             worksiteInfo.ManagerId,
					ProjectStart:           time.Unix(int64(worksiteInfo.StartTime), 0).Format("2006-01-02"),
					ProjectEnd:             time.Unix(int64(worksiteInfo.EndTime), 0).Format("2006-01-02"),
					WarrantyPeriodBase:     2,
					WarrantyPeriodMaterial: 1,
					WarrantyPeriodElectric: 5,
					WarrantyStart:          time.Now().Format("2006-01") + fmt.Sprintf("-%02d", time.Now().Day()+1),
				})
				if err != nil {
					return err
				}
			}
		}
	case 1:
		nodes := make([]models.WorkSiteNode, 0)
		db.GetModel(map[string]interface{}{
			"site_id":    worksitecheck.SiteId,
			"deleted_at": 0,
		}, &nodes)
		for _, node := range nodes {
			if node.State < 2 {
				data := map[string]interface{}{
					"endtime": node.EndTime + worksitecheck.Days*86400,
				}
				if int64(node.StartTime) >= now {
					data["starttime"] = node.StartTime + worksitecheck.Days*86400
				} else {
					data["days"] = node.Days + worksitecheck.Days
				}
				db.UpdateModel(db.Type(models.WorkSiteNode{}), int64(node.ID), data)
			}
		}
		if worksiteInfo.State < 2 {
			data := map[string]interface{}{
				"endtime": worksiteInfo.EndTime + worksitecheck.Days*86400,
			}
			if worksiteInfo.State == 0 {
				data["starttime"] = worksiteInfo.StartTime + worksitecheck.Days*86400
			}
			db.UpdateModel(db.Type(worksiteInfo), int64(worksiteInfo.ID), data)
		}
	case 2:
		if int64(worksitecheck.Days) <= now {
			db.UpdateModel(db.Type(worksiteInfo), int64(worksiteInfo.ID), map[string]interface{}{
				"stoptime": worksitecheck.Days,
				"state":    3,
			})
		}
	case 3:
		if int64(worksitecheck.Days) <= now {
			nodes := make([]models.WorkSiteNode, 0)
			db.GetModel(map[string]interface{}{
				"site_id":    worksitecheck.SiteId,
				"deleted_at": 0,
			}, &nodes)
			for _, node := range nodes {
				if node.State < 2 {
					data := map[string]interface{}{
						"endtime": node.EndTime + worksitecheck.Days - worksiteInfo.StopTime,
					}
					if node.StartTime >= worksiteInfo.StopTime {
						data["starttime"] = node.StartTime + worksitecheck.Days - worksiteInfo.StopTime
					} else {
						data["days"] = node.Days + int((worksitecheck.Days-worksiteInfo.StopTime)/86400)
					}
					db.UpdateModel(db.Type(models.WorkSiteNode{}), int64(node.ID), data)
				}
			}
			data := map[string]interface{}{
				"state":   1,
				"endtime": worksiteInfo.EndTime + worksitecheck.Days - worksiteInfo.StopTime,
			}
			db.UpdateModel(db.Type(worksiteInfo), int64(worksiteInfo.ID), data)
		}
	case 4:
		if worksitecheck.State == 0 {
			state = 3
		} else {

			check_id = "`check_ids`"
			explain = "`explains`"
			worksitenodeInfo, _ := worksitenode.GetInfoByID(worksitecheck.SiteNodeId, nil, nil)
			if worksitenodeInfo == nil {
				return errors.New("invalid worksitenode id")
			}

			data := map[string]interface{}{
				"endtime": worksitenodeInfo.EndTime + worksitecheck.Days*86400,
			}
			if int64(worksitenodeInfo.StartTime) >= now {
				data["starttime"] = worksitenodeInfo.StartTime + worksitecheck.Days*86400
			} else {
				data["days"] = worksitenodeInfo.Days + worksitecheck.Days
			}
			db.UpdateModel(db.Type(models.WorkSiteNode{}), int64(worksitenodeInfo.ID), data)
		}
	case 5:
		if worksitecheck.State == 0 {
			state = 3
		} else {

			check_id = "`check_ids`"
			explain = "`explains`"
			worksitenodeInfo, _ := worksitenode.GetInfoByID(worksitecheck.SiteNodeId, nil, nil)
			if worksitenodeInfo == nil {
				return errors.New("invalid worksitenode id")
			}

			db.UpdateModel(db.Type(models.WorkSiteNode{}), int64(worksitenodeInfo.ID), map[string]interface{}{
				"state":             4,
				"process_ids":       "",
				"return_visit_id":   0,
				"quality_accept_id": 0,
			})
		}
	}

	data := map[string]interface{}{
		"`state`": state,
		explain:   forms.Explain,
		check_id:  adminID,
	}
	if worksitecheck.State == 0 {
		data["check_at"] = now
	}
	_, err = db.Update(WorkSiteCheck.TableName(), map[string]interface{}{
		"id": worksitecheck.ID,
	}, data)
	if err != nil {
		return err
	}

	return nil
}

func CheckCron() {
	day, _ := time.ParseInLocation("2006-01-02", time.Now().Format("2006-01-02"), time.Local)
	now := day.Unix()

	checks := make([]models.WorkSiteCheck, 0)
	db.GetModel(map[string]interface{}{
		"days":       day.Unix(),
		"state":      1,
		"deleted_at": 0,
	}, &checks)
	for _, check := range checks {

		worksiteInfo, _ := worksite.GetInfoByID(check.SiteId, nil, nil)
		if worksiteInfo == nil {
			return
		}

		switch check.Type {
		case 2:
			db.UpdateModel(db.Type(worksiteInfo), int64(worksiteInfo.ID), map[string]interface{}{
				"stoptime": now,
				"state":    3,
			})
		case 3:
			nodes := make([]models.WorkSiteNode, 0)
			db.GetModel(map[string]interface{}{
				"site_id":    check.SiteId,
				"deleted_at": 0,
			}, &nodes)
			for _, node := range nodes {
				if node.State < 2 {
					data := map[string]interface{}{
						"endtime": node.EndTime + check.Days - worksiteInfo.StopTime,
					}
					if node.StartTime >= worksiteInfo.StopTime {
						data["starttime"] = node.StartTime + check.Days - worksiteInfo.StopTime
					} else {
						data["days"] = node.Days + int((check.Days-worksiteInfo.StopTime)/86400)
					}
					db.UpdateModel(db.Type(models.WorkSiteNode{}), int64(node.ID), data)
				}
			}
			data := map[string]interface{}{
				"state":   1,
				"endtime": worksiteInfo.EndTime + check.Days - worksiteInfo.StopTime,
			}
			db.UpdateModel(db.Type(worksiteInfo), int64(worksiteInfo.ID), data)
		}

	}
}

func CheckFail(id int, forms form.WorkSiteCheckFrom, adminID int) error {

	worksitecheck, err := GetInfoByID(id, nil, nil)
	if worksitecheck == nil {
		return errors.New("invalid worksitecheck id")
	}

	if worksitecheck.Type == 0 {
		worksitenodeInfo, err := worksitenode.GetInfoByID(worksitecheck.SiteNodeId, nil, nil)
		if worksitenodeInfo == nil {
			return errors.New("invalid worksitenode id")
		}

		_, err = db.Update(worksitenodeInfo.TableName(), map[string]interface{}{
			"id": worksitenodeInfo.ID,
		}, map[string]interface{}{
			"state": 0,
		})
		if err != nil {
			return err
		}

	}

	_, err = db.Update(WorkSiteCheck.TableName(), map[string]interface{}{
		"id": worksitecheck.ID,
	}, map[string]interface{}{
		"state":      2,
		"`explain`":  forms.Explain,
		"`check_id`": adminID,
	})
	if err != nil {
		return err
	}

	return nil
}

func DeleteByID(id int) error {
	info, _ := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid id")
	}

	_, err := db.DeleteSoft(WorkSiteCheck.TableName(), map[string]interface{}{"id": id})
	return err
}

func Count(where map[string]interface{}) (int64, error) {
	return db.Count(WorkSiteCheck.TableName(), where)
}

func CountRaw(where string, param map[string]interface{}) (int64, error) {
	query := "`zy_work_site_check` left join `zy_work_site` on `zy_work_site`.`id` = `zy_work_site_check`.`site_id` WHERE " + where
	return db.CountRaw(query, param)
}

func GetList(where map[string]interface{}, fields []string, page app.Page, retVal interface{}) ([]*models.WorkSiteCheck, error) {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_limit"] = db.GetOffset(uint(page.PageNum), uint(page.PageSize))
	}
	return WorkSiteCheck.GetMulti(where, fields, retVal)
}

func GetWorkSiteChecksRaw(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	field := "SELECT `zy_work_site_check`.*, `zy_work_site_node`.`name` as `node_name`, `zy_work_node`.`color` as `node_color`, `zy_work_node`.`logo` as `node_logo`, `zy_admin`.`username` as `admin_name`, `zy_admin`.`headimgurl` as `admin_headimgurl`, `check`.`username` as `check_name`, `check`.`headimgurl` as `check_headimgurl`, `checks`.`username` as `checks_name`, `checks`.`headimgurl` as `checks_headimgurl`, `zy_work_site`.`username` as `username`, `zy_work_site`.`phone` as `phone`, `zy_work_site`.`village` as `village`, `zy_work_site`.`address` as `address`, `zy_work_site`.`room_no` as `room_no`, `zy_work_site`.`area` as `area`, `zy_work_site`.`starttime` as `site_starttime`, `zy_work_site`.`endtime` as `site_endtime`, `zy_work_site`.`state` as `site_state`, `zy_work_site`.`servicer_id` as `site_servicer_id` from `zy_work_site_check` left join `zy_admin` on `zy_admin`.`id` = `zy_work_site_check`.`admin_id` left join `zy_work_site_node` on `zy_work_site_node`.`id` = `zy_work_site_check`.`site_node_id` left join `zy_work_node` on `zy_work_node`.`id` = `zy_work_site_node`.`node_id` left join `zy_admin` as `check` on `check`.`id` = `zy_work_site_check`.`check_id` left join `zy_work_site` on `zy_work_site`.`id` = `zy_work_site_check`.`site_id` left join `zy_admin` as `checks` on `checks`.`id` = `zy_work_site_check`.`check_ids`"
	return db.GetMultiRaw(field, where, param, retVal)
}

func GetOne(where map[string]interface{}, fields []string, retVal interface{}) (*models.WorkSiteCheck, error) {
	return WorkSiteCheck.GetOne(where, fields, retVal)
}

func GetWorkSiteCheckOne(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	field := "SELECT `zy_work_site_check`.*, `zy_work_site_node`.`name` as `node_name`, `zy_work_node`.`color` as `node_color`, `zy_work_node`.`logo` as `node_logo`, `zy_admin`.`username` as `admin_name`, `zy_admin`.`headimgurl` as `admin_headimgurl`, `check`.`username` as `check_name`, `check`.`headimgurl` as `check_headimgurl`, `zy_work_site`.`username` as `username`, `zy_work_site`.`phone` as `phone`, `zy_work_site`.`village` as `village`, `zy_work_site`.`address` as `address`, `zy_work_site`.`room_no` as `room_no`, `zy_work_site`.`area` as `area`, `zy_work_site`.`starttime` as `site_starttime`, `zy_work_site`.`endtime` as `site_endtime`, `zy_work_site`.`state` as `site_state` from `zy_work_site_check` left join `zy_admin` on `zy_admin`.`id` = `zy_work_site_check`.`admin_id` left join `zy_work_site_node` on `zy_work_site_node`.`id` = `zy_work_site_check`.`site_node_id` left join `zy_work_node` on `zy_work_node`.`id` = `zy_work_site_node`.`node_id` left join `zy_admin` as `check` on `check`.`id` = `zy_work_site_check`.`check_id` left join `zy_work_site` on `zy_work_site`.`id` = `zy_work_site_check`.`site_id`"
	where["_page_size"] = utils.ToStr(1)
	where["_page_num"] = utils.ToStr(1)
	return db.GetMultiRaw(field, where, param, retVal)
}

func GetWorkSiteCheckByID(id int, retVal interface{}) error {
	where := map[string]string{
		"where": "`zy_work_site_check`.`id` = {{id}}",
	}
	param := map[string]interface{}{"id": id}
	return GetWorkSiteCheckOne(where, param, retVal)
}

func GetInfoByID(id int, fields []string, retVal interface{}) (*models.WorkSiteCheck, error) {
	return GetOne(map[string]interface{}{"id": id}, fields, retVal)
}