pm/controllers/admin/work/worker.go

package work

import (
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/v2/util/gconv"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/geo"
	"zhiyuan/services/work/worker"

	"github.com/gin-gonic/gin"
	"github.com/tealeg/xlsx/v3"
)

func WorkerList(c *gin.Context) {
	page := app.HandlePageNums(c)
	where := map[string]string{
		"where":     "`zy_worker`.`id`>0",
		"_group_by": "`zy_worker`.`id`",
		"_order_by": "`zy_worker`.`id` desc",
	}
	if page.PageSize != 0 {
		where["_page_size"] = utils.ToStr(page.PageSize)
		where["_page_num"] = utils.ToStr(page.PageNum)
	}
	param := make(map[string]interface{})

	name := c.Query("name")
	if name != "" {
		where["where"] = where["where"] + " AND `zy_worker`.`name` LIKE {{name}}"
		param["name"] = "%" + name + "%"
	}

	phone := c.Query("phone")
	if phone != "" {
		where["where"] = where["where"] + " AND `zy_worker`.`phone` LIKE {{phone}}"
		param["phone"] = "%" + phone + "%"
	}

	idcode := c.Query("idcode")
	if idcode != "" {
		where["where"] = where["where"] + " AND `zy_worker`.`idcode` LIKE {{idcode}}"
		param["idcode"] = "%" + idcode + "%"
	}

	typeId := c.Query("type_id")
	if typeId != "" {
		where["where"] = where["where"] + " AND FIND_IN_SET({{type_id}}, `zy_worker`.`type_ids`)"
		param["type_id"] = typeId
	}

	state := utils.ToInt(c.Query("state"))
	if state != 0 {
		where["where"] = where["where"] + " AND `zy_worker`.`state`={{state}}"
		param["state"] = state
	}

	total, err := worker.CountRaw(where["where"], param)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	type WorkerList struct {
		ID        int    `json:"id"`
		Name      string `json:"name"`
		Phone     string `json:"phone"`
		TypeIds   string `json:"type_ids"`
		TypeNames string `json:"type_names"`
		Idcode    string `json:"idcode"`
		Idcard1   string `json:"idcard1"`
		Idcard2   string `json:"idcard2"`
		State     string `json:"state"`
		CreatedAt int    `json:"created_at"`
		UpdatedAt int    `json:"updated_at"`
	}
	workerList := make([]WorkerList, 0)
	if err = worker.GetWorkersRaw(where, param, &workerList); err != nil {
		app.Error(c, err.Error())
		return
	}

	data := gin.H{
		"list":  workerList,
		"total": total,
		"limit": page.PageSize,
	}
	app.Success(c, data)
}

func WorkerVerify(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "worker id must be a number", nil)
		return
	}

	err := worker.VerifyByID(id)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func WorkerImport(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		app.Error(c, fmt.Sprintf("get form err: %s", err.Error()))
		return
	}
	fileExt := utils.FileExt(file.Filename)
	attachKey := utils.RandomStr() + fileExt
	file.Filename = "data/" + attachKey
	if err := c.SaveUploadedFile(file, file.Filename); err != nil {
		app.Error(c, fmt.Sprintf("上传文件失败%s", err.Error()))
		return
	}
	wb, err := xlsx.OpenFile(file.Filename)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	sh, ok := wb.Sheet["Sheet1"]
	if !ok {
		fmt.Println("Sheet does not exist")
		return
	}

	typeList := make([]models.WorkType, 0)
	db.GetModel(map[string]interface{}{}, &typeList)

	datas := make([]map[string]interface{}, 0)
	headers := make([]string, 0)

	err = sh.ForEachRow(func(r *xlsx.Row) error {
		if r.GetCoordinate() <= 0 {
			err := r.ForEachCell(func(c *xlsx.Cell) error {
				headers = append(headers, c.String())
				return nil
			})
			if err != nil {
				return err
			}
		} else {
			var data models.Worker
			for i, header := range headers {
				value := r.GetCell(i).String()
				switch header {
				case "姓名":
					data.Name = value
				case "电话号码":
					data.Phone = value
				case "性别":
					sex := 0
					if value == "男" {
						sex = 1
					} else if value == "女" {
						sex = 2
					}
					data.Sex = sex
				case "年龄":
					age, _ := db.ToInt64(value)
					data.Age = int(age)
				case "身份证号":
					data.Idcode = value
				case "工种":
					types := make([]string, 0)

					nameList := strings.Split(value, ",")
					for _, name := range nameList {
						if name != "" {
							for _, typ := range typeList {
								if strings.Index(typ.Name, name) == 0 {
									types = append(types, db.ToString(typ.ID))
									break
								}
							}
						}
					}

					data.TypeIds = strings.Join(types, ",")
				case "所在区域":
					names := strings.Split(value, "/")
					code := ""
				out:
					for _, name := range names {
						list, err := geo.Lower(code)
						if err != nil {
							break
						}
						for _, l := range list {
							if n, ok := l["name"]; ok {
								if name == db.ToString(n) {
									if c, ok := l["code"]; ok {
										code = db.ToString(c)
										continue out
									}
								}
							}
						}
						break
					}
					data.Areacode = code
				case "是否买保险":
					insure := 0
					if value == "是" {
						insure = 1
					}
					data.Insure = insure
				case "保险开始日期":
					insure_start, _ := time.ParseInLocation("2006-01-02", value, time.Local)
					s := int(insure_start.Unix())
					if s > 0 {
						s = 0
					}
					data.InsureStart = s
				case "保险结束日期":
					insure_end, _ := time.ParseInLocation("2006-01-02", value, time.Local)
					s := int(insure_end.Unix())
					if s > 0 {
						s = 0
					}
					data.InsureEnd = s
				case "开户行":
					data.BankName = value
				case "银行卡号":
					data.BankCardNo = value
				default:
				}
			}
			if data.Name == "" || data.Phone == "" {
				return nil
			}
			var worker models.Worker
			db.GetModel(map[string]interface{}{
				"phone":      data.Phone,
				"deleted_at": 0,
			}, &worker)
			da := map[string]interface{}{
				"name":         data.Name,
				"phone":        data.Phone,
				"sex":          data.Sex,
				"age":          data.Age,
				"idcode":       data.Idcode,
				"type_ids":     data.TypeIds,
				"areacode":     data.Areacode,
				"insure":       data.Insure,
				"insure_start": data.InsureStart,
				"insure_end":   data.InsureEnd,
				"bank_name":    data.BankName,
				"bank_card_no": data.BankCardNo,
			}
			if worker.ID == 0 {
				datas = append(datas, da)
			} else {
				if worker.Name == data.Name {
					err := db.UpdateModel(db.Type(worker), int64(worker.ID), da)
					if err != nil {
						return err
					}
				}
			}
		}
		return nil
	})

	if err != nil {
		app.Error(c, err.Error())
		return
	}
	db.InsertModels(db.Type(models.Worker{}), datas)
	app.Success(c, nil)
}

