yintai2/app/admin/service/job.go

package service

import (
	"slices"
	"strings"
	"time"
	"yintai-api/app/admin/request"
	"yintai-api/app/common/consts"
	"yintai-api/app/common/dao"
	err2 "yintai-api/app/common/err"
	"yintai-api/app/common/model"
	"yintai-api/base/global"

	"github.com/spf13/cast"
	"gorm.io/gorm"
)

type Job struct{}

func (r *Job) Create(req request.JobCreate) int64 {
	m := new(model.Job)
	m.RecruitCount = cast.ToInt64(req.RecruitCount)
	m.City = req.City
	m.JobType = cast.ToInt64(req.JobType)
	m.JobArea = cast.ToInt64(req.JobArea)
	m.JobUnit = cast.ToInt64(req.JobUnit)
	m.CreateTime = time.Now().Unix()

	ms := make([]*model.JobTranslations, 0)
	for lang, trans := range req.Translations {
		lang = strings.ToUpper(lang)
		if !slices.Contains(consts.LangSupport, lang) {
			continue
		}

		temp := &model.JobTranslations{
			Lang:         lang,
			Name:         trans.Name,
			Description:  trans.Desc,
			Requirement:  trans.Requirement,
			ContractInfo: trans.ContractInfo,
		}
		ms = append(ms, temp)
	}

	err := global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err := dao.NewJob(tx).Create(m); err != nil {
			return err
		}

		for _, trans := range ms {
			trans.JobID = m.ID
			if err := dao.NewJobTranslations(tx).Create(trans); err != nil {
				return err
			}
		}

		if err := BizCateCreate(tx, m.ID, cast.ToInt64(req.JobType), model.CateTypeJobType); err != nil {
			return err
		}

		if err := BizCateCreate(tx, m.ID, cast.ToInt64(req.JobArea), model.CateTypeJobArea); err != nil {
			return err
		}

		if err := BizCateCreate(tx, m.ID, cast.ToInt64(req.JobUnit), model.CateTypeJobUnit); err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return m.ID
}

func (r *Job) Update(req request.JobUpdate) {
	m, err := dao.NewJob().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	if cast.ToInt64(req.RecruitCount) != 0 {
		m.RecruitCount = cast.ToInt64(req.RecruitCount)
	}

	if req.City != "" {
		m.City = req.City
	}
	m.UpdateTime = time.Now().Unix()

	ms := make([]*model.JobTranslations, 0)
	for lang, trans := range req.Translations {
		lang = strings.ToUpper(lang)
		if !slices.Contains(consts.LangSupport, lang) {
			continue
		}

		t := new(model.JobTranslations)
		if t, err = dao.NewJobTranslations().GetByMaster(m.ID, lang); err != nil {
			err2.DbErr(err)
		}

		if trans.Name != "" {
			t.Name = trans.Name
		}

		if trans.Desc != "" {
			t.Description = trans.Desc
		}

		if trans.Requirement != "" {
			t.Requirement = trans.Requirement
		}

		if trans.ContractInfo != "" {
			t.ContractInfo = trans.ContractInfo
		}

		ms = append(ms, t)
	}

	err = global.GetDB().Transaction(func(tx *gorm.DB) error {
		for _, trans := range ms {
			if err = dao.NewJobTranslations(tx).Update(trans); err != nil {
				return err
			}
		}

		if v := cast.ToInt64(req.JobType); v > 0 {
			m.JobType = v
			if err = BizCateUpdate(tx, m.ID, v, model.CateTypeJobType); err != nil {
				return err
			}
		}

		if v := cast.ToInt64(req.JobArea); v > 0 {
			m.JobArea = v
			if err = BizCateUpdate(tx, m.ID, v, model.CateTypeJobArea); err != nil {
				return err
			}
		}

		if v := cast.ToInt64(req.JobUnit); v > 0 {
			m.JobUnit = v
			if err = BizCateUpdate(tx, m.ID, v, model.CateTypeJobUnit); err != nil {
				return err
			}
		}

		if err = dao.NewJob(tx).Update(m); err != nil {
			return err
		}
		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return
}

func (r *Job) Delete(req request.JobDelete) {
	m, err := dao.NewJob().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	err = global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = dao.NewJob().Delete(m.ID); err != nil {
			return err
		}

		if err = dao.NewJobTranslations(tx).Delete(m.ID); err != nil {
			return err
		}

		if err = dao.NewCategoryRelation(tx).DeleteByCondition(m.ID, model.CateTypeJob); err != nil {
			return err
		}

		for _, t := range model.CateJobTypes {
			if err = dao.NewCategoryRelation(tx).DeleteByCondition(m.ID, t); err != nil {
				return err
			}
		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return
}

func (r *Job) List(req request.JobList) (any, int64) {
	req.Pagination()
	lists, count, err := dao.NewJob().List(req.Lang, req.City, req.Title, req.Desc, req.Reqs, req.JobType, req.JobArea, req.JobUnit, req.Page, req.Size, req.Sort)
	if err != nil {
		err2.DbErr(err)
	}
	res := make([]map[string]any, 0)
	for _, list := range lists {
		temp := list.Format()
		temp["category"] = r.GetCate(list)[list.Lang]
		res = append(res, temp)
	}

	return res, count
}

func (r *Job) Get(req request.JobDelete) any {
	res := make(map[string]any)
	for _, lang := range consts.LangSupport {
		x, err := dao.NewJob().GetLang(cast.ToInt64(req.ID), lang)
		if err != nil {
			err2.DbErr(err)
		}

		if x == nil {
			res[lang] = make(map[string]any)
			continue
		}

		format := x.Format()
		format["category"] = r.GetCate(x)[x.Lang]
		res[lang] = format
	}

	return res
}

func (r *Job) GetCate(params *model.JobPage) map[string]map[string]any {
	// type:id
	s := map[string]int64{
		model.CateTypeJobType: params.JobType,
		model.CateTypeJobArea: params.JobArea,
		model.CateTypeJobUnit: params.JobUnit,
	}

	res := make(map[string]map[string]any)

	for t, id := range s {
		x, err := dao.NewCategory().GetWithType(id, t)
		if err != nil {
			err2.DbErr(err)
		}

		if x == nil {
			x = new(model.Category)
		}

		for _, lang := range consts.LangSupport {
			name := ""
			switch lang {
			case consts.LangZH:
				name = x.Name
			case consts.LangEN:
				name = x.NameEn
			}
			if _, ok := res[lang]; !ok {
				res[lang] = make(map[string]any)
			}

			res[lang][t] = x.ID
			res[lang][t+"_name"] = name
		}
	}

	return res
}