shopping-service/domain/service/user.go

package service

import (
	"context"
	"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) GetUserList(query *pb.GetUserListRequest) ([]*pb.User, int64, error) {
	users := make([]*pb.User, 0)
	list, count, err := svc.Repository.GetUserList(query)
	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) GetUser(query *pb.GetUserRequest) (*pb.User, error) {
	var rsp pb.User
	if exists, err := svc.Repository.IsUserExists(query.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)
		}
	}
	// CreateUser
	user, err := svc.Repository.GetUser(query.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) CreateUser(ctx context.Context, data *pb.CreateUserRequest) error {
	if exists, err := svc.Repository.IsUserExists(data.Username); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	} else {
		if exists {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.AccountDoesNotExist], 400)
		}
	}
	group, err := svc.Repository.GetUserGroup(&pb.GetUserGroupRequest{Code: data.Code})
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errorcode.New(svc.Namespace, common.ErrorMessage[common.NotAssignedError], 500)
		} else {
			return errorcode.New(svc.Namespace, err.Error(), 500)
		}
	}
	if group.ID != utils.UserUserGroupID {
		return errorcode.New(svc.Namespace, common.ErrorMessage[common.NotAssignedError], 500)
	}
	password, _ := utils.HashPassword(data.Password)
	_, 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:     utils.UserUserGroupID,
		Status:      pb.StatusEnum_ENABLED,
	}
	if err = svc.Repository.CreateUser(&user); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), http.StatusBadRequest)
	}
	return nil
}

func (svc *Service) UpdateUser(ctx context.Context, data *pb.UpdateUserRequest) error {
	if exists, err := svc.Repository.IsUserExists(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.UpdateUser(data.UserId, m); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	}
	return nil
}

func (svc *Service) DeleteUser(data *pb.DeleteUserRequest) error {
	if exists, err := svc.Repository.IsUserExists(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.DeleteUser(data.UserId); err != nil {
		return errorcode.New(svc.Namespace, err.Error(), 500)
	}
	return nil
}

func (svc *Service) ToggleUser(ctx context.Context, data *pb.ToggleUserRequest) error {
	if exists, err := svc.Repository.IsUserExists(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
}