pm/controllers/mobile/admin.go

package mobile

import (
	"strings"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/config"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/admin"
	"zhiyuan/services/dept"
	"zhiyuan/services/form"
	"zhiyuan/services/mobile"
	"zhiyuan/services/role"

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

func Login(c *gin.Context) {
	var form form.AdminLogin
	if app.Bind(c, &form) != nil {
		return
	}
	token, err := mobile.Login(form.Phone, form.Password)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, map[string]string{
		"token": token,
	})
}

type WorkArrangeItem struct {
	Date int64                  `json:"date"`
	Day  int64                  `json:"day"`
	Type int64                  `json:"type"`
	Item models.WorkArrangeItem `json:"item"`
	Log  *models.WorkArrangeLog `json:"log"`
}

func Info(c *gin.Context) {
	type SettingInfo struct {
		ImgHost  string `json:"img_host"`
		PageSize int    `json:"page_size"`
	}
	type AdminInfo struct {
		ID           int                      `json:"id"`
		UserName     string                   `json:"username"`
		Phone        string                   `json:"phone"`
		RoleIds      string                   `json:"role_ids"`
		RoleName     string                   `json:"role_name"`
		DeptId       int                      `json:"dept_id"`
		DeptName     string                   `json:"dept_name"`
		EntryDate    int64                    `json:"entry_date"`
		RestDay      string                   `json:"rest_day"`
		Setting      SettingInfo              `json:"setting"`
		WorkArranges []WorkArrangeItem        `json:"workarranges"`
		SubAdmins    []map[string]interface{} `json:"sub_admins"`
	}
	var adminInfo AdminInfo
	_, err := admin.GetInfoByID(c.GetInt("adminID"), []string{"id", "username", "phone", "role_ids", "dept_id", "entry_date", "rest_day"}, &adminInfo)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	roleListMap := make(map[int]string)
	if roleList, err := role.GetList(nil, []string{"id, name"}, app.Page{}, nil); err == nil {
		for _, v := range roleList {
			roleListMap[v.ID] = v.Name
		}
	}
	roleNames := ""
	roleSlice := strings.Split(adminInfo.RoleIds, ",")
	for _, vv := range roleSlice {
		roleNames += "," + roleListMap[utils.ToInt(vv)]
	}
	adminInfo.RoleName = strings.TrimLeft(roleNames, ",")
	deptInfo, _ := dept.GetInfoByID(adminInfo.DeptId)
	if deptInfo != nil {
		adminInfo.DeptName = deptInfo.Name
	}
	adminInfo.Setting = SettingInfo{
		ImgHost:  config.Cfg.App.ImgHost,
		PageSize: config.Cfg.App.PageLimitMin,
	}

	query := "SELECT `id`, `username`, `headimgurl` from `zy_admin` where FIND_IN_SET({{adminID}}, `log_ids`) and `entry_date` != 0 and `state` = 1"
	params := make(map[string]interface{})
	params["adminID"] = c.GetInt("adminID")
	admins, _ := db.QueryMap(query, params, nil)
	adminInfo.SubAdmins = admins

	if adminInfo.EntryDate == 0 {
		app.Success(c, adminInfo)
		return
	}

	arranges := make([]models.WorkArrange, 0)
	db.GetModel(map[string]interface{}{
		"state":      1,
		"deleted_at": 0,
	}, &arranges)

	arrangeID := int64(-1)
af:
	for _, v := range arranges {
		arrangeRoles := strings.Split(v.RoleIds, ",")
		for _, arrangeRole := range arrangeRoles {
			for _, role := range roleSlice {
				r1, ok1 := db.ToInt64(arrangeRole)
				r2, ok2 := db.ToInt64(role)
				if r1 == r2 && ok1 && ok2 {
					arrangeID = v.ID
					break af
				}
			}
		}
	}

	if arrangeID < 0 {
		app.Success(c, adminInfo)
		return
	}

	arrangeItems := make([]models.WorkArrangeItem, 0)
	db.GetModel(map[string]interface{}{
		"arrange_id": arrangeID,
		"deleted_at": 0,
	}, &arrangeItems)

	day := int64(0)

	arrangeItemMap := make(map[int64]map[int64]models.WorkArrangeItem)
	for _, item := range arrangeItems {
		if _, ok := arrangeItemMap[item.Day]; !ok {
			arrangeItemMap[item.Day] = make(map[int64]models.WorkArrangeItem)
		}
		arrangeItemMap[item.Day][item.Type] = item
		if item.Day > day {
			day = item.Day
		}
	}

	arrangeLogs := make([]models.WorkArrangeLog, 0)
	arrangeLogMap := make(map[int64]models.WorkArrangeLog)
	db.GetModel(map[string]interface{}{
		"arrange_id": arrangeID,
		"created_id": adminInfo.ID,
		"deleted_at": 0,
	}, &arrangeLogs)
	for _, log := range arrangeLogs {
		arrangeLogMap[log.ItemId] = log
	}

	restDayMap := make(map[int]int)
	restDay := strings.Split(adminInfo.RestDay, ",")
	for _, rest := range restDay {
		if len(rest) == 2 {
			if week, ok := db.ToInt64(string(rest[1])); ok {
				if rest[0] == 'a' {
					restDayMap[int(week)] = 1
				}
				if rest[0] == 'b' {
					restDayMap[int(week)] = 2
				}
			}
		}
	}

	date := time.Unix(adminInfo.EntryDate, 0)
	nowDate := date
	nowDay := int64(1)

	items := make([]WorkArrangeItem, 0)

	for {
		if nowDay > day {
			break
		}

		week := nowDate.Weekday()
		isWeek := 0
		if restDayMap[int(week)] == 2 {
			diff := nowDate.Sub(date)
			weekDiff := int(diff.Hours() / 24 / 7)
			if weekDiff%2 == 0 {
				isWeek = 1
			}
		} else if restDayMap[int(week)] != 1 {
			isWeek = 1
		}

		if isWeek == 1 {
			if arrangeItemType, ok := arrangeItemMap[nowDay]; ok {
				for typ, arrangeItem := range arrangeItemType {
					item := WorkArrangeItem{
						Date: nowDate.Unix(),
						Day:  nowDay,
						Type: typ,
						Item: arrangeItem,
					}
					if log, ok := arrangeLogMap[arrangeItem.ID]; ok {
						item.Log = &log
					}
					items = append(items, item)
				}
			}

			nowDay += 1
		}

		nowDate = nowDate.AddDate(0, 0, 1)
	}

	if len(items) == 0 {
		app.Success(c, adminInfo)
		return
	}
	adminInfo.WorkArranges = items

	app.Success(c, adminInfo)
}