type QuoteOrder2ImportFrom struct {
	File string `json:"file"` // 注意：这里的 "file" 字段在 JSON 中是一个数组
}
type Files struct {
	Name       string `json:"name"`
	UploadTime int64  `json:"upload_time"`
	URL        string `json:"url"`
}

func QualityImport(c *gin.Context) {

	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "id must be a number", nil)
		return
	}

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

	// 解析 JSON 数据
	files := []Files{}
	err := json.Unmarshal([]byte(form.File), &files)
	if err != nil {
		log.Fatalf("Error parsing JSON: %v", err)
		return
	}

	// 1. 下载到临时文件
	file, err := downloadExcelFromURL(files[0].URL)
	if err != nil {
		panic(err)
	}
	// 确保程序结束后删除临时文件
	defer os.Remove(file.Name())

	wb, err := xlsx.OpenFile(file.Name())
	if err != nil {
		fmt.Printf("读取错误", err.Error())
		app.Error(c, err.Error())
		return
	}
	sh, ok := wb.Sheet["Sheet1"]
	if !ok {
		fmt.Println("Sheet does not exist")
		return
	}

	typeList := make([]models.WorkQualityAccept, 0)
	db.GetModel(map[string]interface{}{}, &typeList)

	datas := make([]map[string]interface{}, 0)
	headers := make([]string, 0)

	err = sh.ForEachRow(func(r *xlsx.Row) error {
		if r.GetCoordinate() <= 0 {
			err := r.ForEachCell(func(c *xlsx.Cell) error {
				headers = append(headers, c.String())
				return nil
			})
			if err != nil {
				return err
			}
		} else {
			var data models.MatPickWork
			for i, header := range headers {
				value := r.GetCell(i).String()
				switch header {
				case "分类":
					qualityId := 0

					if value == "" {
						qualityId = id
					} else {

						if value == "泥工验收" {
							qualityId = 1
						} else if value == "真实交房验收" {
							qualityId = 2
						} else if value == "特殊交房验收" {
							qualityId = 3
						} else if value == "文明施工（形象）" {
							qualityId = 5
						} else if value == "放样" {
							qualityId = 6
						}
					}

					data.QualityAcceptId = qualityId
				case "名称":
					data.Name = value
				case "内容":
					data.Content = value
				case "施工标准":
					data.Photograph = value
				case "工期":
					data.Days = gconv.Int(value)
				default:
				}
			}

			da := map[string]interface{}{
				"quality_accept_id": data.QualityAcceptId,
				"name":              data.Name,
				"content":           data.Content,
				"photograph":        data.Photograph,
				"days":              data.Days,
			}
			datas = append(datas, da)

		}
		return nil
	})

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

	fmt.Println("dddd", datas)
	db.InsertModels(db.Type(models.WorkQualityAcceptItem{}), datas)
	app.Success(c, nil)
}

// 从URL下载Excel到临时文件，返回*os.File
func downloadExcelFromURL(url string) (*os.File, error) {
	// 1. 发送HTTP请求获取Excel内容
	resp, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	// 检查响应状态
	if resp.StatusCode != http.StatusOK {
		return nil, os.ErrInvalid
	}

	// 2. 创建临时文件（基于URL中的文件名生成临时文件名）
	filename := filepath.Base(url)
	tempFile, err := os.CreateTemp("./", "xlsx_"+filename+"_*.xlsx")
	if err != nil {
		return nil, err
	}

	// 3. 将下载的内容写入临时文件
	_, err = io.Copy(tempFile, resp.Body)
	if err != nil {
		tempFile.Close()
		os.Remove(tempFile.Name()) // 失败时清理临时文件
		return nil, err
	}

	// 关闭临时文件（后续通过xlsx.OpenFile重新打开）
	tempFile.Close()
	return tempFile, nil
}