novatask/internal/svc/service_context.go

package svc

import (
	"context"
	"errors"
	ea "github.com/earn-alliance/earnalliance-go"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"github.com/zeromicro/go-zero/rest"
	"nova_task/internal/config"
	"nova_task/internal/middleware"
	"nova_task/internal/model"
	"nova_task/internal/pkg/errs"
	"nova_task/internal/types"
)

type ServiceContext struct {
	Config config.Config

	TaskModel               model.NhTaskModel
	TaskAssetModel          model.NhTaskAssetModel
	TaskAssetRecordModel    model.NhTaskAssetRecordModel
	TaskProgressModel       model.NhTaskProgressModel
	TwitterModel            model.NhTwitterModel
	PromoteBindModel        model.NhPromoteBindModel
	TouristBindModel        model.NhTouristBindModel
	CommunityModel          model.NhTaskCommunityModel
	UserModel               model.NhUserModel
	WalletModel             model.NhWalletModel
	ConfigModel             model.NhSystemConfigModel
	NftHolderModel          model.NhNftHolderModel
	NftHolderChangeLogModel model.NhNftHolderChangeLogModel
	StakeNftModel           model.NhTaskNftStakeModel
	OldStakeNftModel        model.NhNftStakeModel
	StakeNftLogModel        model.NhTaskNftStakeLogModel
	StakeRewardModel        model.NhTaskNftStakeRewardModel
	GamePitModel            model.NhGamePitModel
	StakePropertyModel      model.NhNftStakePropertyModel
	EmailRewardModel        model.NhEmailRewardModel
	AmbassadorModel         model.NhTaskAmbassadorModel
	GameReportModel         model.NhGameReportModel

	ApiKeyCheck      rest.Middleware
	AdminSecretCheck rest.Middleware

	Earn   *ea.Client
	DBConn sqlx.SqlConn
	Redis  *redis.Redis
}

func NewServiceContext(c config.Config) *ServiceContext {
	dbConn := c.MySql.Conn()
	configModel := model.NewNhSystemConfigModel(dbConn, c.Cache)
	return &ServiceContext{
		Config: c,

		TaskModel:               model.NewNhTaskModel(dbConn),
		TaskAssetModel:          model.NewNhTaskAssetModel(dbConn),
		TaskAssetRecordModel:    model.NewNhTaskAssetRecordModel(dbConn),
		TaskProgressModel:       model.NewNhTaskProgressModel(dbConn),
		TwitterModel:            model.NewNhTwitterModel(dbConn),
		PromoteBindModel:        model.NewNhPromoteBindModel(dbConn),
		CommunityModel:          model.NewNhTaskCommunityModel(dbConn),
		UserModel:               model.NewNhUserModel(dbConn),
		TouristBindModel:        model.NewNhTouristBindModel(dbConn),
		WalletModel:             model.NewNhWalletModel(dbConn),
		ConfigModel:             configModel,
		NftHolderModel:          model.NewNhNftHolderModel(dbConn),
		NftHolderChangeLogModel: model.NewNhNftHolderChangeLogModel(dbConn),
		StakeNftModel:           model.NewNhTaskNftStakeModel(dbConn),
		OldStakeNftModel:        model.NewNhNftStakeModel(dbConn),
		StakeRewardModel:        model.NewNhTaskNftStakeRewardModel(dbConn),
		GamePitModel:            model.NewNhGamePitModel(dbConn),
		StakePropertyModel:      model.NewNhNftStakePropertyModel(dbConn),
		EmailRewardModel:        model.NewNhEmailRewardModel(dbConn),
		AmbassadorModel:         model.NewNhTaskAmbassadorModel(dbConn),
		GameReportModel:         model.NewNhGameReportModel(dbConn),

		ApiKeyCheck:      middleware.NewApiKeyCheckMiddleware(configModel).Handle,
		AdminSecretCheck: middleware.NewAdminSecretCheckMiddleware(configModel).Handle,

		Earn:   c.Earn.BuildEarnClient(),
		DBConn: dbConn,
		Redis:  redis.MustNewRedis(c.Redis),
	}
}

func (s *ServiceContext) Close() {
	err := s.Earn.Flush()
	if err != nil {
		logx.Errorw("flush earn error", logx.Field("err", err))
	}
	s.Earn.Close()
}

func (s *ServiceContext) IsAmbassador(ctx context.Context, uid uint, stage int8) bool {
	u, err := s.UserModel.FindOne(ctx, uid)
	if err != nil {
		if !errors.Is(err, model.ErrNotFound) {
			logx.Errorw("find user error", logx.Field("err", err), logx.Field("uid", uid), logx.Field("stage", stage))
		}
		return false
	}
	_, err = s.AmbassadorModel.FindOneByEmailStage(ctx, u.Email, stage)
	if err != nil {
		if !errors.Is(err, model.ErrNotFound) {
			logx.Errorw("find ambassador error", logx.Field("err", err), logx.Field("uid", uid), logx.Field("stage", stage))
		}
		return false
	}
	return true
}

func (s *ServiceContext) HasBindTwitter(ctx context.Context, uid uint) bool {
	tw, err := s.TwitterModel.FindOneByUid(ctx, uid)
	if err != nil {
		if !errors.Is(err, model.ErrNotFound) {
			logx.Errorw("find twitter error", logx.Field("err", err), logx.Field("uid", uid))
		}
		return false
	}
	return tw.TwitterId != ""
}

func (s *ServiceContext) GetUidByEmail(ctx context.Context, email string) (uint, *types.CarvResult) {
	u, err := s.UserModel.FindOneByEmail(ctx, email)
	if err != nil {
		if !errors.Is(err, model.ErrNotFound) {
			return 0, &types.CarvResult{
				Error: &types.Error{
					Code:    int(errs.ErrDatabaseOperate),
					Message: "system error",
				},
			}
		}
		return 0, &types.CarvResult{
			Error: &types.Error{
				Code:    int(errs.ErrUserNotFound),
				Message: "email not exist",
			},
		}
	}
	return u.Id, nil
}