enterprise/worker/staff.go

package worker

import (
	"enterprise/common/dao"
	"enterprise/common/global"
	"enterprise/common/model"
	"enterprise/common/registry"
	"enterprise/service"
	"fmt"
	log "github.com/sirupsen/logrus"
	"github.com/spf13/cast"
	"strings"
	"time"
)

type Staff struct {
}

func NewStaff() *Staff {
	return &Staff{}
}
func (s *Staff) MontorWorkAge(corpId int64) {
	corp, err := dao.NewCorpDao().Get(corpId)
	if err != nil {
		log.Errorf("db error :%s", err.Error())
		return
	}
	if corp == nil {
		log.Errorf("corp[%d] is nil", corpId)
		return
	}

	staffs, _, err := dao.NewStaffUserDao().Query(1, -1, corpId, model.StaffUserStatusOnline, "", "", "", "")
	if err != nil {
		log.Errorf("db error :%s", err.Error())
		return
	}

	staffPlugin := registry.NewStaff(corp)

	for _, staff := range staffs {
		//离职的忽略
		if staff.LeaveDate != "" || staff.Status != model.StaffUserStatusOnline {
			continue
		}
		if staffPlugin != nil {
			staffPlugin.Monitor(staff)
		}
	}
}

func (s *Staff) SendStaffSalaryBill(corpId int64, month string) {
	staffSalarys, err := dao.NewStaffSalaryDao().QueryAll(corpId, month, model.StaffSalaryStatusPayed)
	//staffSalarys, err := dao.NewStaffSalaryDao().QueryAll(corpId, month, 0)
	if err != nil {
		log.Errorf("db error :%s", err.Error())
		return
	}

	corp, err := dao.NewCorpDao().Get(corpId)
	if err != nil || corp == nil {
		log.Errorf("corp is nil")
		return
	}
	salaryDay := cast.ToInt(corp.GetConfig().SalaryDay)

	totalMessage := make([]string, 0)
	totalMessage = append(totalMessage, fmt.Sprintf("【工资单】[%s]", month))
	for _, staffSalary := range staffSalarys {
		if staffSalary.Salary < 0.1 {
			continue
		}

		staffUser, err := dao.NewStaffUserDao().Get(staffSalary.UserId)
		if err != nil {
			log.Errorf("db error :%s", err.Error())
			continue
		}

		if time.Now().Day() != salaryDay {
			continue
		}
		if staffSalary.Status != model.StaffSalaryStatusPayed && staffUser.GetConfig().PayChannel != model.StaffSalaryPaymentBank {
			continue
		}
		totalMessage = append(totalMessage, fmt.Sprintf(`%s：<a href="%s">查看明细</a>`, staffSalary.Username, staffSalary.GetBillUrl(true)))
		message := make([]string, 0)
		message = append(message, fmt.Sprintf("【工资单】[%s][%s]", staffUser.Username, month))
		message = append(message, fmt.Sprintf("实发工资：%.2f", staffSalary.GetRealSalary()))
		message = append(message, fmt.Sprintf(`<a href="%s">查看明细</a>`, staffSalary.GetBillUrl(false)))
		if err := global.SendCorpMessage(staffUser.CorpId, []string{staffSalary.Username}, strings.Join(message, "\n")); err != nil {
			log.Errorf("send message error :%s", err.Error())
		}
	}

	if err := global.SendCorpMessage(corpId, []string{"jiangyong"}, strings.Join(totalMessage, "\n")); err != nil {
		log.Errorf("send message error :%s", err.Error())
	}
}

func (s *Staff) PayStaffSalary(corpId int64, month string) {
	staffSalarys, err := dao.NewStaffSalaryDao().QueryAll(corpId, month, model.StaffSalaryStatusWait)
	if err != nil {
		log.Errorf("db error :%s", err.Error())
		return
	}

	corp, err := dao.NewCorpDao().Get(corpId)
	if err != nil {
		log.Errorf("db error :%s", err.Error())
		return
	}
	totalPayFee := float64(0)
	message := make([]string, 0)
	message = append(message, fmt.Sprintf("【支付宝工资发放】[%s]", month))
	for _, staffSalary := range staffSalarys {
		if staffSalary.Salary < 0.1 {
			continue
		}

		staffUser, err := dao.NewStaffUserDao().Get(staffSalary.UserId)
		if err != nil {
			log.Errorf("db error :%s", err.Error())
			continue
		}
		if staffUser.GetConfig().PayChannel != model.StaffSalaryPaymentAlipay {
			continue
		}
		if staffSalary.Status == model.StaffSalaryStatusPayed {
			continue
		}

		salaryDay := cast.ToInt(corp.GetConfig().SalaryDay)
		isSend := time.Now().Day() == salaryDay

		if isSend || staffUser.Username == "jiangyong" {
			err = service.NewPay().Pay(corp, staffUser,
				fmt.Sprintf("[%s]工资", staffSalary.Month),
				model.StaffSalaryPaymentAlipay,
				int64(100*staffSalary.GetRealSalary()),
				staffSalary.GetOutTradeNo())
			if err == nil {
				staffSalary.Status = model.StaffSalaryStatusPayed
				message = append(message, fmt.Sprintf("[%s]：%.2f", staffSalary.Username, staffSalary.GetRealSalary()))
				totalPayFee += staffSalary.GetRealSalary()
			} else {
				message = append(message, fmt.Sprintf("[%s]：ERR", staffSalary.Username))
				staffSalary.SetExtra("pay_error", err.Error())
			}
			dao.NewStaffSalaryDao().Update(staffSalary)
		}
	}

	message = append(message, fmt.Sprintf("汇总：%.2f", totalPayFee))
	if err := global.SendCorpMessage(corpId, []string{"jiangyong"}, strings.Join(message, "\n")); err != nil {
		log.Errorf("send message error :%s", err.Error())
	}
}

func (s *Staff) SyncStaffSalary(corpId int64, month string) {
	if month == "" {
		month = time.Now().AddDate(0, -1, 0).Format("2006-01")
	}
	month = strings.ReplaceAll(month, "-", "")

	staffs, _, err := dao.NewStaffUserDao().Query(1, -1, corpId, 0, "", "", "", "")
	if err != nil {
		log.Errorf("query staff db error :%s", err.Error())
		return
	}
	for _, staff := range staffs {
		salary, err := dao.NewStaffSalaryDao().GetBy(corpId, staff.Id, month)
		if err != nil {
			log.Errorf("db error :%s", err.Error())
			continue
		}

		staffService := service.NewStaffSalary(staff)
		salary, err = staffService.CalcSalary(salary, month, "")
		if err != nil {
			log.Errorf("username[%s] staffService.CalcSalary error :%s", staff.Username, err.Error())
			continue
		}
		if salary == nil {
			continue
		}

		if salary.Id == 0 {
			_, err = dao.NewStaffSalaryDao().Create(salary)
		} else {
			err = dao.NewStaffSalaryDao().Update(salary)
		}
		if err != nil {
			log.Errorf("db error :%s", err.Error())
		}
	}

}