pm/services/work/worksite/worksite.go

package worksite

import (
	"errors"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	adminParam "zhiyuan/pkg/param/admin"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/admin"
	"zhiyuan/services/form"
)

var WorkSite models.WorkSite

func Add(form form.WorkSiteAdd, createdId int) (int64, error) {

	pkg := models.GetWorkPkgModel(int64(form.PkgId), false)
	if pkg == nil {
		return 0, errors.New("套餐不存在")
	}

	workSiteMap := map[string]interface{}{
		"`pkg_id`":    form.PkgId,
		"`username`":  form.Username,
		"`phone`":     form.Phone,
		"`village`":   form.Village,
		"`address`":   form.Address,
		"`room_no`":   form.RoomNo,
		"`area`":      form.Area,
		"`longitude`": form.Longitude,
		"`latitude`":  form.Latitude,
		//"`admin_ids`":  form.AdminIds,
		"`starttime`":  form.StartTime,
		"`endtime`":    form.StartTime + int(pkg.Days-1)*86400,
		"`discount`":   form.Discount,
		"`promotion`":  form.Promotion,
		"`gifts`":      form.Gifts,
		"`other`":      form.Other,
		"`hose`":       form.Hose,
		"`bear`":       form.Bear,
		"`created_id`": createdId,
	}
	workSiteID, err := db.InsertOne(WorkSite.TableName(), workSiteMap)
	if err != nil {
		return 0, err
	}
	for _, node := range pkg.Nodes {
		workSiteNodeMap := map[string]interface{}{
			"`site_id`":           workSiteID,
			"`node_id`":           node.NodeId,
			"`name`":              node.Name,
			"`starttime`":         form.StartTime + int(node.Startday-1)*86400,
			"`endtime`":           form.StartTime + int(node.Startday+node.Days-2)*86400,
			"`process_ids`":       node.ProcessIds,
			"`quality_accept_id`": node.QualityAcceptID,
			"`return_visit_id`":   node.ReturnVisitID,
			"`mark`":              node.Mark,
		}
		_, err := db.InsertOne(models.WorkSiteNode{}.TableName(), workSiteNodeMap)
		if err != nil {
			return 0, err
		}
	}
	return workSiteID, nil
}

func EditByID(form form.WorkSiteEdit, id int) error {
	info, err := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid id")
	}
	workSiteMap := map[string]interface{}{
		"`username`":  form.Username,
		"`phone`":     form.Phone,
		"`village`":   form.Village,
		"`address`":   form.Address,
		"`room_no`":   form.RoomNo,
		"`area`":      form.Area,
		"`longitude`": form.Longitude,
		"`latitude`":  form.Latitude,
		//"`admin_ids`": form.AdminIds,
		"`discount`":  form.Discount,
		"`promotion`": form.Promotion,
		"`gifts`":     form.Gifts,
		"`other`":     form.Other,
		"`hose`":      form.Hose,
		"`bear`":      form.Bear,
	}
	_, err = db.Update(WorkSite.TableName(), map[string]interface{}{"id": id}, workSiteMap)
	return err
}

func DeleteByID(id int) error {
	info, _ := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid id")
	}
	_, err := db.DeleteSoft(WorkSite.TableName(), map[string]interface{}{"id": id})
	return err
}

