silvermobi/services/mobility-accounts.go

package services

import (
	"context"

	"git.coopgo.io/coopgo-apps/silvermobi/models"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	ma "git.coopgo.io/coopgo-platform/mobility-accounts/storage"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/protobuf/types/known/structpb"
)

type MobilityAccountService struct {
	Client mobilityaccounts.MobilityAccountsClient
}

func NewMobilityAccountService(mobilityAccountsDial string) (MobilityAccountService, error) {
	mobilityAccountsConn, err := grpc.NewClient(mobilityAccountsDial,
		grpc.WithTransportCredentials(insecure.NewCredentials()))

	client := mobilityaccounts.NewMobilityAccountsClient(mobilityAccountsConn)
	if err != nil {
		return MobilityAccountService{}, err
	}

	return MobilityAccountService{
		Client: client,
	}, nil
}

func (s MobilityAccountService) Login(ctx context.Context, username, password, namespace string) (*models.Account, error) {
	resp, err := s.Client.Login(ctx, &mobilityaccounts.LoginRequest{
		Username:  username,
		Password:  password,
		Namespace: namespace,
	})
	if err != nil {
		return nil, err
	}

	account := resp.Account.ToStorageType()
	return s.ToAccountModel(account), nil
}

func (s MobilityAccountService) UpdateAccountData(ctx context.Context, id string, data map[string]any) error {
	d, err := structpb.NewStruct(data)

	if err != nil {
		return err
	}

	if _, err = s.Client.UpdateData(ctx, &mobilityaccounts.UpdateDataRequest{
		Account: &mobilityaccounts.Account{
			Id:   id,
			Data: d,
		},
	}); err != nil {
		return err
	}

	return nil
}

func (s MobilityAccountService) UpdatePassword(ctx context.Context, id string, password string) bool {
	_, err := s.Client.ChangePassword(ctx, &mobilityaccounts.ChangePasswordRequest{
		Id:       id,
		Password: password,
	})

	if err != nil {
		return false
	}

	return true
}

func (s MobilityAccountService) GetAccountUsername(ctx context.Context,
	username string, namespace string) (*models.Account, error) {

	resp, err := s.Client.GetAccountUsername(ctx, &mobilityaccounts.GetAccountUsernameRequest{
		Username:  username,
		Namespace: namespace,
	})
	if err != nil {
		return nil, err
	}

	return s.ToAccountModel(resp.Account.ToStorageType()), nil
}

func (s MobilityAccountService) Register(ctx context.Context, username string, password string,
	email string, phoneNumber string, data map[string]any, namespace string) (*models.Account, error) {

	var resp *mobilityaccounts.RegisterResponse

	account := &ma.Account{
		Authentication: ma.AccountAuth{
			Local: ma.LocalAuth{
				Username:    username,
				Password:    password,
				Email:       email,
				PhoneNumber: phoneNumber,
			},
		},
		Namespace: namespace,
		Data:      data,
	}

	acc, err := mobilityaccounts.AccountFromStorageType(account)
	if err != nil {
		return nil, err
	}

	if resp, err = s.Client.Register(ctx, &mobilityaccounts.RegisterRequest{
		Account: acc,
	}); err != nil {
		return nil, err
	}

	return s.ToAccountModel(resp.Account.ToStorageType()), nil
}
func (s MobilityAccountService) UpdatePhoneNumber(ctx context.Context, accountID string, phoneNumber string,
	verified bool, verificationCode string) error {

	if _, err := s.Client.UpdatePhoneNumber(
		ctx,
		&mobilityaccounts.UpdatePhoneNumberRequest{
			Id:               accountID,
			PhoneNumber:      phoneNumber,
			Verified:         verified,
			VerificationCode: verificationCode,
		},
	); err != nil {
		return err
	}

	return nil
}

func (s MobilityAccountService) SetAccountType(ctx context.Context, id string, accountType string) error {

	var (
		account *mobilityaccounts.GetAccountResponse
		err     error
	)

	if account, err = s.Client.GetAccount(ctx, &mobilityaccounts.GetAccountRequest{
		Id: id,
	}); err != nil {
		return err
	}

	data := make(map[string]interface{})

	data["type"] = accountType

	dataStruct := &structpb.Struct{
		Fields: make(map[string]*structpb.Value),
	}

	for key, value := range data {

		stringValue, ok := value.(string)

		if !ok {
			continue
		}

		dataStruct.Fields[key] = &structpb.Value{
			Kind: &structpb.Value_StringValue{
				StringValue: stringValue,
			},
		}
	}

	account.Account.Data = dataStruct

	if _, err = s.Client.UpdateData(ctx, &mobilityaccounts.UpdateDataRequest{
		Account: account.Account,
	}); err != nil {
		return err
	}

	return nil

}

func (s MobilityAccountService) UpdateAccountBirthDate(ctx context.Context, id string,
	namespace string, birthdate string) error {

	var (
		account *mobilityaccounts.GetAccountResponse
		err     error
	)

	if account, err = s.Client.GetAccount(ctx, &mobilityaccounts.GetAccountRequest{
		Id: id,
	}); err != nil {
		return err
	}
	data := make(map[string]interface{})

	data["birthdate"] = birthdate

	dataStruct := &structpb.Struct{
		Fields: make(map[string]*structpb.Value),
	}

	for key, value := range data {
		stringValue, ok := value.(string)

		if !ok {
			continue
		}

		dataStruct.Fields[key] = &structpb.Value{
			Kind: &structpb.Value_StringValue{
				StringValue: stringValue,
			},
		}
	}

	account.Account.Data = dataStruct

	if _, err = s.Client.UpdateData(ctx, &mobilityaccounts.UpdateDataRequest{
		Account: account.Account,
	}); err != nil {
		return err
	}

	return nil
}

func (s MobilityAccountService) ToAccountModel(account ma.Account) *models.Account {

	var (
		accountType, birthDate, phoneNumber, email string
		ok                                         bool
	)

	firstName := account.Data["first_name"].(string)
	lastName := account.Data["last_name"].(string)

	if birthDate, ok = account.Data["birthdate"].(string); !ok {
		birthDate = ""
	}

	if accountType, ok = account.Data["type"].(string); !ok {
		accountType = ""
	}

	if phoneNumber, ok = account.Data["phone_number"].(string); !ok {
		phoneNumber = ""
	}

	if email, ok = account.Data["email"].(string); !ok {
		email = ""
	}

	return &models.Account{
		ID:        account.ID,
		FirstName: firstName,
		LastName:  lastName,
		Email:     email,
		BirthDate: birthDate,
		Type:      accountType,
		LocalCredentials: models.LocalCredentials{
			Email:               account.Authentication.Local.Email,
			EmailVerified:       account.Authentication.Local.EmailValidation.Validated,
			EmailValidationCode: account.Authentication.Local.EmailValidation.ValidationCode,
			PhoneNumber:         phoneNumber,
			PhoneNumberVerified: account.Authentication.Local.PhoneNumberValidation.Validated,
		},
	}
}