feat: group, codes controllers and services

.eslintrc.js

@@ -18,8 +18,8 @@ module.exports = {
   ignorePatterns: ['.eslintrc.js'],
   rules: {
     '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'on',
+    '@typescript-eslint/explicit-function-return-type': 2,
     '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'on',
+    '@typescript-eslint/no-explicit-any': 2,
   },
 };

package.json

@@ -22,14 +22,18 @@
     "check-branch-name": "chmod 755 ./.husky/hooks/check-branch-naming.sh && sh ./.husky/hooks/check-branch-naming.sh"
   },
   "dependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0",
-    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/common": "^10.3.10",
+    "@nestjs/core": "^10.3.10",
+    "@nestjs/mongoose": "^10.0.10",
+    "@nestjs/platform-express": "^10.3.10",
+    "@types/uuid": "^10.0.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "commitlint": "^19.3.0",
+    "mongoose": "^8.5.0",
     "reflect-metadata": "^0.2.0",
-    "rxjs": "^7.8.1"
+    "rxjs": "^7.8.1",
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.0.0",

src/accounts/dtos/account.dto.ts

@@ -0,0 +1,58 @@
+import { Optional } from '@nestjs/common';
+import { Expose, Type } from 'class-transformer';
+import {
+  IsArray,
+  IsDefined,
+  IsNotEmpty,
+  IsString,
+  MaxLength,
+} from 'class-validator';
+import { GroupDto } from 'src/groups/dtos/group.dto';
+import {
+  AccountBasicDto,
+  FieldConstraints,
+  SystemStatus,
+} from 'src/libs/shared';
+import { PermissionRule, RoleDto } from 'src/roles/dtos/role.dto';
+
+export class UserAccountDto extends AccountBasicDto {
+  get fullName(): string | null {
+    if (this.firstName && this.lastName) {
+      return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
+    }
+    return null;
+  }
+
+  get initials(): string {
+    if (this.firstName && this.lastName) {
+      return `${this.firstName[0].toUpperCase()}${this.lastName[0].toUpperCase()}`;
+    } else if (this.firstName) {
+      return `${this.firstName[0].toUpperCase()}`;
+    } else if (this.lastName) {
+      return `${this.lastName[0].toUpperCase()}`;
+    } else {
+      return '';
+    }
+  }
+
+  @Expose()
+  firstName?: string;
+
+  @Expose()
+  lastName?: string;
+
+  @Expose()
+  email!: string;
+
+  @Expose()
+  @Type(() => RoleDto)
+  role!: RoleDto[];
+
+  @Expose()
+  @Type(() => GroupDto)
+  groups!: GroupDto[];
+
+  @Expose()
+  @IsDefined()
+  status!: SystemStatus;
+}

src/app.module.ts

@@ -1,7 +1,10 @@
 import { Module } from '@nestjs/common';
+//import { MongooseModule } from '@nestjs/mongoose';
+//import { MongooseModels } from './models';
+import { CoreModule } from './core/core.module';
 
 @Module({
-  imports: [],
+  imports: [CoreModule],
   controllers: [],
   providers: [],
 })

src/codes/codes.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CodesService } from './codes.service';
+
+describe('CodesService', () => {
+  let service: CodesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CodesService],
+    }).compile();
+
+    service = module.get<CodesService>(CodesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/codes/codes.service.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class CodesService {
+  private codeToGroupId = {
+    'code123': 'group1',
+    'code456': 'group2',
+  }; //  TODO zamienić na faktyczną baze danych
+
+  async validateCode(code: string): Promise<string | null> {
+    const groupId = this.codeToGroupId[code] || null;
+    return groupId;
+  }
+}

src/config/app-requirements.ts

@@ -0,0 +1,11 @@
+export class AppRequirements {
+    static readonly MAX_CODE_LENGTH = 20;
+    static readonly CODE_PATTERN = /^[a-z0-9-]+$/;
+
+    static validateCode(code: string): boolean {
+      if (code.length > this.MAX_CODE_LENGTH) {
+        return false;
+      }
+      return this.CODE_PATTERN.test(code);
+    }
+  }

src/core/controllers/groups.controller.ts

@@ -0,0 +1,24 @@
+import { Controller, Post, Body, BadRequestException } from '@nestjs/common';
+import { GroupsService } from '../services/groups.service';
+import { JoinGroupDto } from 'src/core/dtos/join-group.dto';
+
+@Controller('groups')
+export class GroupsController {
+  constructor(private readonly groupsService: GroupsService) {}
+
+  @Post('join')
+  async joinGroup(
+    @Body() joinGroupDto: JoinGroupDto
+  ): Promise<{ message: string }> {
+    const { userId, code } = joinGroupDto;
+
+    try {
+      return await this.groupsService.addUserToGroup(userId, code);
+    } catch (error) {
+      if (error instanceof BadRequestException) {
+        throw error;
+      }
+      throw new BadRequestException('Error during adding user to group');
+    }
+  }
+}

src/core/core.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { GroupsController } from './controllers/groups.controller';
+import { GroupsService } from './services/groups.service';
+import { CodesService } from './services/codes.service';
+
+@Module({
+  imports: [],
+  controllers: [GroupsController],
+  providers: [GroupsService, CodesService],
+})
+export class CoreModule {}

src/core/dtos/join-group.dto.ts

@@ -0,0 +1,14 @@
+import { IsNotEmpty, IsString, Matches, MaxLength } from 'class-validator';
+
+export class JoinGroupDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(20)
+  @Matches(/^[aA-z0-9-]+$/)
+  code: string;
+}
+//dekorator match