func DispatchByID(form form.WorkSiteAdminID, id int) error {
	info, err := GetInfoByID(id, nil, nil)
	if err != nil || info == nil {
		return errors.New("invalid id")
	}
	if roleInfo, _ := admin.GetOneRaw(map[string]string{"where": "id={{admin_id}} AND FIND_IN_SET({{role_id}}, role_ids)"}, map[string]interface{}{"role_id": form.RoleID, "admin_id": form.AdminID}, nil); roleInfo == nil {
		return errors.New("账号角色有误")
	}
	workSiteMap := make(map[string]interface{})
	switch form.RoleID {
	case adminParam.SupervisorRoleId:
		workSiteMap["manager_id"] = form.AdminID
	case adminParam.DesignerRoleId:
		workSiteMap["designer_id"] = form.AdminID
	case adminParam.SalesmanRoleId:
		workSiteMap["salesman_id"] = form.AdminID
	case adminParam.ManagerRoleId:
		workSiteMap["project_manager_id"] = form.AdminID
	case adminParam.LeaderRoleId:
		workSiteMap["project_leader_id"] = form.AdminID
	case adminParam.ServicerRoleId:
		workSiteMap["servicer_id"] = form.AdminID
	case adminParam.QualityRoleId:
		workSiteMap["quality_id"] = form.AdminID
	case adminParam.AssistantRoleId:
		workSiteMap["assistant_id"] = form.AdminID
	default:
		return errors.New("invalid roleID")
	}
	_, err = db.Update(WorkSite.TableName(), map[string]interface{}{"id": id}, workSiteMap)
	return err
}

func StartByID(id int, adminID int) error {
	info, err := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid id")
	}
	if info.State != 0 {
		return errors.New("节点状态有误")
	}

	now := time.Now().Unix()

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

	return nil
}

func EditTime(form form.WorkSiteTime, id int, adminID int) error {
	info, err := GetInfoByID(id, nil, nil)
	if info == nil {
		return errors.New("invalid id")
	}
	if info.State != 0 {
		return errors.New("项目已开工")
	}
	if form.StartTime > form.EndTime {
		return errors.New("工期设置有误")
	}
	workSiteMap := map[string]interface{}{
		"`starttime`": form.StartTime,
		"`endtime`":   form.EndTime,
	}
	_, err = db.Update(WorkSite.TableName(), map[string]interface{}{"id": id}, workSiteMap)
	return err
}

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

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

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

func GetWorkSitesRaw(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	field := "SELECT `zy_work_site`.*, `manager`.`username` as `manager_name`, `manager`.`phone` as `manager_phone`, `designer`.`username` as `designer_name`, `designer`.`phone` as `designer_phone`, `created`.`username` as `created_name`, group_concat(`zy_admin`.`username` separator ',') as `admin_names` FROM `zy_work_site` left join `zy_admin` as `manager` on `manager`.`id` = `zy_work_site`.`manager_id` left join `zy_admin` as `designer` on `designer`.`id` = `zy_work_site`.`designer_id` left join `zy_admin` as `created` on `created`.`id` = `zy_work_site`.`created_id` left join `zy_admin` on FIND_IN_SET(`zy_admin`.`id`, `zy_work_site`.`admin_ids`) "
	return db.GetMultiRaw(field, where, param, retVal)
}

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

func GetWorkSiteOne(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	field := "SELECT `zy_work_site`.*, `manager`.`username` as `manager_name`, `manager`.`phone` as `manager_phone`, `designer`.`username` as `designer_name`, `designer`.`phone` as `designer_phone`, `created`.`username` as `created_name`, group_concat(`zy_admin`.`username` separator ',') as `admin_names` FROM `zy_work_site` left join `zy_admin` as `manager` on `manager`.`id` = `zy_work_site`.`manager_id` left join `zy_admin` as `designer` on `designer`.`id` = `zy_work_site`.`designer_id` left join `zy_admin` as `created` on `created`.`id` = `zy_work_site`.`created_id` left join `zy_admin` on FIND_IN_SET(`zy_admin`.`id`, `zy_work_site`.`admin_ids`) "
	where["_page_size"] = utils.ToStr(1)
	where["_page_num"] = utils.ToStr(1)
	return db.GetMultiRaw(field, where, param, retVal)
}

func GetWorkSiteByID(id int, retVal interface{}) error {
	where := map[string]string{
		"where": "`zy_work_site`.`id` = {{id}}",
	}
	param := map[string]interface{}{"id": id}
	return GetWorkSiteOne(where, param, retVal)
}

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