back/internal/v2/logic/company/company.go

package company

import (
	"fmt"
	"recook/internal/define"
	"recook/internal/libs/bean"
	"recook/internal/service/baseCode"
	"recook/internal/v2/model/company"
	"recook/internal/v2/model/recook/manage"
	"recook/internal/v2/model/recook/user"
	"strings"
	"time"

	"git.oa00.com/go/mysql"
	"github.com/golangkit/formatime"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

type logic struct {
}

var Logic = &logic{}

type ArgsCompanyList struct {
	bean.Page
	Name          string `json:"name"`
	Mobile        string `json:"mobile"`
	Contract      string `json:"contract"`
	ApplyUserName string `json:"apply_user_name"`
	State         int    `json:"state"`
	Status        int    `json:"status"`
	Start         string `json:"start"`
	End           string `json:"end"`
}

func (o logic) List(args ArgsCompanyList) (res []company.Info, total int64, err error) {
	query := mysql.Db.Table((&company.Info{}).TableName())
	{
		if args.Name != "" {
			query = query.Where("company_name like ?", fmt.Sprintf("%%%s%%", args.Name))
		}
		if args.Mobile != "" {
			query = query.Where("mobile=?", args.Mobile)
		}
		if args.Contract != "" {
			query = query.Where("contract_name like ?", fmt.Sprintf("%%%s%%", args.Contract))
		}

		if args.Start != "" {
			query = query.Where("created_at > ?", args.Start)
		}
		if args.End != "" {
			query = query.Where("created_at < ?", args.End)
		}
		if args.ApplyUserName != "" {
			sub := mysql.Db.Table((&manage.RecookManageUserInfoModel{}).TableName()).Select("id").Where("name like ?", fmt.Sprintf("%%%s%%", args.Name))
			query = query.Where("apply_user_id in (?)", sub)
		}
	}
	query.Count(&total)
	query.Preload(clause.Associations).Preload("Logs.ManageUserInfo").Offset(args.GetStart()).Limit(args.GetLimit()).Find(&res)
	for i, v := range res {
		var u1 user.RecookUserInfoModel
		mysql.Db.First(&u1, "id = ?", v.UserID)
		if u1.Id == 0 {
			continue
		}
		mysql.Db.Table(u1.TableName()).Where("root_id = ? and level = 2", u1.Id).Count(&res[i].Count)
	}
	return
}

type ArgsShopList struct {
	bean.Page
	ID     uint   `json:"id"  validate:"required"`
	Name   string `json:"name"`
	Mobile string `json:"mobile"`
	Kind   uint   `json:"kind"`
	Start  string `json:"start"`
	End    string `json:"end"`
}

type ShopEntry struct {
	ID         uint             `json:"id"`
	Name       string           `json:"name"`
	Mobile     string           `json:"mobile"`
	Level      uint             `json:"level,omitempty"`
	Count      int64            `json:"count,omitempty"`
	UpdateTime formatime.Second `json:"update_time"`
}

func (o logic) ShopList(args ArgsShopList) (res []ShopEntry, total int64, err error) {
	var cm company.Info
	if err = mysql.Db.First(&cm, "id = ?", args.ID).Error; err != nil {
		return
	}

	query := mysql.Db.Table((&user.RecookUserInfoModel{}).TableName()).Where("root_id = ? and level = 2", cm.UserID)
	{
		if args.Name != "" {
			query = query.Where("nickname like ?", fmt.Sprintf("%%%s%%", args.Name))
		}
		if args.Mobile != "" {
			query = query.Where("mobile = ?", args.Mobile)
		}
		switch args.Kind {
		case 1:
			query = query.Where("level = 2 and is_offline = 0")
		case 2:
			query = query.Where("level = 2 and is_offline = 1")
		}

		if args.Start != "" {
			query = query.Where("update_time2 > ?", args.Start)
		}
		if args.End != "" {
			query = query.Where("update_time2 < ?", args.End)
		}
	}
	query.Count(&total)
	temp := make([]user.RecookUserInfoModel, 0)
	query.Limit(args.GetLimit()).Offset(args.GetStart()).Find(&temp)
	for _, v := range temp {
		level := 2
		if v.IsOffline {
			level = 3
		}
		obj := ShopEntry{
			ID:         v.Id,
			Name:       v.Nickname,
			Level:      uint(level),
			Count:      0,
			UpdateTime: v.UpgradeTime2,
		}
		mysql.Db.Table((&user.RecookUserInfoModel{}).TableName()).Where("parent_id = ?", v.Id).Count(&obj.Count)
		res = append(res, obj)
	}
	return
}

func (o logic) MasterList(args ArgsShopList) (res []ShopEntry, total int64, err error) {
	query := mysql.Db.Table((&user.RecookUserInfoModel{}).TableName()).Where("parent_id = ? and level = 1", args.ID)
	{
		if args.Name != "" {
			query = query.Where("nickname like ?", fmt.Sprintf("%%%s%%", args.Name))
		}
		if args.Mobile != "" {
			query = query.Where("mobile = ?", args.Mobile)
		}

		if args.Start != "" {
			query = query.Where("update_time1 > ?", args.Start)
		}
		if args.End != "" {
			query = query.Where("update_time1 < ?", args.End)
		}
	}
	query.Count(&total)
	temp := make([]user.RecookUserInfoModel, 0)
	query.Limit(args.GetLimit()).Offset(args.GetStart()).Find(&temp)
	for _, v := range temp {
		obj := ShopEntry{
			ID:         v.Id,
			Name:       v.Nickname,
			Mobile:     v.Mobile,
			Level:      0,
			Count:      0,
			UpdateTime: v.UpgradeTime1,
		}
		res = append(res, obj)
	}
	return
}

func (o logic) All() (res []string) {
	mysql.Db.Table((&company.Info{}).TableName()).Pluck("company_name", &res)
	return
}

type CompanySureApply struct {
	ID     uint `json:"id" validate:"required`
	UserID uint `json:"-"`
}

func (o logic) Sure(args CompanySureApply) error {
	if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
		var obj company.Info
		if err := tx.First(&obj, "id = ?", args.ID).Error; err != nil {
			return err
		}
		if err := tx.Model(&obj).Updates(company.Info{
			State:         company.Pass,
			ProcessUserID: args.UserID,
			ProcessTime:   formatime.NewSecondNow(),
		}).Error; err != nil {
			return err
		}
		if err := tx.Create(&company.Log{
			Text:      fmt.Sprintf("审核通过,并创建账号%s", obj.Mobile),
			UserID:    args.UserID,
			CreatedAt: formatime.NewSecondNow(),
			CompanyID: args.ID,
		}).Error; err != nil {
			return err
		}
		var u1 user.RecookUserInfoModel
		if err := tx.First(&u1, "moblie = ?", obj.Mobile).Error; err != nil {
			return err
		}
		if u1.Id > 0 {
			return fmt.Errorf("该账号已存在")
		} else {
			mobile := obj.Mobile
			sql := `select max(id)+floor(1+rand()*5) from recook_user_info`
			var lastId int64
			if err := tx.Raw(sql).Count(&lastId).Error; err != nil {
				return err
			}
			info := user.RecookUserInfoModel{
				Id:         uint(lastId),
				Nickname:   "左家右厨" + mobile[7:],
				Mobile:     mobile,
				Birthday:   formatime.NewSecondFrom(define.DefaultBirthday),
				HeadImgUrl: "",
				Phone:      mobile,
				Identifier: time.Now().Format("060102") + baseCode.Encode(uint64(lastId)),
				Level:      10,
				ParentID:   0,
				RootID:     0,
			}

			if err := tx.Create(&info).Error; err != nil {
				tx.Rollback()
				err = fmt.Errorf("创建用户错误101:" + err.Error())
				return err
			}

			//  生成邀请码和推荐码
			info.InvitationNo = baseCode.Encode(uint64(info.Id))
			if err := tx.Save(&info).Error; err != nil {
				err = fmt.Errorf("创建用户错误102:" + err.Error())
				return err
			}
			//	建立钱包
			wallet := user.RecookUserWalletModel{
				UserId: info.Id,
			}
			if err := tx.Create(&wallet).Error; err != nil {
				tx.Rollback()
				err = fmt.Errorf("创建用户错误103:" + err.Error())
				return err
			}

			if err := tx.Model(&obj).Updates(company.Info{
				UserID: uint(lastId),
			}).Error; err != nil {
				return err
			}
		}

		return nil
	}); err != nil {
		return err
	}
	return nil
}

