package service

import (
	"github.com/google/uuid"
	"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"

	"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/auth/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-gateway/pkg/application/factory"
	"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 (
		authCode string
		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":
		authCode, err = srv.SignInPassword(loginCommand.Phone, loginCommand.Password)
	case "signInCaptcha":
		authCode, err = srv.SignInCaptcha(loginCommand.Phone, loginCommand.Captcha)
	default:
		err = application.ThrowError(application.TRANSACTION_ERROR, "登录方式无法解析")
	}
	result, err = srv.GetAuthAccessToken(&command.AccessTokenCommand{
		AuthCode:    authCode,
		SessionMode: loginCommand.SessionMode,
	})
	return map[string]interface{}{
		"access": result,
	}, err
}

//AuthLogin 用户登录
func (srv AuthService) AuthLoginPwd(loginCommand *command.LoginPwdCommand) (interface{}, error) {
	if err := loginCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	login := &command.LoginCommand{
		GrantType:   "signInPassword",
		Phone:       loginCommand.Username,
		Password:    loginCommand.Password,
		SessionMode: loginCommand.SessionMode,
	}
	return srv.AuthLogin(login)
}

//AuthLogin 用户登录
func (srv AuthService) AuthLoginSms(loginCommand *command.LoginSmsCommand) (interface{}, error) {
	if err := loginCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	login := &command.LoginCommand{
		GrantType:   "signInCaptcha",
		Phone:       loginCommand.Phone,
		Captcha:     loginCommand.Code,
		SessionMode: loginCommand.SessionMode,
	}
	return srv.AuthLogin(login)
}

//SendSmsCaptcha 发送验证码短信
func (srv AuthService) SendSmsCaptcha(smsCodeCommand *command.SendSmsCodeCommand) error {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.SendSms(smsCodeCommand.Phone)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

//SignInPassword 使用账号密码校验
func (srv AuthService) SignInPassword(account string, password string) (string, error) {
	creationUserGateway := allied_creation_user.NewHttplibAlliedCreationUser(domain.Operator{})
	_, err := creationUserGateway.AuthCheckPassword(allied_creation_user.ReqAuthCheckPassword{
		Password: password,
		Phone:    account,
	})
	if err != nil {
		return "", 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 "", application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	//result := map[string]string{
	//	"authCode": authcode,
	//}
	return authcode, nil
}

//SignInCaptcha 使用手机验证码登录
func (srv AuthService) SignInCaptcha(phone string, captcha string) (string, error) {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.CheckSmsCode(phone, captcha)
	if err != nil {
		return "", application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	ltoken := domain.LoginToken{
		UserId:    0,
		Account:   phone,
		Platform:  domain.LoginPlatformApp,
		CompanyId: 0,
	}
	authcode, err := ltoken.GenerateAuthCode()
	if err != nil {
		return "", application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return authcode, 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
}

//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{}
	_, err := qrmsg.GenerateImageBase64() //imgBase64
	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,
		"key": qrmsg.Token,
	}
	return data, nil
}

//QrcodeLoginStatus 询问扫码登录状态
func (srv AuthService) QrcodeLoginStatus(queryParam *query.QrcodeLoginStatusQuery) (interface{}, error) {
	qrmsg := domain.QrcodeMessage{}
	err := qrmsg.ParseToken(queryParam.Key)
	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,
		"access":  "",
	}
	return data, nil
}

//CheckSmsCode 验证手机短信验证码
func (srv AuthService) CheckSmsCode(smsCodeCommand *command.CheckSmsCodeCommand) (interface{}, error) {
	smsServeGateway := sms_serve.NewHttplibHttplibSmsServe()
	err := smsServeGateway.CheckSmsCode(smsCodeCommand.Phone, smsCodeCommand.SmsCode)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	uid := uuid.New()
	pcc := cache.PhoneCheckCache{}
	if err := pcc.Add(uid.String(), cache.PhoneCheckItem{
		Phone:           smsCodeCommand.Phone,
		SmsCodeIdentity: uid.String(),
		Action:          smsCodeCommand.Action,
	}); err != nil {
		log.Logger.Error(err.Error())
		return nil, application.ThrowError(application.BUSINESS_ERROR, "系统错误")
	}
	return map[string]interface{}{
		"smsCodeIdentity": uid.String(),
	}, nil
}