func Logout(c *gin.Context) {
	if err := mobile.Logout(c.GetInt("adminID")); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func Password(c *gin.Context) {
	var form form.Password
	if app.Bind(c, &form) != nil {
		return
	}
	if err := mobile.Password(c.GetInt("adminID"), form); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func WorkArrangeInfo(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.Error(c, "人员id有误")
		return
	}

	var adminInfo *models.Admin
	_, err := admin.GetInfoByID(id, nil, &adminInfo)
	if adminInfo == nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	if adminInfo.EntryDate == 0 {
		app.Success(c, nil)
		return
	}
	roles := strings.Split(adminInfo.RoleIds, ",")

	arranges := make([]models.WorkArrange, 0)
	db.GetModel(map[string]interface{}{
		"state":      1,
		"deleted_at": 0,
	}, &arranges)

	arrangeID := int64(-1)
af:
	for _, v := range arranges {
		arrangeRoles := strings.Split(v.RoleIds, ",")
		for _, arrangeRole := range arrangeRoles {
			for _, role := range roles {
				r1, ok1 := db.ToInt64(arrangeRole)
				r2, ok2 := db.ToInt64(role)
				if r1 == r2 && ok1 && ok2 {
					arrangeID = v.ID
					break af
				}
			}
		}
	}

	if arrangeID < 0 {
		app.Success(c, nil)
		return
	}

	arrangeItems := make([]models.WorkArrangeItem, 0)
	db.GetModel(map[string]interface{}{
		"arrange_id": arrangeID,
		"deleted_at": 0,
	}, &arrangeItems)

	day := int64(0)

	arrangeItemMap := make(map[int64]map[int64]models.WorkArrangeItem)
	for _, item := range arrangeItems {
		if _, ok := arrangeItemMap[item.Day]; !ok {
			arrangeItemMap[item.Day] = make(map[int64]models.WorkArrangeItem)
		}
		arrangeItemMap[item.Day][item.Type] = item
		if item.Day > day {
			day = item.Day
		}
	}

	arrangeLogs := make([]models.WorkArrangeLog, 0)
	arrangeLogMap := make(map[int64]models.WorkArrangeLog)
	db.GetModel(map[string]interface{}{
		"arrange_id": arrangeID,
		"created_id": adminInfo.ID,
		"deleted_at": 0,
	}, &arrangeLogs)
	for _, log := range arrangeLogs {
		arrangeLogMap[log.ItemId] = log
	}

	restDayMap := make(map[int]int)
	restDay := strings.Split(adminInfo.RestDay, ",")
	for _, rest := range restDay {
		if len(rest) == 2 {
			if week, ok := db.ToInt64(string(rest[1])); ok {
				if rest[0] == 'a' {
					restDayMap[int(week)] = 1
				}
				if rest[0] == 'b' {
					restDayMap[int(week)] = 2
				}
			}
		}
	}

	date := time.Unix(adminInfo.EntryDate, 0)
	nowDate := date
	nowDay := int64(1)

	items := make([]WorkArrangeItem, 0)

	for {
		if nowDay > day {
			break
		}

		week := nowDate.Weekday()
		isWeek := 0
		if restDayMap[int(week)] == 2 {
			diff := nowDate.Sub(date)
			weekDiff := int(diff.Hours() / 24 / 7)
			if weekDiff%2 == 0 {
				isWeek = 1
			}
		} else if restDayMap[int(week)] != 1 {
			isWeek = 1
		}

		if isWeek == 1 {
			if arrangeItemType, ok := arrangeItemMap[nowDay]; ok {
				for typ, arrangeItem := range arrangeItemType {
					item := WorkArrangeItem{
						Date: nowDate.Unix(),
						Day:  nowDay,
						Type: typ,
						Item: arrangeItem,
					}
					if log, ok := arrangeLogMap[arrangeItem.ID]; ok {
						item.Log = &log
					}
					items = append(items, item)
				}
			}

			nowDay += 1
		}

		nowDate = nowDate.AddDate(0, 0, 1)
	}

	if len(items) == 0 {
		app.Success(c, nil)
		return
	}

	app.Success(c, gin.H{
		"username": adminInfo.Username,
		"items":    items,
	})
}