type CompanyRejectApply struct {
	CompanySureApply
	Reason string `json:"reason" validate:"required,maxLen=20"`
}

func (o logic) Reject(args CompanyRejectApply) error {
	if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
		var obj company.Info
		if err := tx.First(&obj, "id = ?", args.ID).Error; err != nil {
			return err
		}
		if err := tx.Model(&obj).Updates(company.Info{
			State:         company.Reject,
			ProcessUserID: args.UserID,
			ProcessTime:   formatime.NewSecondNow(),
		}).Error; err != nil {
			return err
		}
		if err := tx.Create(&company.Log{
			Text:      args.Reason,
			UserID:    args.UserID,
			CreatedAt: formatime.NewSecondNow(),
			CompanyID: args.ID,
		}).Error; err != nil {
			return err
		}
		return nil
	}); err != nil {
		return err
	}
	return nil
}

type CompanyInfo struct {
	company.Info
	UserID uint `json:"user_id"`
}

func (o logic) Apply(args CompanyInfo) error {
	if args.ID != 0 {
		args.State = company.Wait
		if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
			if err := tx.Table((&company.Info{}).TableName()).Where("id = ?", args.ID).Updates(args).Error; err != nil {
				return err
			}
			return nil
		}); err != nil {
			return err
		}
	} else {
		if len(args.Mobile) != 11 || !strings.HasPrefix(args.Mobile, "1") {
			return fmt.Errorf("手机格式不合法")
		}
		var u1 user.RecookUserInfoModel
		mysql.Db.First(&u1, "mobile = ?", args.Mobile)
		if u1.Id > 0 {
			return fmt.Errorf("手机已存在")
		}
		args.State = company.Wait
		args.CreatedAt = formatime.NewSecondNow()
		args.Logs = nil
		args.ID = 0
		if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
			if err := tx.Create(&args).Error; err != nil {
				return err
			}
			if err := tx.Create(&company.Log{
				Text:      "发起了申请",
				UserID:    args.UserID,
				CreatedAt: formatime.NewSecondNow(),
				CompanyID: args.ID,
			}).Error; err != nil {
				return err
			}

			return nil
		}); err != nil {
			return err
		}
	}

	return nil
}