feat: Implement initial User, Service, Veil, and Gallery modules including their controllers, services, repositories, and Mongoose schemas.

Author: beginwebdev2002

backend/src/gallery/gallery.module.ts

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { GalleryService } from './application/gallery.service';
+import { GalleryController } from './presentation/gallery.controller';
 import { GalleryRepository } from './infrastructure/repositories/gallery.repository';
 import {
   GallerySchema,
@@ -13,6 +14,7 @@ import {
       { name: GallerySchemaEntity.name, schema: GallerySchema },
     ]),
   ],
+  controllers: [GalleryController],
   providers: [GalleryService, GalleryRepository],
   exports: [GalleryService],
 })

backend/src/gallery/presentation/gallery.controller.ts

@@ -0,0 +1,18 @@
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { GalleryService } from '../application/gallery.service';
+import { Gallery } from '../domain/gallery.entity';
+
+@Controller('gallery')
+export class GalleryController {
+  constructor(private readonly galleryService: GalleryService) {}
+
+  @Get()
+  async findAll(): Promise<Gallery[]> {
+    return this.galleryService.findAll();
+  }
+
+  @Post()
+  async create(@Body() gallery: Omit<Gallery, 'id' | 'createdAt'>): Promise<Gallery> {
+    return this.galleryService.create(gallery);
+  }
+}

backend/src/service/presentation/service.controller.ts

@@ -0,0 +1,18 @@
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { ServiceService } from '../application/service.service';
+import { Service } from '../domain/service.entity';
+
+@Controller('services')
+export class ServiceController {
+  constructor(private readonly serviceService: ServiceService) {}
+
+  @Get()
+  async findAll(): Promise<Service[]> {
+    return this.serviceService.findAll();
+  }
+
+  @Post()
+  async create(@Body() service: Omit<Service, 'id' | 'createdAt'>): Promise<Service> {
+    return this.serviceService.create(service);
+  }
+}

backend/src/service/service.module.ts

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { ServiceService } from './application/service.service';
+import { ServiceController } from './presentation/service.controller';
 import { ServiceRepository } from './infrastructure/repositories/service.repository';
 import {
   ServiceSchema,
@@ -13,6 +14,7 @@ import {
       { name: ServiceSchemaEntity.name, schema: ServiceSchema },
     ]),
   ],
+  controllers: [ServiceController],
   providers: [ServiceService, ServiceRepository],
   exports: [ServiceService],
 })

backend/src/user/application/user.service.ts

@@ -6,6 +6,10 @@ import { UserRepository } from '@user/infrastructure/repositories/user.repositor
 export class UserService {
   constructor(private readonly userRepository: UserRepository) {}
 
+  async findAll(): Promise<User[]> {
+    return await this.userRepository.findAll();
+  }
+
   async findOrCreate(
     telegramId: number,
     profile: {
@@ -27,4 +31,8 @@ export class UserService {
 
     return user;
   }
+
+  async create(user: User): Promise<User> {
+    return await this.userRepository.create(user);
+  }
 }

backend/src/user/infrastructure/repositories/user.repository.ts

@@ -10,6 +10,11 @@ export class UserRepository {
     @InjectModel(UserSchemaEntity.name) private userModel: Model<UserDocument>,
   ) {}
 
+  async findAll(): Promise<User[]> {
+    const docs = await this.userModel.find().exec();
+    return docs.map((doc) => this.toDomain(doc));
+  }
+
   async findByTelegramId(telegramId: number): Promise<User | null> {
     const doc = await this.userModel.findOne({ telegramId }).exec();
     return doc ? this.toDomain(doc) : null;

backend/src/user/infrastructure/schemas/user.schema.ts

@@ -11,16 +11,16 @@ export class UserSchemaEntity {
   @Prop({ required: true })
   firstName: string;
 
-  @Prop()
+  @Prop({ required: true })
   lastName: string;
 
-  @Prop()
+  @Prop({ required: true })
   username: string;
 
-  @Prop()
+  @Prop({ required: false })
   photoUrl: string;
 
-  @Prop({ default: 'user', enum: ['user', 'admin'] })
+  @Prop({ required: true, default: 'user', enum: ['user', 'admin'] })
   role: string;
 }
 

backend/src/user/presentation/user.controller.ts

@@ -0,0 +1,24 @@
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { UserService } from '../application/user.service';
+import { User } from '@user/domain/user.entity';
+
+@Controller('users')
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+
+  @Get()
+  async findAll(): Promise<User[]> {
+    return this.userService.findAll();
+  }
+
+  @Get('profile')
+  async getProfile() {
+    // Placeholder for profile retrieval logic
+    // In a real app, this would use @Req() or @User() decorator to get the authenticated user
+    return { message: 'Profile endpoint' };
+  }
+  @Post()
+  async create(@Body() user: User): Promise<User> {
+    return this.userService.create(user);
+  }
+}

backend/src/user/user.module.ts

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { UserService } from './application/user.service';
+import { UserController } from './presentation/user.controller';
 import { UserRepository } from './infrastructure/repositories/user.repository';
 import {
   UserSchema,
@@ -13,6 +14,7 @@ import {
       { name: UserSchemaEntity.name, schema: UserSchema },
     ]),
   ],
+  controllers: [UserController],
   providers: [UserService, UserRepository],
   exports: [UserService],
 })

backend/src/veil/presentation/veil.controller.ts

@@ -0,0 +1,23 @@
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { VeilService } from '../application/veil.service';
+import { Veil } from '../domain/veil.entity';
+
+@Controller('veils')
+export class VeilController {
+  constructor(private readonly veilService: VeilService) {}
+
+  @Get()
+  async findAll(): Promise<Veil[]> {
+    return this.veilService.findAll();
+  }
+
+  @Get('available')
+  async getAvailable(): Promise<Veil[]> {
+    return this.veilService.getAvailable();
+  }
+
+  @Post()
+  async create(@Body() veil: Omit<Veil, 'id' | 'createdAt'>): Promise<Veil> {
+    return this.veilService.create(veil);
+  }
+}