evening_detective_server/internal/app/server.go

package app

import (
	"context"
	"evening_detective_server/internal/modules/file_storage"
	"evening_detective_server/internal/modules/processor_jwt"
	"evening_detective_server/internal/modules/roles"
	"evening_detective_server/internal/services/file_service"
	"evening_detective_server/internal/services/ui_service"
	"evening_detective_server/internal/services/users_service"
	proto "evening_detective_server/proto"

	"google.golang.org/genproto/googleapis/api/httpbody"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

type server struct {
	proto.UnsafeEveningDetectiveServerServer

	usersService *users_service.UsersService
	uiService    *ui_service.UiService
	fileService  *file_service.FileService
}

func NewServer(
	usersService *users_service.UsersService,
	uiService *ui_service.UiService,
	fileService *file_service.FileService,
) proto.EveningDetectiveServerServer {
	return &server{
		usersService: usersService,
		uiService:    uiService,
		fileService:  fileService,
	}
}

func (s *server) Ping(_ context.Context, _ *proto.PingReq) (*proto.PingRsp, error) {
	return &proto.PingRsp{}, nil
}

func (s *server) Echo(_ context.Context, req *proto.EchoReq) (*proto.EchoRsp, error) {
	return &proto.EchoRsp{Text: req.Text}, nil
}

func (s *server) Signup(ctx context.Context, req *proto.SignupReq) (*proto.SignupRsp, error) {
	err := s.usersService.AddUser(ctx, req.Username, req.Email)
	if err != nil {
		return &proto.SignupRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.SignupRsp{}, nil
}

func (s *server) RefreshPassword(ctx context.Context, req *proto.RefreshPasswordReq) (*proto.RefreshPasswordRsp, error) {
	err := s.usersService.RefreshPassword(ctx, req.Email)
	if err != nil {
		return &proto.RefreshPasswordRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.RefreshPasswordRsp{}, nil
}

func (s *server) Login(ctx context.Context, req *proto.LoginReq) (*proto.LoginRsp, error) {
	accessToken, refreshToken, err := s.usersService.Login(ctx, req.Email, req.Password)
	if err != nil {
		return &proto.LoginRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.LoginRsp{
		AccessToken:  accessToken,
		RefreshToken: refreshToken,
	}, nil
}

func (s *server) Refresh(ctx context.Context, req *proto.RefreshReq) (*proto.RefreshRsp, error) {
	accessToken, refreshToken, err := s.usersService.Refresh(ctx, req.RefreshToken)
	if err != nil {
		return &proto.RefreshRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.RefreshRsp{
		AccessToken:  accessToken,
		RefreshToken: refreshToken,
	}, nil
}

func (s *server) GetUsers(ctx context.Context, req *proto.GetUsersReq) (*proto.GetUsersRsp, error) {
	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
	if !roles.HasRole(claims, roles.Admin) {
		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
	}
	users, err := s.usersService.GetUsers(ctx)
	if err != nil {
		return &proto.GetUsersRsp{
			Error: err.Error(),
		}, nil
	}

	resUsers := make([]*proto.User, 0, len(users))
	for _, user := range users {
		resUsers = append(resUsers, mapUser(user))
	}
	return &proto.GetUsersRsp{
		Users: resUsers,
	}, nil
}

func (s *server) GetUserById(ctx context.Context, req *proto.GetUserByIdReq) (*proto.GetUserByIdRsp, error) {
	user, err := s.usersService.GetUserByID(ctx, int(req.Id))
	if err != nil {
		return &proto.GetUserByIdRsp{
			Error: err.Error(),
		}, nil
	}

	return &proto.GetUserByIdRsp{
		User: mapUser(user),
	}, nil
}

func (s *server) GetMe(ctx context.Context, req *proto.GetMeReq) (*proto.GetMeRsp, error) {
	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
	user, err := s.usersService.GetUserByID(ctx, claims.UserID)
	if err != nil {
		return &proto.GetMeRsp{
			Error: err.Error(),
		}, nil
	}

	return &proto.GetMeRsp{
		User: mapUser(user),
	}, nil
}

func (s *server) AddUserRole(ctx context.Context, req *proto.AddUserRoleReq) (*proto.AddUserRoleRsp, error) {
	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
	if !roles.HasRole(claims, roles.Admin) {
		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
	}
	if err := s.usersService.AddUserRole(ctx, int(req.Id), req.Role); err != nil {
		return &proto.AddUserRoleRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.AddUserRoleRsp{}, nil
}

func (s *server) DeleteUserRole(ctx context.Context, req *proto.DeleteUserRoleReq) (*proto.DeleteUserRoleRsp, error) {
	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
	if !roles.HasRole(claims, roles.Admin) {
		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
	}
	if err := s.usersService.DeleteUserRole(ctx, int(req.Id), req.Role); err != nil {
		return &proto.DeleteUserRoleRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.DeleteUserRoleRsp{}, nil
}

func (s *server) GetPermissions(
	ctx context.Context,
	req *proto.GetPermissionsReq,
) (*proto.GetPermissionsRsp, error) {
	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
	permissions := s.uiService.GetPermissions(claims.Roles)
	return &proto.GetPermissionsRsp{
		Permissions: permissions,
	}, nil
}

func (s *server) UploadFile(ctx context.Context, req *proto.UploadFileReq) (*proto.UploadFileRsp, error) {
	filename, err := s.fileService.UploadFile(
		ctx,
		&file_storage.File{
			Name: req.Filename,
			Data: req.Data,
		},
	)
	if err != nil {
		return &proto.UploadFileRsp{
			Error: err.Error(),
		}, nil
	}
	return &proto.UploadFileRsp{
		Filename: filename,
	}, nil
}

func (s *server) DownloadFile(ctx context.Context, req *proto.DownloadFileReq) (*httpbody.HttpBody, error) {
	file, err := s.fileService.DownloadFile(ctx, req.Filename)
	if err != nil {
		return &httpbody.HttpBody{}, nil
	}
	return &httpbody.HttpBody{
		Data:        file.Data,
		ContentType: file.Mime,
	}, nil
}