shopping-service/domain/service/adminuser.go

package service

import (
	"context"
	"fmt"
	"github.com/pkg/errors"
	"gorm.io/gorm"
	"net/http"
	"sghgogs.com/micro/common"
	"sghgogs.com/micro/common/errorcode"
	req "sghgogs.com/micro/shopping-service/domain/model/request"
	pb "sghgogs.com/micro/shopping-service/proto"
	"sghgogs.com/micro/shopping-service/utils"
	"time"
)

func (svc *Service) GetAdminUserList(params *pb.GetAdminUserListRequest) ([]*pb.User, int64, error) {
	users := make([]*pb.User, 0)
	list, count, err := svc.Repository.GetAdminUserList(params)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return users, 0, nil
		} else {
			return users, 0, err
		}
	}
	for _, item := range list {
		users = append(users, svc.getUserRes(item))
	}
	return users, count, nil
}

func (svc *Service) GetAllAdminUser() ([]*pb.Base, error) {
	bases := make([]*pb.Base, 0)
	user, err := svc.Repository.GetAllAdminUser()
	if err != nil {
		return bases, errorcode.New(svc.Namespace, err.Error(), 500)
	}
	for _, item := range user {
		bases = append(bases, &pb.Base{
			Key:   item.Username,
			Value: fmt.Sprintf("%v", item.ID),
		})
	}
	return bases, nil
}

func (svc *Service) GetAdminUser(params *pb.GetAdminUserRequest) (*pb.User, error) {
	var rsp *pb.User
	if exists, err := svc.Repository.IsAdminUserExists(params.UserId); err != nil {
		return rsp, errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return rsp, errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	user, err := svc.Repository.GetAdminUser(params.UserId)
	if err != nil {
		return rsp, errorcode.New(svc.Namespace, err.Error(), 500)
	}
	res := svc.getUserRes(user)
	res.Roles = svc.getBaseRoleRes(user.Roles)
	return res, nil
}

func (svc *Service) CreateAdminUser(ctx context.Context, data *pb.CreateAdminUserRequest) error {
	password, _ := utils.HashPassword(data.Password)
	group, err := svc.GetUserGroup(&pb.GetUserGroupRequest{Code: "17a78673-9762-4e9e-8f87-595a049f75bf"})
	if err != nil {
		return err
	}
	_, by, _, _ := utils.ParseMetadata(ctx)
	user := req.User{
		Username:    data.Username,
		Password:    password,
		PhoneNumber: data.PhoneNumber,
		Email:       data.Email,
		Avatar:      data.Avatar,
		CreatedAt:   time.Now(),
		CreatedBy:   by,
		GroupID:     group.Id,
		Status:      pb.StatusEnum_ENABLED,
	}
	if err = svc.Repository.CreateAdminUser(data.Roles, &user); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), http.StatusBadRequest)
	}
	return nil
}

func (svc *Service) UpdateAdminUser(ctx context.Context, data *pb.UpdateAdminUserRequest) error {
	if exists, err := svc.Repository.IsAdminUserExists(data.UserId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	_, by, _, _ := utils.ParseMetadata(ctx)
	m := map[string]interface{}{
		"email":        data.Email,
		"avatar":       data.Avatar,
		"phone_number": data.PhoneNumber,
		"updated_at":   time.Now(),
		"updated_by":   by,
	}
	if err := svc.Repository.UpdateAdminUser(data.UserId, data.Roles, svc.filterNilFields(m)); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), http.StatusBadRequest)
	}
	return nil
}

func (svc *Service) ToggleAdminUser(ctx context.Context, data *pb.ToggleAdminUserRequest) error {
	if exists, err := svc.Repository.IsAdminUserExists(data.UserId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	_, by, _, _ := utils.ParseMetadata(ctx)
	if err := svc.Repository.ToggleAdminUser(data.UserId, data.Status, map[string]interface{}{
		"updated_at": time.Now(),
		"updated_by": by,
		"status":     data.Status,
	}); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), http.StatusBadRequest)
	}
	return nil
}

func (svc *Service) DeleteAdminUser(data *pb.DeleteAdminUserRequest) error {
	if exists, err := svc.Repository.IsAdminUserExists(data.UserId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if !exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	if err := svc.Repository.DeleteAdminUser(data.UserId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), http.StatusBadRequest)
	}
	return nil
}