chcckin

common/config/error.go

@@ -7,9 +7,14 @@ var (
 	// 系统错误码
 	ErrOK = errors.T(0, "操作成功")
 
-	ErrPriv     = errors.T(196, "没有权限")
+	ErrPriv         = errors.T(196, "没有权限")
-	ErrDb       = errors.T(197, "数据库错误")
+	ErrDb           = errors.T(197, "数据库错误")
-	ErrRemote   = errors.T(198, "第三方错误")
+	ErrRemote       = errors.T(198, "第三方错误")
-	ErrInternal = errors.T(199, "内部错误")
+	ErrInternal     = errors.T(199, "内部错误")
-	ErrParam    = errors.T(400, "参数错误")
+	ErrParam        = errors.T(400, "参数错误")
+	ErrNoData       = errors.T(401, "没有数据")
+	ErrTokenExpire  = errors.T(402, "登录过期")    //客户端有特殊逻辑勿动，跳转登录页
+	ErrTokenInvaild = errors.T(403, "TOKEN无效") //客户端有特殊逻辑勿动，跳转登录页
+	ErrNoToken      = errors.T(404, "没有TOKEN") //客户端有特殊逻辑勿动，跳转登录页
+	ErrNoPerm       = errors.T(405, "没有权限")
 )

common/dao/checkin.go

@@ -110,3 +110,27 @@ func (d *CheckinDao) QueryDay(corpId int64, day string) ([]*model.Checkin, error
 	}
 	return u, nil
 }
+
+func (d *CheckinDao) QueryAdmin(page, size int, corpId int64, username, startDay, endDay string) ([]*model.Checkin, int64, error) {
+	tx := GetDB().Table(d.TableName())
+	tx = tx.Where("corp_id = ?", corpId)
+	if startDay != "" {
+		tx = tx.Where("day >= ?", startDay)
+	}
+	if endDay != "" {
+		tx = tx.Where("day <= ?", endDay)
+	}
+	if username != "" {
+		tx = tx.Where("username = ?", username)
+	}
+	var count int64
+	tx.Count(&count)
+
+	tx.Offset((page - 1) * size).Limit(size)
+	var u []*model.Checkin
+	tx = tx.Find(&u)
+	if tx.Error != nil {
+		return nil, 0, tx.Error
+	}
+	return u, count, nil
+}

common/dao/staff_token.go

@@ -0,0 +1,81 @@
+package dao
+
+import (
+	"enterprise/common/model"
+	"github.com/smbrave/goutil"
+	"gorm.io/gorm"
+	"time"
+)
+
+type StaffTokenDao struct {
+}
+
+func NewStaffTokenDao() *StaffTokenDao {
+	return &StaffTokenDao{}
+}
+
+func (d *StaffTokenDao) TableName() string {
+	return "staff_token"
+}
+
+func (d *StaffTokenDao) Create(o *model.StaffToken) (int64, error) {
+	o.CreateTime = time.Now().Unix()
+	res := GetDB().Table(d.TableName()).Create(o)
+	return o.Id, res.Error
+}
+
+func (d *StaffTokenDao) Update(o *model.StaffToken, fields ...string) error {
+	tx := GetDB().Table(d.TableName())
+	tx.Where("id = ?", o.Id)
+	if len(fields) == 0 {
+		res := tx.Save(o)
+		return res.Error
+	}
+
+	dat := goutil.ModelFieldValue(o, fields...)
+	return tx.Updates(dat).Error
+}
+
+func (d *StaffTokenDao) Delete(id int64) error {
+	res := GetDB().Table(d.TableName()).Delete(&model.StaffToken{}, id)
+	return res.Error
+}
+
+func (d *StaffTokenDao) Get(id int64) (*model.StaffToken, error) {
+	var u model.StaffToken
+	tx := GetDB().Table(d.TableName())
+	tx = tx.Where("id = ?", id)
+	res := tx.First(&u)
+	if res.Error == gorm.ErrRecordNotFound {
+		return nil, nil
+	}
+
+	if res.Error != nil {
+		return nil, res.Error
+	}
+	return &u, nil
+}
+
+func (d *StaffTokenDao) GetByToken(token string) (*model.StaffToken, error) {
+	var o model.StaffToken
+	tx := GetDB().Table(d.TableName())
+	tx = tx.Where("token = ?", token)
+	res := tx.First(&o)
+
+	if res.Error == gorm.ErrRecordNotFound {
+		return nil, nil
+	}
+
+	if res.Error != nil {
+		return nil, res.Error
+	}
+	return &o, nil
+}
+
+func (d *StaffTokenDao) DeleteHistory(lastDay int) (int64, error) {
+	tx := GetDB().Table(d.TableName())
+	deleteTime := time.Now().AddDate(0, 0, 0-lastDay).Unix()
+	tx.Where("expire_time <= ?", deleteTime)
+	tx.Delete(&model.StaffToken{})
+	return tx.RowsAffected, tx.Error
+}

