internal/services/user_service.go - main - Arsinenko/CompClubAPI_Go

internal/services/user_service.go
182 строки5 KB
Arsinenko
Update
08 ноя 2025, 13:12
08 ноя 2025, 13:122f36b0f
package services

import (
	"CompClubAPI/internal/database/gen"
	"context"
	"database/sql"
	"errors"

	"github.com/lib/pq"
	"golang.org/x/crypto/bcrypt"
)

type UserResponse struct {
	Login   string `json:"login"`
	Role    string `json:"role"`
	Balance string `json:"balance"`
}

type CreateUserRequest struct {
	Login    string `json:"login"`
	Password string `json:"password"`
	Role     string `json:"role"`
	Balance  string `json:"balance"`
}

func (c CreateUserRequest) IsValid() bool {
	return c.Login != "" && c.Password != "" && c.Role != ""
}

type UpdateUserRequest struct {
	Property string `json:"property"`
	Value    string `json:"value"`
}

type LoginUserRequest struct {
	Login    string `json:"login"`
	Password string `json:"password"`
}

type UserService interface {
	CreateUser(model CreateUserRequest) (UserResponse, error)
	UpdateUser(login string, model UpdateUserRequest) (UserResponse, error)
	DeleteUser(login string) error
	GetUser(login string) (UserResponse, error)
	GetAllUsers() ([]UserResponse, error)
	LoginUser(model LoginUserRequest) (UserResponse, error)
}

type userService struct {
	queries *gen.Queries
}

func NewUserService(queries *gen.Queries) UserService {
	return &userService{queries: queries}
}

func (u userService) LoginUser(model LoginUserRequest) (UserResponse, error) {
	user, err := u.queries.GetUserByLogin(context.Background(), model.Login)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return UserResponse{}, errors.New("user not found")
		}
		return UserResponse{}, err
	}
	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(model.Password)); err != nil {
		return UserResponse{}, errors.New("incorrect password")
	}
	return UserResponse{
		Login:   user.Login,
		Role:    user.Role,
		Balance: user.Balance.String,
	}, nil
}

func (u userService) CreateUser(model CreateUserRequest) (UserResponse, error) {
	if !model.IsValid() {
		return UserResponse{}, errors.New("invalid model")
	}
	passwordHash, err := bcrypt.GenerateFromPassword([]byte(model.Password), bcrypt.DefaultCost)
	if err != nil {
		return UserResponse{}, err
	}
	user, err := u.queries.CreateUser(context.Background(), gen.CreateUserParams{
		Login:        model.Login,
		PasswordHash: string(passwordHash),
		Role:         model.Role,
		Balance:      sql.NullString{String: model.Balance, Valid: true},
	})
	if err != nil {
		var pqError *pq.Error
		if errors.As(err, &pqError) && pqError.Code == "23505" {
			return UserResponse{}, errors.New("user already exists")
		}
		return UserResponse{}, err
	}
	return UserResponse{
		Login:   user.Login,
		Role:    user.Role,
		Balance: user.Balance.String,
	}, nil
}

func (u userService) UpdateUser(login string, model UpdateUserRequest) (UserResponse, error) {
	switch model.Property {
	case "balance":
		user, err := u.queries.UpdateUserBalance(context.Background(), gen.UpdateUserBalanceParams{
			Login: login,
			Balance: sql.NullString{
				String: model.Value,
				Valid:  true,
			},
		})
		if err != nil {
			return UserResponse{}, err
		}
		return UserResponse{
			Login:   user.Login,
			Role:    user.Role,
			Balance: user.Balance.String,
		}, nil
		break
	case "password":
		passwordHash, err := bcrypt.GenerateFromPassword([]byte(model.Value), bcrypt.DefaultCost)
		if err != nil {
			return UserResponse{}, err
		}
		user, err := u.queries.UpdatePassword(context.Background(), gen.UpdatePasswordParams{
			Login:        login,
			PasswordHash: string(passwordHash),
		})
		if err != nil {
			return UserResponse{}, err
		}
		return UserResponse{
			Login:   user.Login,
			Role:    user.Role,
			Balance: user.Balance.String,
		}, nil

	}
	return UserResponse{}, errors.New("invalid property")
}

func (u userService) DeleteUser(login string) error {
	err := u.queries.DeleteUser(context.Background(), login)
	if err != nil {
		return err
	}
	return nil
}

func (u userService) GetUser(login string) (UserResponse, error) {
	user, err := u.queries.GetUserByLogin(context.Background(), login)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return UserResponse{}, errors.New("user not found")
		}
		return UserResponse{}, err
	}
	return UserResponse{
		Login:   user.Login,
		Role:    user.Role,
		Balance: user.Balance.String,
	}, nil

}

func (u userService) GetAllUsers() ([]UserResponse, error) {
	users, err := u.queries.GetAllUsers(context.Background())
	if err != nil {
		return nil, err
	}
	var response []UserResponse
	for _, user := range users {
		response = append(response, UserResponse{
			Login:   user.Login,
			Role:    user.Role,
			Balance: user.Balance.String,
		})
	}
	return response, nil
}