移除无用的目录

@@ -4,8 +4,8 @@ import (
 	"github.com/GeeTeam/gt3-golang-sdk/geetest"
 	"github.com/GeeTeam/gt3-golang-sdk/geetest"
 	"github.com/google/uuid"
 	"github.com/google/uuid"
 	"github.com/linmadan/egglib-go/utils/json"
 	"github.com/linmadan/egglib-go/utils/json"
+	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/auth/dto"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/auth/query"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/auth/query"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/auth/dto"
 	"time"
 	"time"
 
 
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"

-package command
-
-import (
-	"fmt"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type AccessTokenCommand struct {
-	AuthCode string `json:"authCode" valid:"Required"`
-}
-
-func (orgAddCommand *AccessTokenCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (orgAddCommand *AccessTokenCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(orgAddCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type CompanySignUpCommand struct {
-	// 企业名称
-	CompanyName string `cname:"企业名称" json:"companyName" valid:"Required"`
-	// 联系人
-	Contacts string `cname:"联系人" json:"userName" valid:"Required"`
-	// 手机号码
-	Phone string `cname:"手机号码" json:"phone" valid:"Required"`
-	// 规模
-	Scale string `cname:"规模" json:"scale" valid:"Required"`
-	// 所属行业
-	IndustryCategory string `cname:"所属行业" json:"industryCategory" valid:"Required"`
-	// 密码
-	Password string `cname:"密码" json:"password" valid:"Required"`
-	// 短信验证码
-	SmsCode string `cname:"短信验证码" json:"smsCode" valid:"Required"`
-}
-
-func (companySignUpCommand *CompanySignUpCommand) Valid(validation *validation.Validation) {
-	//validation.SetError("CustomValid", "未实现的自定义认证")
-}
-
-func (companySignUpCommand *CompanySignUpCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(companySignUpCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		elem := reflect.TypeOf(companySignUpCommand).Elem()
-		for _, validErr := range valid.Errors {
-			field, isExist := elem.FieldByName(validErr.Field)
-			if isExist {
-				return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1))
-			} else {
-				return fmt.Errorf(validErr.Message)
-			}
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type LoginCommand struct {
-	Phone     string `json:"phone"  valid:"Required"`
-	GrantType string `json:"grantType"  valid:"Required"` //登录方式（signInPassword 密码登录、signInCaptcha 验证码登录）
-	Password  string `json:"password"`
-	Captcha   string `json:"captcha"`
-}
-
-func (orgAddCommand *LoginCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (orgAddCommand *LoginCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(orgAddCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type RefreshTokenCommand struct {
-	RefreshToken string `json:"refreshToken" valid:"Required"`
-}
-
-func (orgAddCommand *RefreshTokenCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (orgAddCommand *RefreshTokenCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(orgAddCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type ResetPasswordCommand struct {
-	// 手机号码
-	// Phone string `cname:"手机号码" json:"phone" valid:"Required"`
-	// 密码
-	Password string `cname:"密码" json:"newPassword"`
-	// 密码
-	RepeatNewPassword string `cname:"密码" json:"repeatNewPassword" valid:"Required"`
-	// 密码
-	SmsCodeIdentity string `cname:"密码" json:"smsCodeIdentity" valid:"Required"`
-}
-
-func (resetPasswordCommand *ResetPasswordCommand) Valid(validation *validation.Validation) {
-	if len(resetPasswordCommand.Password) == 0 {
-		validation.Error("登录密码不能为空")
-		return
-	}
-	if resetPasswordCommand.Password != resetPasswordCommand.RepeatNewPassword {
-		validation.Error("两次密码输入不一致")
-		return
-	}
-}
-
-func (resetPasswordCommand *ResetPasswordCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(resetPasswordCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		elem := reflect.TypeOf(resetPasswordCommand).Elem()
-		for _, validErr := range valid.Errors {
-			field, isExist := elem.FieldByName(validErr.Field)
-			if isExist {
-				return fmt.Errorf(strings.Replace(validErr.Message, validErr.Field, field.Tag.Get("cname"), -1))
-			} else {
-				return fmt.Errorf(validErr.Message)
-			}
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-	"github.com/beego/beego/v2/core/validation"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-)
-
-type SwitchOrgCommand struct {
-	//操作人
-	Operator domain.Operator `json:"-"`
-	// 组织ID
-	OrgId int64 `json:"orgId,string"`
-}
-
-func (switchOrgCommand *SwitchOrgCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (switchOrgCommand *SwitchOrgCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(switchOrgCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type UserInfoCommand struct {
-	//操作人
-	Operator domain.Operator `json:"-"`
-}
-
-func (userInfoCommand *UserInfoCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (userInfoCommand *UserInfoCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(userInfoCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type UserMenusCommand struct {
-	//操作人
-	Operator domain.Operator `json:"-"`
-}
-
-func (userMenusCommand *UserMenusCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (userMenusCommand *UserMenusCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(userMenusCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package command
-
-import (
-	"fmt"
-	"github.com/beego/beego/v2/core/validation"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-)
-
-type UserOrgCommand struct {
-	//操作人
-	Operator domain.Operator `json:"-"`
-}
-
-func (userOrgCommand *UserOrgCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (userOrgCommand *UserOrgCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(userOrgCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package service
-
-import (
-	"time"
-
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/log"
-
-	"github.com/linmadan/egglib-go/core/application"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/factory"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/mobile/auth/command"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/cache"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_user"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/sms_serve"
-)
-
-// 组织管理
-type AuthService struct {
-}
-
-//AuthLogin 用户登录
-func (srv AuthService) AuthLogin(loginCommand *command.LoginCommand) (interface{}, error) {
-	var (
-		result interface{}
-		err    error
-	)
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	_, err = creationUserGateway.AuthRefreshIM(allied_creation_user.ReqAuthRefreshIM{
-		Phone: loginCommand.Phone,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	switch loginCommand.GrantType {
-	case "signInPassword":
-		result, err = srv.SignInPassword(loginCommand.Phone, loginCommand.Password)
-	case "signInCaptcha":
-		result, err = srv.SignInCaptcha(loginCommand.Phone, loginCommand.Captcha)
-	default:
-		err = application.ThrowError(application.TRANSACTION_ERROR, "登录方式无法解析")
-	}
-	return result, err
-}
-
-//SignInPassword 使用账号密码校验
-func (srv AuthService) SignInPassword(account string, password string) (interface{}, error) {
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	_, err := creationUserGateway.AuthCheckPassword(allied_creation_user.ReqAuthCheckPassword{
-		Password: password,
-		Phone:    account,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	ltoken := domain.LoginToken{
-		UserId:    0,
-		Account:   account,
-		Platform:  domain.LoginPlatformApp,
-		CompanyId: 0,
-	}
-	authcode, err := ltoken.GenerateAuthCode()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	result := map[string]string{
-		"authCode": authcode,
-	}
-	return result, nil
-}
-
-//SignInCaptcha 使用手机验证码登录
-func (srv AuthService) SignInCaptcha(phone string, captcha string) (interface{}, error) {
-	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
-	err := smsServeGateway.CheckSmsCode(phone, captcha)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	ltoken := domain.LoginToken{
-		UserId:    0,
-		Account:   phone,
-		Platform:  domain.LoginPlatformApp,
-		CompanyId: 0,
-	}
-	authcode, err := ltoken.GenerateAuthCode()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	result := map[string]string{
-		"authCode": authcode,
-	}
-	return result, nil
-}
-
-//GetAuthAccessToken 获取令牌Token
-func (srv AuthService) GetAuthAccessToken(accessTokenCommand *command.AccessTokenCommand) (interface{}, error) {
-	if err := accessTokenCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	ltoken := &domain.LoginToken{}
-	err := ltoken.ParseToken(accessTokenCommand.AuthCode)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	phone := ltoken.Account
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	userSeachResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
-		CompanyId: ltoken.CompanyId,
-		Phone:     phone,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if len(userSeachResult.Users) == 0 {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, "获取用户信息失败")
-	}
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-	var loginAccessRepository domain.LoginAccessRepository
-	if loginAccessRepository, err = factory.CreateLoginAccessRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
-		"account":  phone,
-		"platform": domain.LoginPlatformApp,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	var currentAccess *domain.LoginAccess
-	if len(lAccess) > 0 {
-		currentAccess = lAccess[0]
-		currentAccess.UpdatedTime = time.Now()
-	} else {
-		currentAccess = &domain.LoginAccess{
-			UserBaseId:     int64(userSeachResult.Users[0].UserBaseId),
-			UserId:         int64(userSeachResult.Users[0].UserId),
-			Account:        userSeachResult.Users[0].UserInfo.Phone,
-			Platform:       domain.LoginPlatformApp,
-			OrganizationId: int64(userSeachResult.Users[0].Org.OrgId),
-			AccessToken:    "",
-			RefreshToken:   "",
-			AccessExpired:  0,
-			RefreshExpired: 0,
-			CreatedTime:    time.Now(),
-			UpdatedTime:    time.Now(),
-		}
-		if userSeachResult.Users[0].Company != nil {
-			currentAccess.CompanyId = int64(userSeachResult.Users[0].Company.CompanyId)
-		}
-	}
-	//判定当前凭证的companyId，OrganizationId 是否在用户列表中
-	var currentOrgIsOK bool
-loopUser1:
-	for _, v := range userSeachResult.Users {
-		if v.Company.CompanyId == int(currentAccess.CompanyId) {
-			for _, vv := range v.UserOrg {
-				if vv.OrgID == int(currentAccess.OrganizationId) {
-					currentOrgIsOK = true
-					currentAccess.UserId = int64(v.UserId)
-					currentAccess.UserBaseId = int64(v.UserBaseId)
-					break loopUser1
-				}
-			}
-		}
-	}
-	//记录上一次的登录公司组织信息不可用 ，重置登录记录
-	//使用找到的第一个可用的公司组织
-	if !currentOrgIsOK {
-	loopUser2:
-		for _, v := range userSeachResult.Users {
-			currentAccess.CompanyId = int64(v.Company.CompanyId)
-			for _, vv := range v.UserOrg {
-				currentAccess.UserId = int64(v.UserId)
-				currentAccess.UserBaseId = int64(v.UserBaseId)
-				currentAccess.OrganizationId = int64(vv.OrgID)
-				currentOrgIsOK = true
-				break loopUser2
-			}
-		}
-	}
-
-	loginToken := domain.LoginToken{
-		UserId:     currentAccess.UserId,
-		Account:    currentAccess.Account,
-		UserBaseId: currentAccess.UserBaseId,
-		CompanyId:  currentAccess.CompanyId,
-		OrgId:      currentAccess.OrganizationId,
-		Platform:   currentAccess.Platform,
-	}
-
-	accessTokenStr, err := loginToken.GenerateAccessToken()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	currentAccess.AccessToken = accessTokenStr
-	currentAccess.AccessExpired = loginToken.ExpiresAt
-	refreshTokenStr, err := loginToken.GenerateRefreshToken()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	currentAccess.RefreshToken = refreshTokenStr
-	currentAccess.AccessExpired = loginToken.ExpiresAt
-	//先存数据库
-	_, err = loginAccessRepository.Save(currentAccess)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	//后处理redis缓存
-	tokenCache := cache.LoginTokenCache{}
-	tokenCache.RemoveAccessToken(currentAccess.Account, domain.LoginPlatformApp)
-	tokenCache.RemoveRefreshToken(currentAccess.Account, domain.LoginPlatformApp)
-	tokenCache.SaveAccessToken(currentAccess)
-	tokenCache.SaveRefreshToken(currentAccess)
-	nowTime := time.Now().Unix()
-	return map[string]interface{}{
-		"refreshToken": accessTokenStr,
-		"accessToken":  refreshTokenStr,
-		"expiresIn":    currentAccess.AccessExpired - nowTime,
-	}, nil
-}
-
-func (srv AuthService) RefreshAuthAccessToken(refreshTokenCommand *command.RefreshTokenCommand) (interface{}, error) {
-	if err := refreshTokenCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	ltoken := domain.LoginToken{}
-	err := ltoken.ParseToken(refreshTokenCommand.RefreshToken)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, "refreshToken 不可用，"+err.Error())
-	}
-	token, err := srv.getToken(domain.Operator{}, ltoken)
-	//	phone := ltoken.Account
-	//	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	//	userSearchResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
-	//		Phone: phone,
-	//	})
-	//	if err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, "用户信息获取失败，"+err.Error())
-	//	}
-	//	//判定当前凭证的companyId，OrganizationId 是否在用户列表中
-	//	var currentOrgIsOK bool
-	//loopUser1:
-	//	for _, v := range userSearchResult.Users {
-	//		if v.Company.CompanyId == int(ltoken.CompanyId) {
-	//			for _, vv := range v.UserOrg {
-	//				if vv.OrgID == int(ltoken.OrgId) {
-	//					currentOrgIsOK = true
-	//					break loopUser1
-	//				}
-	//			}
-	//		}
-	//	}
-	//	if !currentOrgIsOK {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, "登录的公司组织不可用")
-	//	}
-	//
-	//	transactionContext, err := factory.CreateTransactionContext(nil)
-	//	if err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	if err := transactionContext.StartTransaction(); err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	defer func() {
-	//		transactionContext.RollbackTransaction()
-	//	}()
-	//	var loginAccessRepository domain.LoginAccessRepository
-	//	if loginAccessRepository, err = factory.CreateLoginAccessRepository(map[string]interface{}{
-	//		"transactionContext": transactionContext,
-	//	}); err != nil {
-	//		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	//	}
-	//	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
-	//		"account":  phone,
-	//		"platform": domain.LoginPlatformApp,
-	//	})
-	//	if err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	var currentAccess *domain.LoginAccess
-	//	if len(lAccess) > 0 {
-	//		currentAccess = lAccess[0]
-	//		currentAccess.UpdatedTime = time.Now()
-	//	} else {
-	//		currentAccess = &domain.LoginAccess{
-	//			UserBaseId:     ltoken.UserBaseId,
-	//			UserId:         ltoken.UserId,
-	//			Account:        ltoken.Account,
-	//			Platform:       domain.LoginPlatformApp,
-	//			CompanyId:      ltoken.CompanyId,
-	//			OrganizationId: ltoken.OrgId,
-	//			AccessToken:    "",
-	//			RefreshToken:   "",
-	//			AccessExpired:  0,
-	//			RefreshExpired: 0,
-	//			CreatedTime:    time.Now(),
-	//			UpdatedTime:    time.Now(),
-	//		}
-	//	}
-	//	accessTokenStr, err := ltoken.GenerateAccessToken()
-	//	if err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	currentAccess.AccessToken = accessTokenStr
-	//	currentAccess.AccessExpired = ltoken.ExpiresAt
-	//	refreshTokenStr, err := ltoken.GenerateRefreshToken()
-	//	if err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	currentAccess.RefreshToken = refreshTokenStr
-	//	currentAccess.RefreshExpired = ltoken.ExpiresAt
-	//	//先存数据库
-	//	_, err = loginAccessRepository.Save(currentAccess)
-	//	if err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	if err := transactionContext.CommitTransaction(); err != nil {
-	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	//	}
-	//	//后处理redis缓存
-	//	tokenCache := cache.LoginTokenCache{}
-	//	tokenCache.RemoveAccessToken(currentAccess.Account, domain.LoginPlatformApp)
-	//	tokenCache.RemoveRefreshToken(currentAccess.Account, domain.LoginPlatformApp)
-	//	tokenCache.SaveAccessToken(currentAccess)
-	//	tokenCache.SaveRefreshToken(currentAccess)
-	//	nowTime := time.Now().Unix()
-	//	return map[string]interface{}{
-	//		"refreshToken": accessTokenStr,
-	//		"accessToken":  refreshTokenStr,
-	//		"expiresIn":    currentAccess.AccessExpired - nowTime,
-	//	}, nil
-	return token["token"], err
-}
-
-//GetUserMenus 获取用户信息
-func (srv AuthService) GetUserInfo(userInfoCommand *command.UserInfoCommand) (interface{}, error) {
-	user, err := srv.getUserInfo(userInfoCommand.Operator)
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	return map[string]interface{}{
-		"user": user,
-	}, nil
-}
-
-//GetUserMenus 获取用户菜单
-func (srv AuthService) GetUserMenus(userMenusCommand *command.UserMenusCommand) (interface{}, error) {
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
-		userMenusCommand.Operator)
-	resultMenu, err := creationUserGateway.UserAccessMenus(allied_creation_user.ReqUserAccessMenus{
-		UserId: int(userMenusCommand.Operator.UserId),
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	return map[string]interface{}{
-		"accessMenus": resultMenu.Menus,
-	}, nil
-}
-
-//GetUserMenus 获取用户组织
-func (srv AuthService) GetUserOrg(userOrgCommand *command.UserOrgCommand) (interface{}, error) {
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(userOrgCommand.Operator)
-	result, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
-		Offset:       0,
-		Limit:        100,
-		UserBaseId:   userOrgCommand.Operator.UserBaseId,
-		UserType:     domain.UserTypeEmployee,
-		EnableStatus: domain.UserStatusEnable,
-		PullRealTime: true,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	var res = make([]interface{}, 0)
-	for i := range result.Users {
-		for j := range result.Users[i].UserOrg {
-			org := result.Users[i].UserOrg[j]
-			res = append(res, map[string]interface{}{
-				"orgId":   org.OrgID,
-				"orgName": org.OrgName,
-			})
-		}
-	}
-	return map[string]interface{}{
-		"orgs": res,
-	}, nil
-}
-
-//OrgSwitch 组织切换
-func (srv AuthService) OrgSwitch(switchOrgCommand *command.SwitchOrgCommand) (interface{}, error) {
-	if err := switchOrgCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	ltoken := domain.LoginToken{}
-	err := ltoken.ParseToken(switchOrgCommand.Operator.Token)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, "accessToken 不可用，"+err.Error())
-	}
-	ltoken.OrgId = switchOrgCommand.OrgId
-	token, err := srv.getToken(domain.Operator{}, ltoken)
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	var userId int64
-	if v, ok := token["userId"]; ok {
-		if userId, ok = v.(int64); !ok {
-			return nil, application.ThrowError(application.TRANSACTION_ERROR, "用户不存在")
-		}
-	}
-	user, err := srv.getUserInfo(domain.Operator{UserId: userId})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
-		switchOrgCommand.Operator)
-	resultMenu, err := creationUserGateway.UserAccessMenus(allied_creation_user.ReqUserAccessMenus{
-		UserId: int(userId),
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	var res = map[string]interface{}{
-		"user":        user,
-		"accessMenus": resultMenu.Menus,
-		"token":       token["token"],
-	}
-	return res, nil
-}
-
-// CompanySignUp 企业注册
-func (srv AuthService) CompanySignUp(companySignUpCommand *command.CompanySignUpCommand) (interface{}, error) {
-	//TODO:验证码验证测试去掉，后期恢复回来
-	//smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
-	//err := smsServeGateway.CheckSmsCode(companySignUpCommand.Phone, companySignUpCommand.SmsCode)
-	//if err != nil {
-	//	return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	//}
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	_, err := creationUserGateway.AuthCompanySignUp(allied_creation_user.ReqAuthCompanySignUp{
-		CompanyName:      companySignUpCommand.CompanyName,
-		Phone:            companySignUpCommand.Phone,
-		Password:         companySignUpCommand.Password,
-		Contacts:         companySignUpCommand.Contacts,
-		IndustryCategory: companySignUpCommand.IndustryCategory,
-		Scale:            companySignUpCommand.Scale,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	return companySignUpCommand, err
-}
-
-// ResetPassword  重置密码（找回密码）
-func (srv AuthService) ResetPassword(resetPasswordCommand *command.ResetPasswordCommand) (interface{}, error) {
-	if err := resetPasswordCommand.ValidateCommand(); err != nil {
-		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
-	}
-	//var phone string
-	pcc := cache.PhoneCheckCache{}
-	var item = &cache.PhoneCheckItem{}
-	if err := pcc.Get(resetPasswordCommand.SmsCodeIdentity, item); err != nil {
-		log.Logger.Error(err.Error())
-		return nil, application.ThrowError(application.BUSINESS_ERROR, "验证码已失效")
-	}
-	// 2.重置密码
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	result, err := creationUserGateway.AuthResetPassword(allied_creation_user.ReqAuthResetPassword{
-		Phone:    item.Phone,
-		Password: resetPasswordCommand.Password,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	return result, err
-}
-
-func (srv AuthService) getUserInfo(operator domain.Operator) (interface{}, error) {
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(
-		operator)
-	resultUser, err := creationUserGateway.UserGet(allied_creation_user.ReqGetUser{
-		UserId: int(operator.UserId),
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	var user = map[string]interface{}{
-		"userId": resultUser.UserId,
-		"userInfo": map[string]interface{}{
-			"userName":   resultUser.UserInfo.UserName,
-			"userPhone":  resultUser.UserInfo.Phone,
-			"userAvatar": resultUser.UserInfo.Avatar,
-			//"userCode": resultUser.UserInfo.UserCode,
-			"email": resultUser.UserInfo.Email,
-		},
-		"department": resultUser.Department,
-		"company": map[string]interface{}{
-			"companyId":   resultUser.Company.CompanyId,
-			"companyName": resultUser.Company.CompanyName,
-			"logo":        resultUser.Company.Log,
-		},
-		"im":  resultUser.IM,
-		"org": resultUser.Org,
-	}
-	return user, nil
-}
-
-func (srv AuthService) getToken(operator domain.Operator, ltoken domain.LoginToken) (map[string]interface{}, error) {
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	userSearchResult, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
-		Phone: ltoken.Account,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, "用户信息获取失败，"+err.Error())
-	}
-	//判定当前凭证的companyId，OrganizationId 是否在用户列表中
-	var currentOrgIsOK bool
-	var currentUserId int64
-loopUser1:
-	for _, v := range userSearchResult.Users {
-		//if v.Company.CompanyId == int(ltoken.CompanyId) {
-		for _, vv := range v.UserOrg {
-			if vv.OrgID == int(ltoken.OrgId) {
-				currentOrgIsOK = true
-				currentUserId = int64(v.UserId)
-				break loopUser1
-			}
-		}
-		//}
-	}
-	if !currentOrgIsOK {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, "登录的公司组织不可用")
-	}
-
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-	var loginAccessRepository domain.LoginAccessRepository
-	if loginAccessRepository, err = factory.CreateLoginAccessRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	_, lAccess, err := loginAccessRepository.Find(map[string]interface{}{
-		"account":  ltoken.Account,
-		"platform": domain.LoginPlatformApp,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	var currentAccess *domain.LoginAccess
-	if len(lAccess) > 0 {
-		currentAccess = lAccess[0]
-		currentAccess.UpdatedTime = time.Now()
-	} else {
-		currentAccess = &domain.LoginAccess{
-			UserBaseId:     ltoken.UserBaseId,
-			UserId:         ltoken.UserId,
-			Account:        ltoken.Account,
-			Platform:       domain.LoginPlatformApp,
-			CompanyId:      ltoken.CompanyId,
-			OrganizationId: ltoken.OrgId,
-			AccessToken:    "",
-			RefreshToken:   "",
-			AccessExpired:  0,
-			RefreshExpired: 0,
-			CreatedTime:    time.Now(),
-			UpdatedTime:    time.Now(),
-		}
-	}
-	accessTokenStr, err := ltoken.GenerateAccessToken()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	currentAccess.AccessToken = accessTokenStr
-	currentAccess.AccessExpired = ltoken.ExpiresAt
-	refreshTokenStr, err := ltoken.GenerateRefreshToken()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	currentAccess.RefreshToken = refreshTokenStr
-	currentAccess.RefreshExpired = ltoken.ExpiresAt
-	//先存数据库
-	_, err = loginAccessRepository.Save(currentAccess)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	//后处理redis缓存
-	tokenCache := cache.LoginTokenCache{}
-	tokenCache.RemoveAccessToken(currentAccess.Account, domain.LoginPlatformApp)
-	tokenCache.RemoveRefreshToken(currentAccess.Account, domain.LoginPlatformApp)
-	tokenCache.SaveAccessToken(currentAccess)
-	tokenCache.SaveRefreshToken(currentAccess)
-	nowTime := time.Now().Unix()
-	token := map[string]interface{}{
-		"refreshToken": accessTokenStr,
-		"accessToken":  refreshTokenStr,
-		"expiresIn":    currentAccess.AccessExpired - nowTime,
-	}
-	return map[string]interface{}{
-		"token":  token,
-		"userId": currentUserId,
-	}, nil
-}

-package command
-
-import (
-	"fmt"
-
-	"github.com/beego/beego/v2/core/validation"
-)
-
-type LoginCommand struct {
-	Phone     string `json:"phone"  valid:"Required"`
-	GrantType string `json:"grantType"  valid:"Required"` //登录方式（signInPassword 密码登录、signInCaptcha 验证码登录）
-	Password  string `json:"password"`
-	Captcha   string `json:"captcha"`
-}
-
-func (orgAddCommand *LoginCommand) Valid(validation *validation.Validation) {
-
-}
-
-func (orgAddCommand *LoginCommand) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(orgAddCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package query
-
-import (
-	"fmt"
-
-	"github.com/beego/beego/v2/core/validation"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-)
-
-type GetCompanyOrgsByUserQuery struct {
-	//操作人
-	Operator domain.Operator `json:"-"`
-	Phone    string          `json:"phone" valid:"Required"` //手机号
-}
-
-func (orgAddCommand *GetCompanyOrgsByUserQuery) Valid(validation *validation.Validation) {
-
-}
-
-func (orgAddCommand *GetCompanyOrgsByUserQuery) ValidateCommand() error {
-	valid := validation.Validation{}
-	b, err := valid.Valid(orgAddCommand)
-	if err != nil {
-		return err
-	}
-	if !b {
-		for _, validErr := range valid.Errors {
-			return fmt.Errorf("%s  %s", validErr.Key, validErr.Message)
-		}
-	}
-	return nil
-}

-package query
-
-type QrcodeLoginStatusQuery struct {
-	Token string `json:"token"`
-}

-package service
-
-import (
-	"errors"
-
-	"github.com/linmadan/egglib-go/core/application"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/auth/command"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/auth/dto"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/web/auth/query"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/domain"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/cache"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/allied_creation_user"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/infrastructure/service_gateway/sms_serve"
-)
-
-type AuthService struct{}
-
-//AuthLogin 用户登录
-func (srv AuthService) AuthLogin(loginCommand *command.LoginCommand) (interface{}, error) {
-	var (
-		result interface{}
-		err    error
-	)
-	switch loginCommand.GrantType {
-	case "signInPassword":
-		//账号密码登录
-		result, err = srv.SignInPassword(loginCommand.Phone, loginCommand.Password)
-	case "signInCaptcha":
-		//手机验证码登录
-		result, err = srv.SignInCaptcha(loginCommand.Phone, loginCommand.Captcha)
-	default:
-		err = errors.New("登录方式无法解析")
-	}
-	return result, err
-}
-
-//SignInPassword 使用账号密码校验
-func (srv AuthService) SignInPassword(account string, password string) (interface{}, error) {
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
-	_, err := creationUserGateway.AuthCheckPassword(allied_creation_user.ReqAuthCheckPassword{
-		Password: password,
-		Phone:    account,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	ltoken := domain.LoginToken{
-		UserId:    0,
-		Account:   account,
-		Platform:  domain.LoginPlatformApp,
-		CompanyId: 0,
-	}
-	authcode, err := ltoken.GenerateAuthCode()
-	if err != nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
-	}
-	result := map[string]string{
-		"authCode": authcode,
-	}
-	return result, nil
-}
-
-//SignInCaptcha 使用手机验证码登录
-func (srv AuthService) SignInCaptcha(phone string, captcha string) (interface{}, error) {
-	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
-	err := smsServeGateway.CheckSmsCode(phone, captcha)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	ltoken := domain.LoginToken{
-		UserId:    0,
-		Account:   phone,
-		Platform:  domain.LoginPlatformApp,
-		CompanyId: 0,
-	}
-	authcode, err := ltoken.GenerateAuthCode()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	result := map[string]string{
-		"authCode": authcode,
-	}
-	return result, nil
-}
-
-//GetCompanyOrgsByUser 获取登录用户的公司组织列表
-func (srv AuthService) GetCompanyOrgsByUser(queryParam query.GetCompanyOrgsByUserQuery) (interface{}, error) {
-
-	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(queryParam.Operator)
-	result, err := creationUserGateway.UserSearch(allied_creation_user.ReqUserSearch{
-		Phone: queryParam.Phone,
-	})
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	var (
-		companys []dto.CompanyItem
-		orgs     []dto.OrgItem
-	)
-
-	for _, v := range result.Users {
-		companys = append(companys, dto.CompanyItem{
-			CompanyId:   v.Company.CompanyId,
-			CompanyName: v.Company.CompanyName,
-		})
-		for _, vv := range v.UserOrg {
-			orgs = append(orgs, dto.OrgItem{
-				OrganizationId:   vv.OrgID,
-				OrganizationName: vv.OrgName,
-				CompanyId:        v.Company.CompanyId,
-			})
-		}
-	}
-
-	data := map[string]interface{}{
-		"companys":      companys,
-		"organizations": orgs,
-	}
-	return data, nil
-}
-
-//GetQrcode 获取扫码登录需要的二维码
-func (srv AuthService) GetQrcode() (interface{}, error) {
-	qrmsg := domain.QrcodeMessage{}
-	imgBase64, err := qrmsg.GenerateImageBase64()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	qrCache := cache.LoginQrcodeCache{}
-	err = qrCache.Save(qrmsg)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	data := map[string]interface{}{
-		"image": imgBase64,
-		"token": qrmsg.Token,
-	}
-	return data, nil
-}
-
-//QrcodeLoginStatus 询问扫码登录状态
-func (srv AuthService) QrcodeLoginStatus(queryParam query.QrcodeLoginStatusQuery) (interface{}, error) {
-	qrmsg := domain.QrcodeMessage{}
-	err := qrmsg.ParseToken(queryParam.Token)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	qrCache := cache.LoginQrcodeCache{}
-	qrmsgCache, err := qrCache.Get(qrmsg.Id)
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	loginToken := domain.LoginToken{
-		UserId:     qrmsgCache.UserId,
-		UserBaseId: qrmsgCache.UserBaseId,
-		Account:    qrmsgCache.Account,
-		Platform:   domain.LoginPlatformWeb,
-		CompanyId:  qrmsgCache.CompanyId,
-		OrgId:      qrmsgCache.OrgId,
-	}
-	accessToken, err := loginToken.GenerateAccessToken()
-	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
-	}
-	_ = accessToken
-	//TODO 填充token数据
-	data := map[string]interface{}{
-		"isLogin":     qrmsgCache.IsLogin,
-		"accessToken": "",
-	}
-	return data, nil
-}

 package mobile_client
 package mobile_client
 
 
-import (
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/mobile/auth/command"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/mobile/auth/service"
-)
-
 type AuthController struct {
 type AuthController struct {
 	baseController
 	baseController
 }
 }
 
 
-func (controller *AuthController) Login() {
-	authService := service.AuthService{}
-	loginCmd := &command.LoginCommand{}
-	err := controller.Unmarshal(loginCmd)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	data, err := authService.AuthLogin(loginCmd)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) GetAuthAccessToken() {
-	authService := service.AuthService{}
-	accessTokenCommand := &command.AccessTokenCommand{}
-	err := controller.Unmarshal(accessTokenCommand)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	data, err := authService.GetAuthAccessToken(accessTokenCommand)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) RefreshAuthAccessToken() {
-	authService := service.AuthService{}
-	refreshTokenCmd := &command.RefreshTokenCommand{}
-	err := controller.Unmarshal(refreshTokenCmd)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	data, err := authService.RefreshAuthAccessToken(refreshTokenCmd)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) GetUserInfo() {
-	authService := service.AuthService{}
-	userInfoCommand := &command.UserInfoCommand{}
-	err := controller.Unmarshal(userInfoCommand)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	userInfoCommand.Operator = controller.GetOperator()
-	data, err := authService.GetUserInfo(userInfoCommand)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) GetUserMenus() {
-	authService := service.AuthService{}
-	userMenusCommand := &command.UserMenusCommand{}
-	err := controller.Unmarshal(userMenusCommand)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	userMenusCommand.Operator = controller.GetOperator()
-	data, err := authService.GetUserMenus(userMenusCommand)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) GetUserOrg() {
-	authService := service.AuthService{}
-	userOrgCommand := &command.UserOrgCommand{}
-	err := controller.Unmarshal(userOrgCommand)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	userOrgCommand.Operator = controller.GetOperator()
-	data, err := authService.GetUserOrg(userOrgCommand)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) CompanySignUp() {
-	authService := service.AuthService{}
-	userOrgCommand := &command.CompanySignUpCommand{}
-	err := controller.Unmarshal(userOrgCommand)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	//userOrgCommand.Operator = controller.GetOperator()
-	data, err := authService.CompanySignUp(userOrgCommand)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) ResetPassword() {
-	authService := service.AuthService{}
-	userOrgCommand := &command.ResetPasswordCommand{}
-	err := controller.Unmarshal(userOrgCommand)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	//userOrgCommand.Operator = controller.GetOperator()
-	data, err := authService.ResetPassword(userOrgCommand)
-	controller.Response(data, err)
-}
-
-func (controller *AuthController) OrgSwitch() {
-	authService := service.AuthService{}
-	cmd := &command.SwitchOrgCommand{}
-	err := controller.Unmarshal(cmd)
-	if err != nil {
-		controller.Response(nil, err)
-		return
-	}
-	cmd.Operator = controller.GetOperator()
-	data, err := authService.OrgSwitch(cmd)
-	controller.Response(data, err)
-}
+//func (controller *AuthController) Login() {
+//	authService := service.AuthService{}
+//	loginCmd := &command.LoginCommand{}
+//	err := controller.Unmarshal(loginCmd)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	data, err := authService.AuthLogin(loginCmd)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) GetAuthAccessToken() {
+//	authService := service.AuthService{}
+//	accessTokenCommand := &command.AccessTokenCommand{}
+//	err := controller.Unmarshal(accessTokenCommand)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	data, err := authService.GetAuthAccessToken(accessTokenCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) RefreshAuthAccessToken() {
+//	authService := service.AuthService{}
+//	refreshTokenCmd := &command.RefreshTokenCommand{}
+//	err := controller.Unmarshal(refreshTokenCmd)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	data, err := authService.RefreshAuthAccessToken(refreshTokenCmd)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) GetUserInfo() {
+//	authService := service.AuthService{}
+//	userInfoCommand := &command.UserInfoCommand{}
+//	err := controller.Unmarshal(userInfoCommand)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	userInfoCommand.Operator = controller.GetOperator()
+//	data, err := authService.GetUserInfo(userInfoCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) GetUserMenus() {
+//	authService := service.AuthService{}
+//	userMenusCommand := &command.UserMenusCommand{}
+//	err := controller.Unmarshal(userMenusCommand)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	userMenusCommand.Operator = controller.GetOperator()
+//	data, err := authService.GetUserMenus(userMenusCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) GetUserOrg() {
+//	authService := service.AuthService{}
+//	userOrgCommand := &command.UserOrgCommand{}
+//	err := controller.Unmarshal(userOrgCommand)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	userOrgCommand.Operator = controller.GetOperator()
+//	data, err := authService.GetUserOrg(userOrgCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) CompanySignUp() {
+//	authService := service.AuthService{}
+//	userOrgCommand := &command.CompanySignUpCommand{}
+//	err := controller.Unmarshal(userOrgCommand)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	//userOrgCommand.Operator = controller.GetOperator()
+//	data, err := authService.CompanySignUp(userOrgCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) ResetPassword() {
+//	authService := service.AuthService{}
+//	userOrgCommand := &command.ResetPasswordCommand{}
+//	err := controller.Unmarshal(userOrgCommand)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	//userOrgCommand.Operator = controller.GetOperator()
+//	data, err := authService.ResetPassword(userOrgCommand)
+//	controller.Response(data, err)
+//}
+//
+//func (controller *AuthController) OrgSwitch() {
+//	authService := service.AuthService{}
+//	cmd := &command.SwitchOrgCommand{}
+//	err := controller.Unmarshal(cmd)
+//	if err != nil {
+//		controller.Response(nil, err)
+//		return
+//	}
+//	cmd.Operator = controller.GetOperator()
+//	data, err := authService.OrgSwitch(cmd)
+//	controller.Response(data, err)
+//}

@@ -2,7 +2,6 @@ package routers
 
 
 import (
 import (
 	"github.com/beego/beego/v2/server/web"
 	"github.com/beego/beego/v2/server/web"
-	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/port/beego/controllers/mobile_client"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/port/beego/controllers/web_client"
 	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/port/beego/controllers/web_client"
 )
 )
 
 
@@ -22,6 +21,4 @@ func init() {
 	web.Router("/v1/web/users/selector/org", &web_client.UsersController{}, "Post:SelectorCompanyOrg")
 	web.Router("/v1/web/users/selector/org", &web_client.UsersController{}, "Post:SelectorCompanyOrg")
 	web.Router("/v1/web/users/selector/role", &web_client.UsersController{}, "Post:SelectorCompanyRole")
 	web.Router("/v1/web/users/selector/role", &web_client.UsersController{}, "Post:SelectorCompanyRole")
 	web.Router("/v1/web/users/selector/org/all", &web_client.UsersController{}, "Post:SelectorCompanyOrgAll")
 	web.Router("/v1/web/users/selector/org/all", &web_client.UsersController{}, "Post:SelectorCompanyOrgAll")
-
-	web.Router("/v1/web/auth/users-info", &mobile_client.AuthController{}, "Post:GetUserInfo")
 }
 }