src/core/services/codes.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CodesService } from './codes.service';
+
+describe('CodesService', () => {
+  let service: CodesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CodesService],
+    }).compile();
+
+    service = module.get<CodesService>(CodesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/core/services/codes.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@nestjs/common';
+import { JoinGroupDto } from 'src/core/dtos/join-group.dto';
+import { validate } from 'class-validator';
+@Injectable()
+export class CodesService {
+  private codeToGroupId = {
+    sCode123: 'group1',
+    ucode456: 'group2',
+    acode789: 'group3',
+  }; // TODO zamienić na faktyczną bazę danych
+
+  async validateCode(code: string): Promise<{
+    groupId: string | null;
+    roleId: string | null;
+    status: string;
+  }> {
+    if (!this.isValidCode(code)) {
+      return { groupId: null, roleId: null, status: 'invalid' };
+    }
+
+    const roleId = this.extractRole(code);
+    const groupId = this.codeToGroupId[code] || null;
+    const status = this.getCodeStatus(code);
+    return { groupId, roleId, status };
+  }
+
+  private extractRole(code: string): string | null {
+    const roleMap = {
+      s: 'starosta',
+      u: 'student',
+      a: 'administrator',
+    };
+    const rolePrefix = code[0];
+    return roleMap[rolePrefix] || null;
+  }
+
+  private getCodeStatus(code: string): string {
+    // TODO: Replace this logic with actual status checking logic
+    const statusMap = {
+      sCode123: 'active',
+      ucode456: 'used',
+      acode789: 'expired',
+    };
+    return statusMap[code] || 'expired';
+  }
+
+  private async isValidCode(code: string): Promise<boolean> {
+    const validateCodeDto = new JoinGroupDto();
+    validateCodeDto.code = code;
+
+    const errors = await validate(validateCodeDto);
+    return errors.length === 0;
+  }
+}
+//musi zwracac id grupy i id roli jaka kod nadaje, a jak nie to falsz, moze byc uzyty, moze wygasc

src/core/services/groups.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GroupsService } from './groups.service';
+
+describe('GroupsService', () => {
+  let service: GroupsService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [GroupsService],
+    }).compile();
+
+    service = module.get<GroupsService>(GroupsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/core/services/groups.service.ts

@@ -0,0 +1,59 @@
+import {
+  Injectable,
+  BadRequestException,
+  NotFoundException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { CodesService } from './codes.service';
+
+@Injectable()
+export class GroupsService {
+  constructor(private readonly codesService: CodesService) {}
+
+  async groupExists(code: string): Promise<boolean> {
+    const validationResult = await this.codesService.validateCode(code);
+    return (
+      validationResult.groupId !== null && validationResult.status === 'active'
+    );
+  }
+
+  async addUserToGroup(
+    userId: string,
+    code: string
+  ): Promise<{ message: string }> {
+    const validationResult = await this.codesService.validateCode(code);
+
+    if (!validationResult.groupId) {
+      throw new BadRequestException('Invalid code');
+    }
+
+    if (validationResult.status == 'expired') {
+      throw new BadRequestException('Inactive code');
+    }
+    if (validationResult.status == 'used') {
+      throw new BadRequestException('Used code');
+    }
+
+    try {
+      const groupId = validationResult.groupId;
+      const role = validationResult.roleId;
+
+      console.log(
+        `Dodaję użytkownika ${userId} do grupy ${groupId}, jako ${role}`
+      );
+      // TODO: Add logic
+
+      return { message: 'Student został pomyślnie dodany do grupy' };
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw new NotFoundException('Group not found');
+      }
+      throw new InternalServerErrorException('Error');
+    }
+  }
+
+  async removeStudentFromGroup(groupId: string, userId: string): Promise<void> {
+    console.log(`Usuwam użytkownika ${userId} z grupy ${groupId}`);
+    // TODO: Add logic
+  }
+}

src/groups/dtos/create-group.dto.ts

@@ -0,0 +1,29 @@
+import { Optional } from '@nestjs/common';
+import { Expose } from 'class-transformer';
+import { IsNotEmpty, IsString, MaxLength } from 'class-validator';
+import { FieldConstraints } from 'src/libs/shared';
+
+export class CreateGroupDto {
+  @Expose()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(FieldConstraints.FIRST_NAME.MAX_LENGTH)
+  name!: string;
+
+  @Expose()
+  @Optional()
+  @IsString()
+  @MaxLength(FieldConstraints.COURSE_NAME.MAX_LENGTH)
+  courseName?: string;
+
+  @Expose()
+  @Optional()
+  @IsString()
+  @MaxLength(FieldConstraints.DESCRIPTION.MAX_LENGTH)
+  description?: string;
+
+  @Expose()
+  @IsString()
+  @IsNotEmpty()
+  avatar!: string;
+}