common/model/staff_salary.go

@@ -12,7 +12,7 @@ type StaffSalary struct {
 	Id             int64
 	CorpId         int64
 	UserId         int64
-	UserName       string
+	Username       string
 	Month          string
 	Salary         float64
 	AttendSalary   float64

common/model/staff_token.go

@@ -0,0 +1,9 @@
+package model
+
+type StaffToken struct {
+	Id         int64
+	UserId     int64
+	Token      string
+	CreateTime int64
+	ExpireTime int64
+}

common/session/base.go

@@ -0,0 +1,111 @@
+package session
+
+import (
+	"encoding/json"
+	"enterprise/common/config"
+	"github.com/smbrave/goutil"
+	"reflect"
+)
+
+type BaseResponse struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+type CommonResponse struct {
+	BaseResponse
+	Data interface{} `json:"data"`
+}
+
+type RawResponse struct {
+	BaseResponse
+	Data json.RawMessage `json:"data"`
+}
+
+type ListResponse struct {
+	BaseResponse
+	Data struct {
+		Total       int64       `json:"total"`
+		TotalAmount string      `json:"total_amount,omitempty"`
+		TotalSize   string      `json:"total_size,omitempty"`
+		Items       interface{} `json:"items"`
+	} `json:"data,omitempty"`
+}
+
+var (
+	rspOk *BaseResponse
+)
+
+func init() {
+	rspOk = new(BaseResponse)
+	rspOk.Message = "OK"
+	rspOk.Code = 0
+}
+
+func NewRspOk() *BaseResponse {
+	return rspOk
+}
+
+func NewRawRsp(raw []byte) *RawResponse {
+	rsp := &RawResponse{
+		BaseResponse: BaseResponse{
+			Code:    rspOk.Code,
+			Message: rspOk.Message,
+		},
+	}
+	rsp.Data = raw
+	return rsp
+}
+func NewListRsp(total int64, items interface{}) *ListResponse {
+	rsp := &ListResponse{
+		BaseResponse: BaseResponse{
+			Code:    rspOk.Code,
+			Message: rspOk.Message,
+		},
+	}
+	rsp.Data.Total = total
+	rsp.Data.Items = items
+	return rsp
+}
+
+func NewListSizeRsp(total int64, totalSize int64, items interface{}) *ListResponse {
+	rsp := &ListResponse{
+		BaseResponse: BaseResponse{
+			Code:    rspOk.Code,
+			Message: rspOk.Message,
+		},
+	}
+	rsp.Data.Total = total
+	rsp.Data.TotalSize = goutil.FormatBytes(totalSize)
+	rsp.Data.Items = items
+	return rsp
+}
+
+func NewRsp(data interface{}) *CommonResponse {
+	return &CommonResponse{
+		BaseResponse: BaseResponse{
+			Code:    rspOk.Code,
+			Message: rspOk.Message,
+		},
+		Data: data,
+	}
+}
+
+func CheckDBError(err error) {
+	if err != nil {
+		panic(config.ErrDb.New().Append(err))
+	}
+}
+
+func CheckParamError(err error) {
+	if err != nil {
+		panic(config.ErrParam.New().Append(err))
+	}
+}
+
+func CheckNilError(data interface{}, args ...string) {
+	val := reflect.ValueOf(data)
+	if val.IsNil() {
+		panic(config.ErrNoData.New().Append(args))
+	}
+}

common/session/session.go

@@ -0,0 +1,50 @@
+package session
+
+import (
+	"enterprise/common/model"
+)
+
+var (
+	ContextSession      = "session"
+	ContextRequest      = "request"
+	ContextResponse     = "response"
+	ContextHeader       = "header"
+	ContextWriteEvent   = "write_event"
+	ContextRefreshToken = "refresh_token"
+)
+
+type AdminHeader struct {
+	Token    string `header:"x-token" json:"-"`
+	RemoteIp string `header:"x-remote-ip" json:"public_ip"`
+}
+
+type AdminSession struct {
+	adminHeader *AdminHeader
+	adminUser   *model.StaffUser
+}
+
+func NewAdminSession(header *AdminHeader, user *model.StaffUser) *AdminSession {
+	return &AdminSession{
+		adminHeader: header,
+		adminUser:   user,
+	}
+}
+
+func (s *AdminSession) GetHeader() *AdminHeader {
+	return s.adminHeader
+}
+
+func (s *AdminSession) GetAdmin() *model.StaffUser {
+	return s.adminUser
+}
+
+func (s *AdminSession) GetCorpId() int64 {
+	return s.adminUser.CorpId
+}
+
+func (s *AdminSession) GetUsername() string {
+	if s.adminUser != nil {
+		return s.adminUser.Username
+	}
+	return ""
+}

server/api/checkin.go

@@ -0,0 +1,57 @@
+package api
+
+import (
+	"enterprise/common/model"
+	"github.com/smbrave/goutil"
+	"github.com/spf13/cast"
+)
+
+type BaseRequest struct {
+	Page int `form:"page"`
+	Size int `form:"size"`
+}
+
+func (b *BaseRequest) Default() {
+	if b.Page <= 0 {
+		b.Page = 1
+	}
+	if b.Size <= 0 {
+		b.Size = 10
+	}
+}
+
+type ListCheckin struct {
+	BaseRequest
+	Username string `form:"username"`
+	StartDay string `form:"start_day"`
+	EndDay   string `form:"end_day"`
+}
+
+type SyncCheckin struct {
+	StartDay string `form:"start_day"`
+	EndDay   string `form:"end_day"`
+}
+
+type Checkin struct {
+	Id         string
+	Username   string
+	Day        string
+	Month      string
+	Exception  string
+	Rawdata    string
+	StartTime  string
+	EndTime    string
+	CreateTime string
+}
+
+func (c *Checkin) From(m *model.Checkin) {
+	c.Id = cast.ToString(m.Id)
+	c.Username = m.Username
+	c.Day = m.Day
+	c.Month = m.Month
+	c.StartTime = goutil.TimeToDateTime(m.StartTime)
+	c.StartTime = goutil.TimeToDateTime(m.EndTime)
+	c.CreateTime = goutil.TimeToDateTime(m.CreateTime)
+	c.Exception = m.Exception
+	c.Rawdata = m.Rawdata
+}

server/controller/base.go

@@ -2,6 +2,9 @@ package controller
 
 import (
 	"enterprise/common/config"
+	"enterprise/common/dao"
+	"enterprise/common/model"
+	"enterprise/common/session"
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/gogap/errors"
@@ -21,6 +24,54 @@ type Response struct {
 type Base struct {
 }
 
+// 所有请求都必须走的逻辑，用于创建session
+func (c *Base) Before(ctx *gin.Context) {
+	if ctx.Keys == nil {
+		ctx.Keys = make(map[string]interface{})
+	}
+
+	// 获取头部参数
+	var header session.AdminHeader
+	if err := ctx.BindHeader(&header); err != nil {
+		panic(config.ErrParam.New().Append(err))
+	}
+
+	if header.Token == "" { // 新用户没有extra所以extra中的配置不能对新用户生效
+		return
+	}
+
+	var tk *model.StaffToken = nil
+
+	tk, err := dao.NewStaffTokenDao().GetByToken(header.Token)
+	if err != nil {
+		panic(config.ErrDb.New().Append(err))
+	}
+
+	if tk == nil {
+		panic(config.ErrTokenInvaild.New())
+	}
+	if time.Now().Unix() > tk.ExpireTime {
+		panic(config.ErrTokenExpire.New())
+	}
+	staffUser, err := dao.NewStaffUserDao().Get(tk.UserId)
+	if err != nil {
+		panic(config.ErrDb.New().Append(err))
+	}
+	if staffUser == nil {
+		panic(config.ErrTokenInvaild.New())
+	}
+
+	ctx.Keys[session.ContextSession] = session.NewAdminSession(&header, staffUser)
+}
+
+func (c *Base) Token(ctx *gin.Context) {
+	// 只有需要传token的接口需要强制校验token
+	sess := ctx.Keys[session.ContextSession].(*session.AdminSession)
+	if sess.GetHeader().Token == "" {
+		panic(config.ErrNoToken.New())
+	}
+}
+
 func (c *Base) Recovery(ctx *gin.Context) {
 	defer func() {
 		if err := recover(); err != nil {

server/controller/checkin.go

@@ -0,0 +1,41 @@
+package controller
+
+import (
+	"enterprise/common/config"
+	"enterprise/common/dao"
+	"enterprise/common/session"
+	"enterprise/server/api"
+	"enterprise/server/service"
+	"github.com/gin-gonic/gin"
+	"github.com/spf13/cast"
+	"net/http"
+)
+
+type StaffCheckin struct {
+}
+
+func (s *StaffCheckin) List(ctx *gin.Context) {
+	var req api.ListCheckin
+	if err := ctx.ShouldBind(&req); err != nil {
+		panic(config.ErrParam.New().Append(err))
+	}
+	sess := ctx.Keys[session.ContextSession].(*session.AdminSession)
+	total, items := new(service.Checkin).List(sess, &req)
+	ctx.JSON(http.StatusOK, session.NewListRsp(total, items))
+}
+
+func (s *StaffCheckin) Sync(ctx *gin.Context) {
+	var req api.SyncCheckin
+	if err := ctx.ShouldBind(&req); err != nil {
+		panic(config.ErrParam.New().Append(err))
+	}
+	sess := ctx.Keys[session.ContextSession].(*session.AdminSession)
+	new(service.Checkin).Sync(sess, &req)
+	ctx.JSON(http.StatusOK, session.NewRspOk())
+}
+
+func (s *StaffCheckin) Delete(ctx *gin.Context) {
+	id := cast.ToInt64(ctx.Query("id"))
+	dao.NewCheckinDao().Delete(id)
+	ctx.JSON(http.StatusOK, session.NewRspOk())
+}

server/controller/salary.go

@@ -0,0 +1 @@
+package controller

server/server.go

@@ -10,18 +10,28 @@ func initRoutge(engine *gin.Engine) {
 	qyweixin := new(controller.QyWeixin)
 	staff := new(controller.Staff)
 	base := new(controller.Base)
+	checkin := new(controller.StaffCheckin)
 	apiGroup := engine.Group("/api")
+	noTokenGroup := engine.Group("/api")
+
+	apiGroup.Use(base.Before).Use(base.Token)
 	group := engine.Group("/")
 	apiGroup.Use(base.Recovery)
 	group.Use(base.Recovery)
-	apiGroup.Any("/qyweixin/approve/:cid", qyweixin.Approve)
+
-	apiGroup.Any("/qyweixin/pay/:cid", qyweixin.Pay)
+	noTokenGroup.Any("/qyweixin/approve/:cid", qyweixin.Approve)
-	apiGroup.Any("/qyweixin/handle/refund", qyweixin.HandleRefund)
+	noTokenGroup.Any("/qyweixin/pay/:cid", qyweixin.Pay)
+	noTokenGroup.Any("/qyweixin/handle/refund", qyweixin.HandleRefund)
 
 	group.GET("/staff/salary", staff.Salary)
 	group.GET("/staff/sync/salary", staff.SyncStaffSalary)
 
+	apiGroup.GET("/checkin", checkin.List)
+	apiGroup.DELETE("/checkin", checkin.Delete)
+	apiGroup.Any("/checkin/sync", checkin.Sync)
+
 	engine.LoadHTMLGlob("conf/template/*")
+
 }
 
 func Start() error {

server/service/checkin.go

@@ -0,0 +1,34 @@
+package service
+
+import (
+	"enterprise/common/config"
+	"enterprise/common/dao"
+	"enterprise/common/session"
+	"enterprise/server/api"
+	CS "enterprise/service"
+)
+
+type Checkin struct {
+}
+
+func (c *Checkin) List(sess *session.AdminSession, req *api.ListCheckin) (int64, interface{}) {
+
+	checkts, total, err := dao.NewCheckinDao().QueryAdmin(req.Page, req.Size, sess.GetCorpId(), req.Username, req.StartDay, req.EndDay)
+	if err != nil {
+		panic(config.ErrDb.New().Append(err))
+	}
+	items := make([]*api.Checkin, 0)
+	for _, checkin := range checkts {
+		ch := new(api.Checkin)
+		ch.From(checkin)
+		items = append(items, ch)
+	}
+	return total, items
+}
+
+func (c *Checkin) Sync(sess *session.AdminSession, req *api.SyncCheckin) {
+	err := new(CS.Checkin).SyncCheckin(sess.GetCorpId(), req.StartDay, req.EndDay)
+	if err != nil {
+		panic(config.ErrInternal.New().Append(err))
+	}
+}

service/checkin.go

@@ -0,0 +1,79 @@
+package service
+
+import (
+	"enterprise/common/dao"
+	"enterprise/common/model"
+	"git.u8t.cn/open/gosdk/qyweixin"
+	log "github.com/sirupsen/logrus"
+	"github.com/smbrave/goutil"
+)
+
+type Checkin struct {
+}
+
+func (c *Checkin) SyncCheckin(corpId int64, startDay, endDay string) error {
+	corp, err := dao.NewCorpDao().Get(corpId)
+	if err != nil {
+		log.Errorf("db error :%s", err.Error())
+		return err
+	}
+
+	cfg := corp.GetConfig()
+	qyw := qyweixin.NewAppCheckin(&qyweixin.AppConfig{
+		Corpid: cfg.CorpId,
+		Secret: cfg.EnterpriseSecret,
+		Agent:  cfg.EnterpriseAgent,
+	})
+
+	users, err := qyw.GetCheckinEmployee(nil)
+	if err != nil {
+		log.Errorf("GetCheckinEmployee error :%s", err.Error())
+		return err
+	}
+
+	userDatas, err := qyw.GetCheckinData(startDay, endDay, users)
+	if err != nil {
+		log.Errorf("GetCheckinData[%s-%s]%s error :%s", startDay, endDay, goutil.EncodeJSON(users), err.Error())
+		return err
+	}
+
+	for _, user := range userDatas {
+		c.saveToDB(corpId, user)
+	}
+	return nil
+}
+
+func (c *Checkin) saveToDB(corpId int64, user *qyweixin.UserCheckIn) error {
+	checkin, err := dao.NewCheckinDao().GetByDay(user.UserId, user.Day)
+	if err != nil {
+		log.Errorf("db error :%s", err.Error())
+		return err
+	}
+	isNew := false
+	if checkin == nil {
+		checkin = new(model.Checkin)
+		checkin.Day = user.Day
+		checkin.Month = user.Month
+		checkin.Username = user.UserId
+		isNew = true
+	}
+
+	checkin.Exception = user.Exception
+	checkin.StartTime = user.StartTime
+	checkin.EndTime = user.EndTime
+	checkin.Month = user.Month
+	checkin.Rawdata = user.Rawdata
+	checkin.CorpId = corpId
+
+	if isNew {
+		_, err = dao.NewCheckinDao().Create(checkin)
+	} else {
+		err = dao.NewCheckinDao().Update(checkin)
+	}
+	if err != nil {
+		log.Errorf("create/update db error :%s", err.Error())
+		return err
+	}
+
+	return nil
+}

service/salary_calculator/salary_calculator_1002.go

@@ -32,15 +32,15 @@ func (s *SalaryCalculator1002) Calculate(salary *model.StaffSalary) {
 
 	if salary.Month == "202502" {
 		salary.ShouldDay = 21
-		if salary.UserName == "luoyi" {
+		if salary.Username == "luoyi" {
 			salary.AttendDay = float64(salary.ShouldDay - 5)
-		} else if strings.ToLower(salary.UserName) == "wangyan" {
+		} else if strings.ToLower(salary.Username) == "wangyan" {
 			salary.AttendDay = float64(salary.ShouldDay) - 5.6
-		} else if strings.ToLower(salary.UserName) == "zhouhong" {
+		} else if strings.ToLower(salary.Username) == "zhouhong" {
 			salary.AttendDay = float64(salary.ShouldDay) - 5.6
-		} else if strings.ToLower(salary.UserName) == "chenmin" {
+		} else if strings.ToLower(salary.Username) == "chenmin" {
 			salary.AttendDay = 19
-		} else if strings.ToLower(salary.UserName) == "xushiyu" {
+		} else if strings.ToLower(salary.Username) == "xushiyu" {
 			salary.AttendDay = 7
 		}
 	}

service/staff_salary.go

@@ -39,7 +39,7 @@ func (s *StaffSalary) CalcSalary(salary *model.StaffSalary, month string) (*mode
 		salary.Month = month
 		salary.CorpId = s.user.CorpId
 		salary.UserId = s.user.Id
-		salary.UserName = s.user.Username
+		salary.Username = s.user.Username
 	}
 
 	entryTime, _ := time.ParseInLocation("2006-01-02", s.user.EntryDate, time.Local)

worker/checkin.go

@@ -4,8 +4,8 @@ import (
 	"enterprise/common/dao"
 	"enterprise/common/global"
 	"enterprise/common/model"
+	"enterprise/service"
 	"fmt"
-	"git.u8t.cn/open/gosdk/qyweixin"
 	log "github.com/sirupsen/logrus"
 	"github.com/smbrave/goutil"
 	"strings"
@@ -24,78 +24,33 @@ func NewCheckin(corpId int64) *Checkin {
 		corpConfig: corp.GetConfig(),
 	}
 }
-func (c *Checkin) SyncCheckinMonth(month string) error {
+
+func (c *Checkin) SyncCheckinMonth(month string) {
 	if month == "" {
 		month = time.Now().AddDate(0, -1, 0).Format("200601")
 	}
 
-	cfg := c.corp.GetConfig()
-
 	startTime, _ := time.ParseInLocation("20060102", month+"01", time.Local)
 	endDay := startTime.AddDate(0, 1, -1).Format("2006-01-02")
 	startDay := startTime.Format("2006-01-02")
 
-	qyw := qyweixin.NewAppCheckin(&qyweixin.AppConfig{
+	new(service.Checkin).SyncCheckin(c.corp.Id, startDay, endDay)
-		Corpid: cfg.CorpId,
-		Secret: cfg.EnterpriseSecret,
-		Agent:  cfg.EnterpriseAgent,
-	})
-	users, err := qyw.GetCheckinEmployee(nil)
-	if err != nil {
-		log.Errorf("GetCheckinEmployee error :%s", err.Error())
-		return err
-	}
 
-	userDatas, err := qyw.GetCheckinData(startDay, endDay, users)
-	if err != nil {
-		log.Errorf("GetCheckinData[%s-%s]%s error :%s", startDay, endDay, goutil.EncodeJSON(users), err.Error())
-		return err
-	}
-	for _, user := range userDatas {
-		c.saveToDB(user)
-	}
-	return nil
 }
 
-func (c *Checkin) SyncCheckinDay(corpId int64, day string) {
+func (c *Checkin) SyncCheckinDay(day string) {
-	corp, err := dao.NewCorpDao().Get(corpId)
-	if err != nil {
-		log.Errorf("db error :%s", err.Error())
-		return
-	}
-
-	cfg := corp.GetConfig()
-	qyw := qyweixin.NewAppCheckin(&qyweixin.AppConfig{
-		Corpid: cfg.CorpId,
-		Secret: cfg.EnterpriseSecret,
-		Agent:  cfg.EnterpriseAgent,
-	})
 	if day == "" {
 		day = time.Now().AddDate(0, 0, -1).Format("2006-01-02")
 	}
-	users, err := qyw.GetCheckinEmployee(nil)
+	new(service.Checkin).SyncCheckin(c.corp.Id, day, day)
-	if err != nil {
-		log.Errorf("GetCheckinEmployee error :%s", err.Error())
-		return
-	}
 
-	userDatas, err := qyw.GetCheckinData(day, day, users)
-	if err != nil {
-		log.Errorf("GetCheckinData[%s-%s]%s error :%s", day, day, goutil.EncodeJSON(users), err.Error())
-		return
-	}
-
-	for _, user := range userDatas {
-		c.saveToDB(user)
-	}
-	return
 }
 
-func (c *Checkin) MonitorCheckinDay(corpId int64, day string) {
+func (c *Checkin) MonitorCheckinDay(day string) {
 	if day == "" {
 		day = time.Now().AddDate(0, 0, -1).Format("2006-01-02")
 	}
-	checkins, err := dao.NewCheckinDao().QueryDay(corpId, day)
+	checkins, err := dao.NewCheckinDao().QueryDay(c.corp.Id, day)
 	if err != nil {
 		log.Errorf("db error :%s", err.Error())
 		return
@@ -104,7 +59,7 @@ func (c *Checkin) MonitorCheckinDay(corpId int64, day string) {
 		if checkin.Exception == "" {
 			continue
 		}
-		approvals, err := dao.NewApprovalVacationDao().GetByUsername(corpId, checkin.Username, "", checkin.Day)
+		approvals, err := dao.NewApprovalVacationDao().GetByUsername(c.corp.Id, checkin.Username, "", checkin.Day)
 		if err != nil {
 			log.Errorf("db error :%s", err.Error())
 			continue
@@ -121,38 +76,3 @@ func (c *Checkin) MonitorCheckinDay(corpId int64, day string) {
 		global.SendMessage([]string{"jiangyong", checkin.Username}, strings.Join(message, "\n"))
 	}
 }
-
-func (c *Checkin) saveToDB(user *qyweixin.UserCheckIn) error {
-	checkin, err := dao.NewCheckinDao().GetByDay(user.UserId, user.Day)
-	if err != nil {
-		log.Errorf("db error :%s", err.Error())
-		return err
-	}
-	isNew := false
-	if checkin == nil {
-		checkin = new(model.Checkin)
-		checkin.Day = user.Day
-		checkin.Month = user.Month
-		checkin.Username = user.UserId
-		isNew = true
-	}
-
-	checkin.Exception = user.Exception
-	checkin.StartTime = user.StartTime
-	checkin.EndTime = user.EndTime
-	checkin.Month = user.Month
-	checkin.Rawdata = user.Rawdata
-	checkin.CorpId = c.corp.Id
-
-	if isNew {
-		_, err = dao.NewCheckinDao().Create(checkin)
-	} else {
-		err = dao.NewCheckinDao().Update(checkin)
-	}
-	if err != nil {
-		log.Errorf("create/update db error :%s", err.Error())
-		return err
-	}
-
-	return nil
-}

worker/worker.go

@@ -22,11 +22,11 @@ func InitCorp1002(cron *gocron.Scheduler) {
 	//同步每日考勤数据
 	cron.Every(1).Day().At("05:00").Do(func() {
 		checkIn := NewCheckin(corpId)
-		go checkIn.SyncCheckinDay(corpId, "")
+		go checkIn.SyncCheckinDay("")
 	})
 	cron.Every(1).Day().At("08:00").Do(func() {
 		checkIn := NewCheckin(corpId)
-		go checkIn.MonitorCheckinDay(corpId, "")
+		go checkIn.MonitorCheckinDay("")
 	})
 
 	//每月1号同步上月考勤、补卡审批、请假审批、报销审批
@@ -65,11 +65,11 @@ func InitCorp1000(cron *gocron.Scheduler) {
 	//同步每日考勤数据
 	cron.Every(1).Day().At("05:00").Do(func() {
 		checkIn := NewCheckin(corpId)
-		go checkIn.SyncCheckinDay(corpId, "")
+		go checkIn.SyncCheckinDay("")
 	})
 	cron.Every(1).Day().At("08:00").Do(func() {
 		checkIn := NewCheckin(corpId)
-		go checkIn.MonitorCheckinDay(corpId, "")
+		go checkIn.MonitorCheckinDay("")
 	})
 
 	//每月1号同步上月考勤、补卡审批、请假审批、报销审批