pm/controllers/admin/daily.go

package admin

import (
	"fmt"
	"strings"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"

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

func DailyImport(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
	}

	for typ, sh := range wb.Sheet {
		datas := make([]map[string]interface{}, 0)
		headers := make([]string, 0)
		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 {
				data := make(map[string]interface{}, 0)
				data["type"] = typ
				content := ""
				for i, header := range headers {
					value := r.GetCell(i).String()
					switch header {
					case "工号":
						data["number"] = value
					case "填报人":
						data["name"] = value
					case "部门":
						data["dept"] = value
					case "填报时间":
						t, _ := time.ParseInLocation("2006年01月02日 15:04", value, time.Local)
						data["ctime"] = t.Unix()
					case "最后一次修改时间":
						t, _ := time.ParseInLocation("2006年01月02日 15:04", value, time.Local)
						data["utime"] = t.Unix()
					default:
						content += header + "\n" + value + "\n"
					}
				}
				data["content"] = content
				datas = append(datas, data)
			}
			return nil
		})
		db.InsertModels(db.Type(models.Daily{}), datas)
	}
	app.Success(c, nil)
}

func DailyAdminImport(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
	}

	for _, sh := range wb.Sheet {
		datas := make([]map[string]interface{}, 0)
		headers := make([]string, 0)
		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 {
				data := make(map[string]interface{}, 0)
				for i, header := range headers {
					value := r.GetCell(i).String()
					switch header {
					case "姓名":
						data["name"] = value
					case "岗位":
						data["post"] = value
					}
				}
				datas = append(datas, data)
			}
			return nil
		})
		db.InsertModels(db.Type(models.DailyAdmin{}), datas)
	}
	app.Success(c, nil)
}

func DailyStatist(c *gin.Context) {
	var post map[string]interface{}
	if err := c.ShouldBindJSON(&post); err != nil {
	}

	var statistType models.DailyStatistType
	db.GetModel(map[string]interface{}{"id": post["typeId"]}, &statistType)
	if statistType.ID == 0 {
		app.ErrorMsg(c, "统计类型不存在", nil)
		return
	}

	startTime, ok1 := db.ToInt64(post["startTime"])
	endTime, ok2 := db.ToInt64(post["endTime"])
	if !ok1 || !ok2 {
		app.ErrorMsg(c, "参数错误", nil)
		return
	}

	times := make([]int64, 0)
	t := time.Unix(startTime, 0)
	switch statistType.Statist {
	case 0:
		t = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
	case 1:
		t = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local).AddDate(0, 0, int(time.Monday-t.Weekday()))
	case 2:
		t = time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, time.Local)
	}
	for t.Unix() < endTime+24*60*60 {
		times = append(times, t.Unix())
		switch statistType.Statist {
		case 0:
			t = t.AddDate(0, 0, 1)
		case 1:
			t = t.AddDate(0, 0, 7)
		case 2:
			t = t.AddDate(0, 1, 0)
		}
	}

	s := db.ModelQuery(db.Type(models.DailyStatist{}), post, false)
	timeSelects := make([]string, 0)
	for _, t := range times {
		timeSelects = append(timeSelects, fmt.Sprintf("select %d as `time`", t))
	}
	s.TableName = fmt.Sprintf("(%s) as `date`", strings.Join(timeSelects, " union "))
	s.InnerJoin = []db.Join{
		{
			models.DailyStatistPost{}.TableName(),
			"post",
			[]string{
				"`post`.`deleted_at` = 0",
				fmt.Sprintf("`post`.`typeId` = %s", s.Param(post["typeId"])),
			},
		},
		{
			models.DailyAdmin{}.TableName(),
			"admin",
			[]string{
				"`admin`.`deleted_at` = 0",
				"FIND_IN_SET(`admin`.`post`, `post`.`posts`)",
			},
		},
	}
	timeField := "`date`.`time`"
	if statistType.Statist == 2 {
		timeField = "IF(WEEKDAY(from_unixtime(`date`.`time`))>3, `date`.`time` + 24 * 3600 * (7 - WEEKDAY(from_unixtime(`date`.`time`))), `date`.`time` - 24 * 3600 * WEEKDAY(from_unixtime(`date`.`time`)))"
	}
	s.LeftJoin = []db.Join{
		{
			models.Daily{}.TableName(),
			"daily",
			[]string{
				"`daily`.`deleted_at` = 0",
				"`daily`.`name` = `admin`.`name`",
				fmt.Sprintf("FIND_IN_SET(`daily`.`type`, %s)", s.Param(statistType.Types)),
				fmt.Sprintf("`daily`.`ctime` >= (%s + `post`.`starthour` * 3600)", timeField),
				fmt.Sprintf("`daily`.`ctime` < (%s + `post`.`endhour` * 3600)", timeField),
			},
		},
	}
	s.GroupBy = "`date`.`time`, `post`.`id`, `admin`.`id`"
	if s.OrderBy == "``.`id` DESC" {
		s.OrderBy = "`date`.`time`, `admin`.`id` DESC"
	}
	query, params := s.Query()
	list, err := db.QueryMap(query, params, models.Daily{}.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,
	}
	count, err := db.GetCount(s, models.Daily{}.DB())
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	data["count"] = count
	app.Success(c, data)
}