Merge branch 'dev' into feature/13-runner_controllers

src/models/creation/CreateUser.ts

@@ -0,0 +1,76 @@
+import * as argon2 from "argon2";
+import { IsEmail, IsOptional, IsPhoneNumber, IsString, IsUUID } from 'class-validator';
+import { getConnectionManager } from 'typeorm';
+import * as uuid from 'uuid';
+import { UserGroupNotFoundError, UsernameOrEmailNeededError } from '../../errors/UserErrors';
+import { User } from '../entities/User';
+import { UserGroup } from '../entities/UserGroup';
+
+export class CreateUser {
+    @IsString()
+    firstname: string;
+    @IsString()
+    middlename?: string;
+    @IsOptional()
+    @IsString()
+    username?: string;
+    @IsPhoneNumber("ZZ")
+    @IsOptional()
+    phone?: string;
+    @IsString()
+    password: string;
+    @IsString()
+    lastname: string;
+    @IsEmail()
+    @IsString()
+    email?: string;
+    @IsOptional()
+    groupId?: number[] | number
+    @IsUUID("4")
+    uuid: string;
+
+    public async toUser(): Promise<User> {
+        let newUser: User = new User();
+
+        if (this.email === undefined && this.username === undefined) {
+            throw new UsernameOrEmailNeededError();
+        }
+
+        if (this.groupId) {
+            if (!Array.isArray(this.groupId)) {
+                this.groupId = [this.groupId]
+            }
+            const groupIDs: number[] = this.groupId
+            let errors = 0
+            const validateusergroups = async () => {
+                let foundgroups = []
+                for (const g of groupIDs) {
+                    const found = await getConnectionManager().get().getRepository(UserGroup).find({ id: g });
+                    if (found.length === 0) {
+                        errors++
+                    } else {
+                        foundgroups.push(found[0])
+                    }
+                }
+                newUser.groups = foundgroups
+            }
+            await validateusergroups()
+            if (errors !== 0) {
+                throw new UserGroupNotFoundError();
+            }
+        }
+
+        const new_uuid = uuid.v4()
+
+        newUser.email = this.email
+        newUser.username = this.username
+        newUser.firstname = this.firstname
+        newUser.middlename = this.middlename
+        newUser.lastname = this.lastname
+        newUser.uuid = new_uuid
+        newUser.password = await argon2.hash(this.password + new_uuid);
+
+        console.log(newUser)
+        return newUser;
+    }
+}

src/models/creation/CreateUserGroup.ts

@@ -0,0 +1,28 @@
+import { IsOptional, IsString } from 'class-validator';
+import { GroupNameNeededError } from '../../errors/UserGroupErrors';
+import { UserGroup } from '../entities/UserGroup';
+
+export class CreateUserGroup {
+    @IsOptional()
+    @IsString()
+    name: string;
+    @IsOptional()
+    @IsString()
+    description?: string;
+
+    public async toUserGroup(): Promise<UserGroup> {
+        let newUserGroup: UserGroup = new UserGroup();
+
+        if (this.name === undefined) {
+            throw new GroupNameNeededError();
+        }
+
+        newUserGroup.name = this.name
+        if (this.description) {
+            newUserGroup.description = this.description
+        }
+
+        console.log(newUserGroup)
+        return newUserGroup;
+    }
+}