users api

src/users/users.service.ts

@@ -1,20 +1,100 @@
-import {Model, Connection} from 'mongoose';
-import {Injectable} from '@nestjs/common';
+import {Model, Connection, Document} from 'mongoose';
+import {Injectable, NotFoundException, BadGatewayException} from '@nestjs/common';
 import {InjectConnection} from '@nestjs/mongoose';
 import {DB_NAME, USERS_CONTROLLER} from 'src/consts';
-import {User, UserSchema} from './users.schema';
+import {User, UserSchema, CreateUserRequest, UserResponse, UserModel, UpdateUserRequest} from './users.schema';
+
+const validateModel = async (user: Document) => {
+    try {
+        await user.validate();
+    } catch (e) {
+        throw new BadGatewayException(e);
+    }
+};
+
+const prepareUserToUserModel = (user: User): UserModel => ({
+    login: user.login,
+    avatar: user.avatar,
+    password: user.password,
+    is_admin: user.is_admin,
+    access_token: user.access_token,
+    refresh_token: user.refresh_token,
+});
+
+const prepareUserToUserResponse = (user: User): UserResponse => ({
+    login: user.login,
+    avatar: user.avatar,
+    is_admin: user.is_admin,
+});
 
 @Injectable()
 export class UserService {
     constructor(
         @InjectConnection(DB_NAME) private dbConnection: Connection,
     ) {}
-    
-    get userModel(): Model<User> {
+
+    userModel(): Model<User> {
         return this.dbConnection.model<User>(USERS_CONTROLLER, UserSchema);
     }
 
-    findAll(): any {
-        return this.userModel.find().exec();
+    async findUser(login: string): Promise<UserModel> {
+        const user = await this.userModel().findOne({login});
+        return user ? prepareUserToUserModel(user) : user;
+    }
+
+    async findOne(login: string): Promise<UserResponse> {
+        const user = await this.userModel().findOne({login});
+        if (!user) {
+            throw new NotFoundException(`Пользователь с логином ${login} не найден`);
+        }
+        return prepareUserToUserResponse(user);
+    }
+
+    async findAll(): Promise<UserResponse[]> {
+        const users = await this.userModel().find().exec();
+        return users.map(prepareUserToUserResponse);
+    }
+
+    async create(user: CreateUserRequest): Promise<UserResponse> {
+        const searchUser = await this.findUser(user.login);
+
+        if (searchUser) {
+            throw new NotFoundException(`Пользователь с логином ${user.login} уже существует`);
+        }
+
+        const Model = await this.userModel();
+        const createUser = new Model(user);
+        await validateModel(createUser);
+
+        const savedUser = await createUser.save();
+
+        return prepareUserToUserResponse(savedUser);
+    }
+
+    async update(user: UpdateUserRequest): Promise<UserResponse> {
+        const searchUser = await this.userModel().findOne({login: user.login});
+
+        const Model = await this.userModel();
+        const updateUser = new Model({
+            ...user,
+            password: searchUser.password,
+        });
+        await validateModel(updateUser);
+
+        await searchUser.updateOne({
+            ...{
+                avatar: user.avatar,
+            },
+        });
+
+        return prepareUserToUserResponse(updateUser);
+    }
+
+    async removeOne(login: string): Promise<UserResponse> {
+        const searchUser = await this.userModel().findOne({login});
+
+        await this.userModel().deleteOne({login});
+
+        return prepareUserToUserResponse(searchUser);
     }
 }