.env.example

@@ -1,14 +0,0 @@
-PORT=3333
-
-POSTGRES_HOST=127.0.0.1
-POSTGRES_PORT=5434
-POSTGRES_DATABASE=
-POSTGRES_USER=
-POSTGRES_PASSWORD=
-DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DATABASE}?schema=public&connection_limit=1
-
-SMTP_PASSWORD=""
-SMTP_EMAIL=""
-SMTP_HOST=""
-
-JWT_SECRET=

prisma/seed.ts

@@ -1,34 +0,0 @@
-import { PrismaClient } from '@prisma/client';
-
-const prisma = new PrismaClient();
-
-async function main() {
-  await prisma.role.create({
-    data: {
-      name: 'user',
-    },
-  });
-  await prisma.role.create({
-    data: {
-      name: 'admin',
-    },
-  });
-
-  await prisma.promoCode.create({
-    data: {
-      name: 'PROMO1000',
-      value: 1000,
-    },
-  });
-}
-
-main()
-  .then(async () => {
-    await prisma.$disconnect();
-  })
-  .catch(async (e) => {
-    console.error(e);
-    await prisma.$disconnect();
-    process.exit(1);
-  });
-

src/app.controller.spec.ts

@@ -1,22 +0,0 @@
-import { Test, TestingModule } from "@nestjs/testing";
-import { AppController } from "./app.controller";
-import { AppService } from "./app.service";
-
-describe("AppController", () => {
-	let appController: AppController;
-
-	beforeEach(async () => {
-		const app: TestingModule = await Test.createTestingModule({
-			controllers: [AppController],
-			providers: [AppService],
-		}).compile();
-
-		appController = app.get<AppController>(AppController);
-	});
-
-	describe("root", () => {
-		it('should return "Hello World!"', () => {
-			expect(appController.getHello()).toBe("Hello World!");
-		});
-	});
-});

src/app.controller.ts

@@ -1,12 +0,0 @@
-import { Controller, Get } from "@nestjs/common";
-import { AppService } from "./app.service";
-
-@Controller()
-export class AppController {
-	constructor(private readonly appService: AppService) {}
-
-	@Get()
-	getHello(): string {
-		return "Hello";
-	}
-}

src/app.module.ts

@@ -1,38 +0,0 @@
-import { AppController } from "@/app.controller";
-import { AppService } from "@/app.service";
-import { AuthModule } from "@/auth/auth.module";
-import { CryptoModule } from "@/crypto/crypto.module";
-import { OfferModule } from "@/offer/offer.module";
-import { PrismaModule } from "@/prisma/prisma.module";
-import { PromoCodeModule } from "@/promoCode/promoCode.module";
-import { RoleModule } from "@/role/role.module";
-import { TradeModule } from "@/trade/trade.module";
-import { UserModule } from "@/user/user.module";
-import { Module } from "@nestjs/common";
-import { ConfigModule } from "@nestjs/config";
-import { ThrottlerModule } from "@nestjs/throttler";
-
-@Module({
-	imports: [
-		ConfigModule.forRoot({
-			isGlobal: true,
-		}),
-		AuthModule,
-		PrismaModule,
-		RoleModule,
-		PromoCodeModule,
-		CryptoModule,
-		TradeModule,
-		OfferModule,
-		UserModule,
-		ThrottlerModule.forRoot([
-			{
-				ttl: 60000,
-				limit: 40,
-			},
-		]),
-	],
-	controllers: [AppController],
-	providers: [AppService],
-})
-export class AppModule {}

src/app.service.ts

@@ -1,8 +0,0 @@
-import { Injectable } from "@nestjs/common";
-
-@Injectable()
-export class AppService {
-	getHello(): string {
-		return "Hello World!";
-	}
-}

src/auth/auth.controller.ts

@@ -1,21 +0,0 @@
-import { Body, Controller, HttpCode, HttpStatus, Post } from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
-import { AuthService } from "./auth.service";
-import { AuthLoginDto, AuthRegisterDto } from "./dto";
-
-@ApiTags("auth")
-@Controller("auth")
-export class AuthController {
-	constructor(private authService: AuthService) {}
-
-	@Post("sign-up")
-	signUp(@Body() dto: AuthRegisterDto) {
-		return this.authService.signup(dto);
-	}
-
-	@HttpCode(HttpStatus.OK)
-	@Post("sign-in")
-	signIn(@Body() dto: AuthLoginDto) {
-		return this.authService.signin(dto);
-	}
-}

src/auth/auth.module.ts

@@ -1,12 +0,0 @@
-import { Module } from "@nestjs/common";
-import { JwtModule } from "@nestjs/jwt";
-import { AuthController } from "./auth.controller";
-import { AuthService } from "./auth.service";
-import { JwtStrategy } from "./strategy";
-
-@Module({
-	imports: [JwtModule.register({})],
-	controllers: [AuthController],
-	providers: [AuthService, JwtStrategy],
-})
-export class AuthModule {}

src/auth/auth.service.ts

@@ -1,113 +1,110 @@
-import { ForbiddenException, Injectable } from "@nestjs/common";
+import { ForbiddenException, Injectable } from '@nestjs/common';
-import { ConfigService } from "@nestjs/config";
+import { PrismaService } from '../prisma/prisma.service';
-import { JwtService } from "@nestjs/jwt";
+import { AuthLoginDto, AuthRegisterDto } from './dto';
-import { Prisma, User } from "@prisma/client";
+import * as argon from 'argon2';
-import * as argon from "argon2";
+import { Prisma, User } from '@prisma/client';
-import { PrismaService } from "../prisma/prisma.service";
+import { JwtService } from '@nestjs/jwt';
-import { AuthLoginDto, AuthRegisterDto } from "./dto";
+import { ConfigService } from '@nestjs/config';
 
 @Injectable()
 export class AuthService {
-	private readonly initialBalance = 1000;
+  private readonly initialBalance = 1000;
 
-	constructor(
+  constructor(
-		private prisma: PrismaService,
+    private prisma: PrismaService,
-		private jwt: JwtService,
+    private jwt: JwtService,
-		private config: ConfigService,
+    private config: ConfigService,
-	) {}
+  ) {}
 
-	async signup(dto: AuthRegisterDto) {
+  async signup(dto: AuthRegisterDto) {
-		const hash = await argon.hash(dto.password);
+    const hash = await argon.hash(dto.password);
-		const promoCode = await this.getPromoCode(dto.promoCode);
+    const promoCode = await this.getPromoCode(dto.promoCode);
-		const userRole = await this.getUserRole("user");
+    const userRole = await this.getUserRole('user');
-		const balance = this.calculateBalance(promoCode);
+    const balance = this.calculateBalance(promoCode);
 
-		try {
+    try {
-			const user = await this.createUser(dto, hash, userRole.id, balance);
+      const user = await this.createUser(dto, hash, userRole.id, balance);
-			return this.signToken(user);
+      return this.signToken(user);
-		} catch (error) {
+    } catch (error) {
-			this.handleSignupError(error);
+      this.handleSignupError(error);
-		}
+    }
-	}
+  }
 
-	private async getPromoCode(promoCode: string) {
+  private async getPromoCode(promoCode: string) {
-		return this.prisma.promoCode.findFirst({
+    return this.prisma.promoCode.findFirst({
-			where: { name: promoCode },
+      where: {name: promoCode},
-		});
+    });
-	}
+  }
 
-	private async getUserRole(roleName: string) {
+  private async getUserRole(roleName: string) {
-		return this.prisma.role.findFirst({
+    return this.prisma.role.findFirst({
-			where: { name: roleName },
+      where: {name: roleName},
-		});
+    });
-	}
+  }
 
-	private calculateBalance(promoCode: any) {
+  private calculateBalance(promoCode: any) {
-		let balance = this.initialBalance;
+    let balance = this.initialBalance;
-		if (promoCode && promoCode.value) {
+    if (promoCode && promoCode.value) {
-			balance += promoCode.value;
+      balance += promoCode.value;
-		}
+    }
-		return balance;
+    return balance;
-	}
+  }
 
-	private async createUser(
+  private async createUser(dto: AuthRegisterDto, hash: string, roleId: string, balance: number) {
-		dto: AuthRegisterDto,
+    return this.prisma.user.create({
-		hash: string,
+      data: {
-		roleId: string,
+        firstName: dto.firstName,
-		balance: number,
+        lastName: dto.lastName,
-	) {
+        pseudo: dto.pseudo,
-		return this.prisma.user.create({
+        city: dto.city,
-			data: {
+        email: dto.email,
-				firstName: dto.firstName,
+        hash,
-				lastName: dto.lastName,
+        age: dto.age,
-				pseudo: dto.pseudo,
+        roleId,
-				email: dto.email,
+        isActive: true,
-				hash,
+        dollarAvailables: balance,
-				roleId,
+      },
-				isActive: true,
+    });
-				dollarAvailables: balance,
+  }
-			},
-		});
-	}
 
-	private handleSignupError(error: any) {
+  private handleSignupError(error: any) {
-		if (error instanceof Prisma.PrismaClientKnownRequestError) {
+    if (error instanceof Prisma.PrismaClientKnownRequestError) {
-			if (error.code === "P2002") {
+      if (error.code === 'P2002') {
-				throw new ForbiddenException("Credentials taken");
+        throw new ForbiddenException('Credentials taken');
-			}
+      }
-		}
+    }
-		throw error;
+    throw error;
-	}
+  }
 
-	async signin(dto: AuthLoginDto) {
+  async signin(dto: AuthLoginDto) {
-		const userDatas = await this.prisma.user.findUnique({
+    const userDatas = await this.prisma.user.findUnique({
-			where: { email: dto.email },
+      where: { email: dto.email },
-			include: {
+      include: {
-				UserHasCrypto: { include: { Crypto: true } },
+        UserHasCrypto: { include: { Crypto: true } },
-				Role: true,
+        Role: true,
-			},
+      },
-		});
+    });
 
-		if (!userDatas) throw new ForbiddenException("Credentials incorrect");
+    if (!userDatas) throw new ForbiddenException('Credentials incorrect');
 
-		const pwMatches = await argon.verify(userDatas.hash, dto.password);
+    const pwMatches = await argon.verify(userDatas.hash, dto.password);
-		if (!pwMatches) throw new ForbiddenException("Credentials incorrect");
+    if (!pwMatches) throw new ForbiddenException('Credentials incorrect');
 
-		return this.signToken(userDatas);
+    return this.signToken(userDatas);
-	}
+  }
 
-	async signToken(user: any): Promise<{ access_token: string; user: User }> {
+  async signToken(user: any): Promise<{ access_token: string; user: User }> {
-		const payload = { sub: user.id, email: user.email };
+    const payload = { sub: user.id, email: user.email };
-		user.hash = null;
+    user.hash = null;
-		const secret = this.config.get("JWT_SECRET");
+    const secret = this.config.get('JWT_SECRET');
-		const token = await this.jwt.signAsync(payload, {
+    const token = await this.jwt.signAsync(payload, {
-			expiresIn: "30d",
+      expiresIn: '30d',
-			secret: secret,
+      secret: secret,
-		});
+    });
 
-		return {
+    return {
-			access_token: token,
+      access_token: token,
-			user,
+      user,
-		};
+    };
-	}
+  }
-}
+}

src/auth/decorator/get-user.decorator.ts

@@ -1,11 +0,0 @@
-import { ExecutionContext, createParamDecorator } from "@nestjs/common";
-
-export const GetUser = createParamDecorator(
-	(data: string | undefined, ctx: ExecutionContext) => {
-		const request: Express.Request = ctx.switchToHttp().getRequest();
-		if (data) {
-			return request.user[data];
-		}
-		return request.user;
-	},
-);

src/auth/decorator/index.ts

@@ -1 +0,0 @@
-export * from "./get-user.decorator";

src/auth/dto/auth.login.dto.ts

@@ -1,13 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import { IsEmail, IsNotEmpty, IsString } from "class-validator";
-export class AuthLoginDto {
-	@IsEmail()
-	@IsNotEmpty()
-	@ApiProperty({ type: String, description: "email" })
-	email: string;
-
-	@ApiProperty({ type: String, description: "password" })
-	@IsString()
-	@IsNotEmpty()
-	password: string;
-}

src/auth/dto/auth.register.dto.ts

@@ -1,73 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import {
-	IsEmail,
-	IsInt,
-	IsNotEmpty,
-	IsOptional,
-	IsString,
-	Max,
-	MaxLength,
-	Min,
-	MinLength,
-} from "class-validator";
-export class AuthRegisterDto {
-	@ApiProperty({
-		type: String,
-		description: "FirstName",
-		example: "Thomas",
-	})
-	@MinLength(1)
-	@MaxLength(50)
-	@IsNotEmpty()
-	@IsString()
-	firstName: string;
-
-	@ApiProperty({
-		type: String,
-		description: "Last Name",
-		example: "Anderson",
-	})
-	@MinLength(1)
-	@MaxLength(50)
-	@IsNotEmpty()
-	@IsString()
-	lastName: string;
-
-	@ApiProperty({
-		type: String,
-		description: "Pseudo",
-		example: "Néo",
-	})
-	@MinLength(1)
-	@MaxLength(50)
-	@IsNotEmpty()
-	@IsString()
-	pseudo: string;
-
-	@ApiProperty({
-		type: String,
-		description: "email",
-		example: "neo@matrix.fr",
-	})
-	@MaxLength(255)
-	@IsEmail()
-	@IsNotEmpty()
-	email: string;
-
-	@ApiProperty({
-		type: String,
-		description: "password",
-		example: "AAaa11&&&&",
-	})
-	@IsString()
-	@IsNotEmpty()
-	password: string;
-
-	@ApiProperty({
-		type: String,
-		description: "promoCode",
-		example: "FILOU20",
-	})
-	@IsOptional()
-	promoCode: string;
-}

src/auth/dto/index.ts

@@ -1,2 +0,0 @@
-export * from "./auth.register.dto";
-export * from "./auth.login.dto";

src/auth/guard/index.ts

@@ -1 +0,0 @@
-export * from "./jwt.guard";

src/auth/guard/jwt.guard.ts

@@ -1,7 +0,0 @@
-import { AuthGuard } from "@nestjs/passport";
-
-export class JwtGuard extends AuthGuard("jwt") {
-	constructor() {
-		super();
-	}
-}

src/auth/strategy/index.ts

@@ -1 +0,0 @@
-export * from "./jwt.strategy";

src/auth/strategy/jwt.strategy.ts

@@ -1,28 +0,0 @@
-import { PrismaService } from "@/prisma/prisma.service";
-import { Injectable } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-import { PassportStrategy } from "@nestjs/passport";
-import { ExtractJwt, Strategy } from "passport-jwt";
-
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy, "jwt") {
-	constructor(
-		config: ConfigService,
-		private prisma: PrismaService,
-	) {
-		super({
-			jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-			secretOrKey: config.get("JWT_SECRET"),
-		});
-	}
-
-	async validate(payload: { sub: string; email: string }) {
-		const user = await this.prisma.user.findUnique({
-			where: {
-				id: payload.sub,
-			},
-		});
-		delete user.hash;
-		return user;
-	}
-}

src/crypto/crypto.controller.ts

@@ -1,73 +0,0 @@
-import {
-	Body,
-	Controller,
-	Delete,
-	Get,
-	HttpCode,
-	HttpStatus,
-	Param,
-	Patch,
-	Post,
-	UseGuards,
-} from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
-import { JwtGuard } from "src/auth/guard";
-import { GetUser } from "../auth/decorator";
-import { CryptoService } from "./crypto.service";
-import { CryptoDto } from "./dto";
-import { BuyCryptoDto } from "./dto/buy.crypto.dto";
-
-@UseGuards(JwtGuard)
-@ApiTags("crypto")
-@Controller("crypto")
-export class CryptoController {
-	constructor(private cryptoService: CryptoService) {}
-
-	@Get("/all")
-	getAllPromoCodes(@GetUser() user: User) {
-		return this.cryptoService.getCryptos(user.id);
-	}
-	@Get("/search/:name")
-	searchCrypto(@GetUser() user: User, @Param("name") cryptoName: string) {
-		return this.cryptoService.searchCryptos(user.id, cryptoName);
-	}
-
-	@Get("/history/:id")
-	CryptoHistory(@GetUser() user: User, @Param("id") cryptoId: string) {
-		return this.cryptoService.getCryptoHistory(user.id, cryptoId);
-	}
-
-	@HttpCode(HttpStatus.CREATED)
-	@Post("/create")
-	createPromoCode(
-		@Body()
-		dto: CryptoDto,
-		@GetUser() user: User,
-	) {
-		return this.cryptoService.createCrypto(user.id, dto);
-	}
-	@Post("/buy")
-	buyCrypto(
-		@Body()
-		dto: BuyCryptoDto,
-		@GetUser() user: User,
-	) {
-		return this.cryptoService.buyCrypto(user.id, dto);
-	}
-	@HttpCode(HttpStatus.OK)
-	@Patch("/update/:id")
-	editCryptoById(
-		@Param("id") cryptoId: string,
-		@Body() dto: CryptoDto,
-		@GetUser() user: User,
-	) {
-		return this.cryptoService.editCryptoById(user.id, cryptoId, dto);
-	}
-
-	@HttpCode(HttpStatus.NO_CONTENT)
-	@Delete("/delete/:id")
-	deleteOfferById(@Param("id") roleId: string, @GetUser() user: User) {
-		return this.cryptoService.deleteCryptoById(user.id, roleId);
-	}
-}

src/crypto/crypto.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-import { CryptoController } from "./crypto.controller";
-import { CryptoService } from "./crypto.service";
-
-@Module({
-	providers: [CryptoService],
-	controllers: [CryptoController],
-})
-export class CryptoModule {}

src/crypto/crypto.service.ts

@@ -1,192 +0,0 @@
-import { ForbiddenException, Injectable } from "@nestjs/common";
-import { checkUserHasAccount, checkUserIsAdmin } from "src/utils/checkUser";
-import { PrismaService } from "../prisma/prisma.service";
-import { CryptoDto } from "./dto";
-import { BuyCryptoDto } from "./dto/buy.crypto.dto";
-@Injectable()
-export class CryptoService {
-	constructor(private prisma: PrismaService) {}
-
-	async getCryptos(userId: string) {
-		await checkUserHasAccount(userId);
-
-		return this.prisma.crypto.findMany({
-			orderBy: {
-				name: "asc",
-			},
-		});
-	}
-	async searchCryptos(userId: string, cryptoName: string) {
-		await checkUserHasAccount(userId);
-
-		return this.prisma.crypto.findMany({
-			where: {
-				name: {
-					contains: cryptoName,
-					mode: "insensitive",
-				},
-			},
-			orderBy: {
-				name: "asc",
-			},
-		});
-	}
-
-	async getCryptoHistory(userId: string, cryptoId: string) {
-		await checkUserHasAccount(userId);
-
-		if (cryptoId) {
-			return this.prisma.crypto.findMany({
-				where: {
-					id: cryptoId,
-				},
-
-				orderBy: {
-					created_at: "desc",
-				},
-				take: 50,
-			});
-		}
-		throw new ForbiddenException("Crypto UUID required");
-	}
-
-	async createCrypto(userId: string, dto: CryptoDto) {
-		await checkUserIsAdmin(userId);
-
-		const existingCryptosWithSameName = await this.prisma.crypto.findMany({
-			where: {
-				name: dto.name,
-			},
-		});
-		if (existingCryptosWithSameName.length > 0) {
-			throw new ForbiddenException("Name already taken");
-		}
-		const crypto = await this.prisma.crypto.create({
-			data: {
-				name: dto.name,
-				image: dto.image,
-				value: dto.value,
-				quantity: dto.quantity,
-			},
-		});
-
-		return crypto;
-	}
-
-	async buyCrypto(userId: string, dto: BuyCryptoDto) {
-		const crypto = await this.prisma.crypto.findFirst({
-			where: {
-				id: dto.id_crypto,
-			},
-		});
-
-		const user = await this.prisma.user.findFirst({
-			where: {
-				id: userId,
-			},
-		});
-		if (crypto.quantity < dto.amount) {
-			throw new ForbiddenException("No more tokens available");
-		}
-		const necessaryAmount = crypto.value * dto.amount;
-		console.log(necessaryAmount, user.dollarAvailables);
-
-		if (necessaryAmount > user.dollarAvailables) {
-			throw new ForbiddenException("Make money first :) ");
-		}
-		const userAsset = await this.prisma.userHasCrypto.findFirst({
-			where: {
-				id_crypto: dto.id_crypto,
-				id_user: userId,
-			},
-		});
-		const newBalance = user.dollarAvailables - necessaryAmount;
-		console.log(newBalance);
-
-		await this.prisma.user.update({
-			where: {
-				id: user.id,
-			},
-			data: {
-				dollarAvailables: newBalance,
-			},
-		});
-		if (userAsset) {
-			const newBalance = userAsset.amount + dto.amount;
-			await this.prisma.userHasCrypto.update({
-				where: {
-					id: userAsset.id,
-				},
-				data: {
-					amount: newBalance,
-				},
-			});
-		} else {
-			await this.prisma.userHasCrypto.create({
-				data: {
-					id_crypto: dto.id_crypto,
-					id_user: userId,
-					amount: dto.amount,
-				},
-			});
-		}
-		const newCryptoValue = crypto.value * 1.1;
-
-		await this.prisma.cryptoHistory.create({
-			data: {
-				id_crypto: crypto.id,
-				value: newCryptoValue,
-			},
-		});
-		const newQuantity = (crypto.quantity -= dto.amount);
-		return this.prisma.crypto.update({
-			where: {
-				id: dto.id_crypto,
-			},
-			data: {
-				value: newCryptoValue,
-				quantity: newQuantity,
-			},
-		});
-	}
-	async editCryptoById(userId: string, cryptoId: string, dto: CryptoDto) {
-		await checkUserIsAdmin(userId);
-
-		const crypto = await this.prisma.crypto.findUnique({
-			where: {
-				id: cryptoId,
-			},
-		});
-
-		if (!crypto || crypto.id !== cryptoId)
-			throw new ForbiddenException("Access to resources denied");
-
-		return this.prisma.crypto.update({
-			where: {
-				id: crypto.id,
-			},
-			data: {
-				...dto,
-			},
-		});
-	}
-
-	async deleteCryptoById(userId: string, id: string) {
-		await checkUserIsAdmin(userId);
-
-		const crypto = await this.prisma.crypto.findUnique({
-			where: {
-				id: id,
-			},
-		});
-
-		if (!crypto || crypto.id !== id)
-			throw new ForbiddenException("Access to resources denied");
-
-		await this.prisma.crypto.delete({
-			where: {
-				id: crypto.id,
-			},
-		});
-	}
-}

src/crypto/dto/buy.crypto.dto.ts

@@ -1,32 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import {
-	IsNumber,
-	IsString,
-	IsUUID,
-	Max,
-	MaxLength,
-	Min,
-	MinLength,
-} from "class-validator";
-export class BuyCryptoDto {
-	@ApiProperty({
-		type: String,
-		description: "Cryptocurrency UUID",
-		example: "12121-DSZD-E221212-2121221",
-	})
-	@MinLength(1)
-	@MaxLength(50)
-	@IsString()
-	@IsUUID()
-	id_crypto: string;
-
-	@ApiProperty({
-		type: Number,
-		description: "Amount of token traded",
-		example: 2,
-	})
-	@Min(1)
-	@Max(1000)
-	@IsNumber()
-	amount: number;
-}

src/crypto/dto/crypto.dto.ts

@@ -1,54 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import {
-	IsNumber,
-	IsPositive,
-	IsString,
-	IsUrl,
-	Max,
-	MaxLength,
-	Min,
-	MinLength,
-} from "class-validator";
-export class CryptoDto {
-	@ApiProperty({
-		type: String,
-		description: "Cryptocurrency name",
-		example: "BTC",
-	})
-	@MaxLength(50)
-	@MinLength(1)
-	@IsString()
-	name: string;
-
-	@ApiProperty({
-		type: Number,
-		description: "Value for the cryptocurrency in $",
-		example: 1,
-	})
-	@Min(1)
-	@Max(10000)
-	@IsPositive()
-	@IsNumber()
-	value: number;
-
-	@ApiProperty({
-		type: Number,
-		description: "Quantity of tokens available on the platform",
-		example: 100,
-	})
-	@Min(1)
-	@Max(10000)
-	@IsPositive()
-	@IsNumber()
-	quantity: number;
-
-	@ApiProperty({
-		type: String,
-		description: "Image for the cryptocurrency in ",
-		example: "https://myImage/com",
-	})
-	@MaxLength(255)
-	@IsUrl()
-	@IsString()
-	image: string;
-}

src/crypto/dto/index.ts

@@ -1 +0,0 @@
-export * from "./crypto.dto";

src/main.ts

@@ -1,26 +1,26 @@
-import { ValidationPipe } from "@nestjs/common";
+import { NestFactory } from '@nestjs/core';
-import { NestFactory } from "@nestjs/core";
+import { AppModule } from './app.module';
-import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import { ValidationPipe } from '@nestjs/common';
-import { AppModule } from "./app.module";
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 
 async function bootstrap() {
-	const app = await NestFactory.create(AppModule);
+  const app = await NestFactory.create(AppModule);
-	app.enableCors();
+  app.enableCors();
 
-	const config = new DocumentBuilder()
+  const config = new DocumentBuilder()
-		.setTitle("Neptune API")
+    .setTitle('Neptune API')
-		.setDescription("A fictive app")
+    .setDescription('A fictive app')
-		.setVersion("1.0")
+    .setVersion('1.0')
-		.build();
+    .build();
-	const document = SwaggerModule.createDocument(app, config);
+  const document = SwaggerModule.createDocument(app, config);
-	SwaggerModule.setup("api", app, document);
+  SwaggerModule.setup('api', app, document);
 
-	app.useGlobalPipes(
+  app.useGlobalPipes(
-		new ValidationPipe({
+    new ValidationPipe({
-			whitelist: true,
+      whitelist: true,
-		}),
+    }),
-	);
+  );
 
-	await app.listen(process.env.PORT || 3000);
+  await app.listen(process.env.PORT || 3000);
 }
 bootstrap();

src/offer/dto/index.ts

@@ -1 +0,0 @@
-export * from "./offer.dto";

src/offer/dto/offer.dto.ts

@@ -1,32 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import {
-	IsNumber,
-	IsPositive,
-	IsString,
-	IsUUID,
-	Max,
-	MaxLength,
-	Min,
-} from "class-validator";
-export class OfferDto {
-	@ApiProperty({
-		type: String,
-		description: "Cryptocurrency UUID",
-		example: "12121-DSZD-E221212-6227933",
-	})
-	@IsString()
-	@IsUUID()
-	id_crypto: string;
-
-	@ApiProperty({
-		type: "number",
-
-		description: "Amount traded ",
-		example: 21,
-	})
-	@Min(1)
-	@Max(1000)
-	@IsNumber()
-	@IsPositive()
-	amount: number;
-}

src/offer/offer.controller.ts

@@ -1,58 +0,0 @@
-import {
-	Body,
-	Controller,
-	Delete,
-	Get,
-	HttpCode,
-	HttpStatus,
-	Param,
-	Patch,
-	Post,
-	UseGuards,
-	//   UseGuards,
-} from "@nestjs/common";
-// import { JwtGuard } from '../auth/guard';
-import { ApiTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
-import { JwtGuard } from "src/auth/guard";
-import { GetUser } from "../auth/decorator";
-import { OfferDto } from "./dto";
-import { OfferService } from "./offer.service";
-
-@UseGuards(JwtGuard)
-@ApiTags("offer")
-@Controller("offer")
-export class OfferController {
-	constructor(private offerService: OfferService) {}
-
-	@Get("/all")
-	getAllRoles(@GetUser() user: User) {
-		return this.offerService.getOffers(user.id);
-	}
-
-	@HttpCode(HttpStatus.CREATED)
-	@Post("/create")
-	createRole(
-		@Body()
-		dto: OfferDto,
-		@GetUser() user: User,
-	) {
-		return this.offerService.createOffer(user.id, dto);
-	}
-
-	@HttpCode(HttpStatus.OK)
-	@Patch("/update/:id")
-	editOfferById(
-		@Param("id") offerId: string,
-		@Body() dto: OfferDto,
-		@GetUser() user: User,
-	) {
-		return this.offerService.editOfferById(user.id, offerId, dto);
-	}
-
-	@HttpCode(HttpStatus.NO_CONTENT)
-	@Delete("/delete/:id")
-	deleteOfferById(@Param("id") roleId: string, @GetUser() user: User) {
-		return this.offerService.deleteOfferById(user.id, roleId);
-	}
-}

src/offer/offer.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-import { OfferController } from "./offer.controller";
-import { OfferService } from "./offer.service";
-
-@Module({
-	providers: [OfferService],
-	controllers: [OfferController],
-})
-export class OfferModule {}

src/offer/offer.service.sql

@@ -1,35 +0,0 @@
-SELECT
-    o.amount,
-    o.created_at,
-    o.id_user,
-    c.id AS crypto_id,
-    c.name AS crypto_name,
-    c.value AS crypto_value,
-    c.image AS crypto_image,
-    c.quantity AS crypto_quantity
-FROM
-    "Offer" o
-        JOIN
-    "Crypto" c ON o.id_crypto = c.id
-ORDER BY
-    o.created_at DESC;
-
-INSERT INTO "Offer" (id, id_crypto, id_user, amount, created_at, updated_at)
-VALUES (gen_random_uuid(), 'dto.id_crypto', 'userId', 'dto.amount', NOW(), NOW());
-
-SELECT * FROM "Offer" WHERE id = 'offerId';
-
-SELECT * FROM "Crypto" WHERE id = 'dto.id_crypto';
-
-UPDATE "Offer"
-SET
-    id_crypto = 'dto.id_crypto',
-    amount = 'dto.amount',
-    updated_at = NOW()
-WHERE
-    id = 'offerId';
-
-SELECT * FROM "Offer" WHERE id = 'id';
-
-DELETE FROM "Offer" WHERE id = 'id';
-

src/offer/offer.service.ts

@@ -1,84 +0,0 @@
-import { PrismaService } from "@/prisma/prisma.service";
-import { ForbiddenException, Injectable } from "@nestjs/common";
-import { checkUserHasAccount, checkUserIsAdmin } from "src/utils/checkUser";
-import { OfferDto } from "./dto";
-
-@Injectable()
-export class OfferService {
-	constructor(private prisma: PrismaService) {}
-
-	async getOffers(userId: string) {
-		await checkUserHasAccount(userId);
-		return this.prisma.offer.findMany({
-			orderBy: {
-				created_at: "desc",
-			},
-			select: {
-				amount: true,
-				created_at: true,
-				id_user: true,
-				Crypto: true,
-			},
-		});
-	}
-
-	async createOffer(userId: string, dto: OfferDto) {
-		await checkUserHasAccount(userId);
-		return this.prisma.offer.create({
-			data: {
-				id_crypto: dto.id_crypto,
-				id_user: userId,
-				amount: dto.amount,
-			},
-		});
-	}
-
-	async editOfferById(userId: string, offerId: string, dto: OfferDto) {
-		await checkUserHasAccount(userId);
-
-		const offer = await this.prisma.offer.findUnique({
-			where: {
-				id: offerId,
-			},
-		});
-
-		const crypto = await this.prisma.crypto.findUnique({
-			where: {
-				id: dto.id_crypto,
-			},
-		});
-		if (!crypto || !crypto.id) {
-			throw new ForbiddenException("Crypto doesnt exist");
-		}
-
-		if (!offer || offer.id !== offerId)
-			throw new ForbiddenException("Offer id mandatory");
-
-		return this.prisma.offer.update({
-			where: {
-				id: offerId,
-			},
-			data: {
-				...dto,
-			},
-		});
-	}
-	async deleteOfferById(userId: string, id: string) {
-		await checkUserIsAdmin(userId);
-
-		const offer = await this.prisma.offer.findUnique({
-			where: {
-				id: id,
-			},
-		});
-
-		if (!offer || offer.id !== id)
-			throw new ForbiddenException("Access to resources denied");
-
-		await this.prisma.offer.delete({
-			where: {
-				id: id,
-			},
-		});
-	}
-}

src/prisma/prisma.module.ts

@@ -1,9 +0,0 @@
-import { Global, Module } from "@nestjs/common";
-import { PrismaService } from "./prisma.service";
-
-@Global()
-@Module({
-	providers: [PrismaService],
-	exports: [PrismaService],
-})
-export class PrismaModule {}

src/prisma/prisma.service.ts

@@ -1,17 +0,0 @@
-import { Injectable } from "@nestjs/common";
-// biome-ignore lint/style/useImportType:
-import { ConfigService } from "@nestjs/config";
-import { PrismaClient } from "@prisma/client";
-
-@Injectable()
-export class PrismaService extends PrismaClient {
-	constructor(config: ConfigService) {
-		super({
-			datasources: {
-				db: {
-					url: config.get("DATABASE_URL"),
-				},
-			},
-		});
-	}
-}

src/promoCode/dto/index.ts

@@ -1 +0,0 @@
-export * from "./promoCode.dto";

src/promoCode/dto/promoCode.dto.ts

@@ -1,32 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import {
-	IsNumber,
-	IsPositive,
-	IsString,
-	Max,
-	MaxLength,
-	Min,
-	MinLength,
-} from "class-validator";
-export class PromoCodeDto {
-	@ApiProperty({
-		type: String,
-		description: "Name of the PromoCOde",
-		example: "FILOU10",
-	})
-	@MinLength(1)
-	@MaxLength(50)
-	@IsString()
-	name: string;
-
-	@ApiProperty({
-		type: Number,
-		description: "Dollars given for account creation when promoCode applied",
-		example: 100,
-	})
-	@IsPositive()
-	@Min(1)
-	@Max(3000)
-	@IsNumber()
-	value: number;
-}

src/promoCode/promoCode.controller.ts

@@ -1,57 +0,0 @@
-import {
-	Body,
-	Controller,
-	Delete,
-	Get,
-	HttpCode,
-	HttpStatus,
-	Param,
-	Patch,
-	Post,
-	UseGuards,
-} from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
-import { JwtGuard } from "src/auth/guard";
-import { GetUser } from "../auth/decorator";
-import { PromoCodeDto } from "./dto";
-import { PromoCodeService } from "./promoCode.service";
-
-@UseGuards(JwtGuard)
-@ApiTags("promoCode")
-@Controller("promoCode")
-export class PromoCodeController {
-	constructor(private promoService: PromoCodeService) {}
-
-	@Get("/all")
-	getAllPromoCodes(@GetUser() user: User) {
-		return this.promoService.getPromoCodes(user.id);
-	}
-
-	@HttpCode(HttpStatus.CREATED)
-	@Post("/create")
-	createPromoCode(
-		// @GetUser() user: User,
-		@Body()
-		dto: PromoCodeDto,
-		@GetUser() user: User,
-	) {
-		return this.promoService.createPromoCode(user.id, dto);
-	}
-
-	@HttpCode(HttpStatus.OK)
-	@Patch("/update/:id")
-	editPromoCodeById(
-		@Param("id") promoCodeId: string,
-		@Body() dto: PromoCodeDto,
-		@GetUser() user: User,
-	) {
-		return this.promoService.editPromoCodeById(user.id, promoCodeId, dto);
-	}
-
-	@HttpCode(HttpStatus.NO_CONTENT)
-	@Delete("/delete/:id")
-	deletePromoCodeById(@Param("id") promoCodeId: string, @GetUser() user: User) {
-		return this.promoService.deletePromoCodeById(user.id, promoCodeId);
-	}
-}

src/promoCode/promoCode.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-import { PromoCodeController } from "./promoCode.controller";
-import { PromoCodeService } from "./promoCode.service";
-
-@Module({
-	providers: [PromoCodeService],
-	controllers: [PromoCodeController],
-})
-export class PromoCodeModule {}

src/promoCode/promoCode.service.spec.ts

@@ -1,70 +0,0 @@
-import { PrismaService } from "@/prisma/prisma.service";
-import { checkUserIsAdmin } from "@/utils/checkUser";
-import { ForbiddenException } from "@nestjs/common";
-// biome-ignore lint/style/useImportType:
-import { Test, TestingModule } from "@nestjs/testing";
-import { PromoCodeService } from "./promoCode.service";
-
-jest.mock("../utils/checkUser");
-
-describe("PromoCodeService", () => {
-	let service: PromoCodeService;
-	let prisma: PrismaService;
-
-	const mockPrismaService = {
-		promoCode: {
-			findMany: jest.fn(),
-			create: jest.fn(),
-			findUnique: jest.fn(),
-			update: jest.fn(),
-			delete: jest.fn(),
-		},
-	};
-
-	beforeEach(async () => {
-		const module: TestingModule = await Test.createTestingModule({
-			providers: [
-				PromoCodeService,
-				{ provide: PrismaService, useValue: mockPrismaService },
-			],
-		}).compile();
-
-		service = module.get<PromoCodeService>(PromoCodeService);
-		prisma = module.get<PrismaService>(PrismaService);
-	});
-
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	describe("getPromoCodes", () => {
-		it("should get promo codes if user is admin", async () => {
-			(checkUserIsAdmin as jest.Mock).mockResolvedValue(true);
-			const mockPromoCodes = [
-				{ id: "1", name: "PROMO10", value: 10 },
-				{ id: "2", name: "PROMO20", value: 20 },
-			];
-			mockPrismaService.promoCode.findMany.mockResolvedValue(mockPromoCodes);
-
-			const result = await service.getPromoCodes("user-id");
-
-			expect(checkUserIsAdmin).toHaveBeenCalledWith("user-id");
-			expect(prisma.promoCode.findMany).toHaveBeenCalledWith({
-				orderBy: { name: "asc" },
-				select: { id: true, name: true, value: true },
-			});
-			expect(result).toEqual(mockPromoCodes);
-		});
-
-		it("should throw ForbiddenException if user is not admin", async () => {
-			(checkUserIsAdmin as jest.Mock).mockRejectedValue(
-				new ForbiddenException("Not an admin"),
-			);
-
-			await expect(service.getPromoCodes("user-id")).rejects.toThrow(ForbiddenException);
-
-			expect(checkUserIsAdmin).toHaveBeenCalledWith("user-id");
-			expect(prisma.promoCode.findMany).not.toHaveBeenCalled();
-		});
-	});
-});

src/promoCode/promoCode.service.ts

@@ -1,75 +0,0 @@
-import { ForbiddenException, Injectable } from "@nestjs/common";
-import { PrismaService } from "../prisma/prisma.service";
-import { checkUserIsAdmin } from "../utils/checkUser";
-import { PromoCodeDto } from "./dto";
-@Injectable()
-export class PromoCodeService {
-	constructor(private prisma: PrismaService) {}
-
-	async getPromoCodes(userId: string) {
-		await checkUserIsAdmin(userId);
-
-		return this.prisma.promoCode.findMany({
-			orderBy: {
-				name: "asc",
-			},
-			select: {
-				id: true,
-				name: true,
-				value: true,
-			},
-		});
-	}
-
-	async createPromoCode(userId: string, dto: PromoCodeDto) {
-		await checkUserIsAdmin(userId);
-
-		const promoCode = await this.prisma.promoCode.create({
-			data: {
-				name: dto.name,
-				value: dto.value,
-			},
-		});
-
-		return promoCode;
-	}
-	async editPromoCodeById(userId: string, promoCodeId: string, dto: PromoCodeDto) {
-		await checkUserIsAdmin(userId);
-
-		const promoCode = await this.prisma.promoCode.findUnique({
-			where: {
-				id: promoCodeId,
-			},
-		});
-
-		if (!promoCode || promoCode.id !== promoCodeId)
-			throw new ForbiddenException("Access to resources denied");
-
-		return this.prisma.promoCode.update({
-			where: {
-				id: promoCode.id,
-			},
-			data: {
-				...dto,
-			},
-		});
-	}
-	async deletePromoCodeById(userId: string, id: string) {
-		await checkUserIsAdmin(userId);
-
-		const promoCode = await this.prisma.promoCode.findUnique({
-			where: {
-				id: id,
-			},
-		});
-
-		if (!promoCode || promoCode.id !== id)
-			throw new ForbiddenException("Access to resources denied");
-
-		await this.prisma.promoCode.delete({
-			where: {
-				id: promoCode.id,
-			},
-		});
-	}
-}

src/role/dto/index.ts

@@ -1 +0,0 @@
-export * from "./role.dto";

src/role/dto/role.dto.ts

@@ -1,13 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import { IsString, MaxLength, MinLength } from "class-validator";
-export class RoleDto {
-	@ApiProperty({
-		type: String,
-		description: "Role Name",
-		example: "user",
-	})
-	@MinLength(1)
-	@MaxLength(50)
-	@IsString()
-	name: string;
-}

src/role/role.controller.ts

@@ -1,59 +0,0 @@
-import {
-	Body,
-	Controller,
-	Delete,
-	Get,
-	HttpCode,
-	HttpStatus,
-	Param,
-	Patch,
-	Post,
-	UseGuards,
-	//   UseGuards,
-} from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
-import { JwtGuard } from "src/auth/guard";
-import { GetUser } from "../auth/decorator";
-// import { JwtGuard } from '../auth/guard';
-import { RoleDto } from "./dto";
-import { RoleService } from "./role.service";
-
-@UseGuards(JwtGuard)
-@ApiTags("role")
-@Controller("role")
-export class RoleController {
-	constructor(private roleService: RoleService) {}
-
-	@Get("/all")
-	getAllRoles(@GetUser() user: User) {
-		return this.roleService.getRolesAdmin(user.id);
-	}
-	// @Get('/cm/all')
-	// getRolesCm(@GetUser() user: User) {
-	//     return this.roleService.getRolesCm(user)
-	// }
-
-	@HttpCode(HttpStatus.CREATED)
-	@Post("/create")
-	createRole(
-		// @GetUser() user: User,
-		@Body()
-		dto: RoleDto,
-		@GetUser() user: User,
-	) {
-		return this.roleService.createRole(user.id, dto);
-	}
-
-	@HttpCode(HttpStatus.OK)
-	@Patch("/update/:id")
-	editRoleById(@Param("id") roleId: string, @Body() dto: RoleDto, @GetUser() user: User) {
-		return this.roleService.editRoleById(user.id, roleId, dto);
-	}
-
-	@HttpCode(HttpStatus.NO_CONTENT)
-	@Delete("/delete/:id")
-	deleteRoleById(@Param("id") roleId: string, @GetUser() user: User) {
-		return this.roleService.deleteRoleById(user.id, roleId);
-	}
-}

src/role/role.module.ts

@@ -1,8 +0,0 @@
-import { Module } from "@nestjs/common";
-import { RoleController } from "./role.controller";
-import { RoleService } from "./role.service";
-@Module({
-	providers: [RoleService],
-	controllers: [RoleController],
-})
-export class RoleModule {}

src/role/role.service.ts

@@ -1,72 +0,0 @@
-import { ForbiddenException, Injectable } from "@nestjs/common";
-import { checkUserIsAdmin } from "src/utils/checkUser";
-import { PrismaService } from "../prisma/prisma.service";
-import { RoleDto } from "./dto";
-// import { checkRoleLevel, checkUserIsStaff } from 'src/utils/checkUser';
-@Injectable()
-export class RoleService {
-	constructor(private prisma: PrismaService) {}
-
-	async getRolesAdmin(userId: string) {
-		await checkUserIsAdmin(userId);
-		return this.prisma.role.findMany({
-			orderBy: {
-				name: "asc",
-			},
-			select: {
-				id: true,
-				name: true,
-			},
-		});
-	}
-
-	async createRole(userId: string, dto: RoleDto) {
-		await checkUserIsAdmin(userId);
-		const role = await this.prisma.role.create({
-			data: {
-				name: dto.name,
-			},
-		});
-
-		return role;
-	}
-	async editRoleById(userId: string, roleId: string, dto: RoleDto) {
-		await checkUserIsAdmin(userId);
-
-		const role = await this.prisma.role.findUnique({
-			where: {
-				id: roleId,
-			},
-		});
-
-		if (!role || role.id !== roleId)
-			throw new ForbiddenException("Access to resources denied");
-
-		return this.prisma.role.update({
-			where: {
-				id: roleId,
-			},
-			data: {
-				...dto,
-			},
-		});
-	}
-	async deleteRoleById(userId: string, id: string) {
-		await checkUserIsAdmin(userId);
-
-		const role = await this.prisma.role.findUnique({
-			where: {
-				id: id,
-			},
-		});
-
-		if (!role || role.id !== id)
-			throw new ForbiddenException("Access to resources denied");
-
-		await this.prisma.role.delete({
-			where: {
-				id: id,
-			},
-		});
-	}
-}

src/trade/dto/index.ts

@@ -1 +0,0 @@
-export * from "./trade.dto";

src/trade/dto/trade.dto.ts

@@ -1,13 +0,0 @@
-import { ApiProperty } from "@nestjs/swagger";
-import { IsNotEmpty, IsString, IsUUID } from "class-validator";
-export class TradeDto {
-	@ApiProperty({
-		type: String,
-		description: "Offer UUID ",
-		example: "121212-DSDZ1-21212DJDZ-31313",
-	})
-	@IsUUID()
-	@IsNotEmpty()
-	@IsString()
-	id_offer: string;
-}

src/trade/trade.controller.ts

@@ -1,38 +0,0 @@
-import {
-	Body,
-	Controller,
-	Get,
-	HttpCode,
-	HttpStatus,
-	Post,
-	UseGuards,
-} from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
-import { JwtGuard } from "src/auth/guard";
-import { GetUser } from "../auth/decorator";
-import { TradeDto } from "./dto";
-import { TradeService } from "./trade.service";
-
-@UseGuards(JwtGuard)
-@ApiTags("trade")
-@Controller("trade")
-export class TradeController {
-	constructor(private tradeService: TradeService) {}
-
-	@Get("/all")
-	getAllPromoCodes(@GetUser() user: User) {
-		return this.tradeService.getTrades(user.id);
-	}
-
-	@HttpCode(HttpStatus.CREATED)
-	@Post("/create")
-	createPromoCode(
-		// @GetUser() user: User,
-		@Body()
-		dto: TradeDto,
-		@GetUser() user: User,
-	) {
-		return this.tradeService.createTrade(user.id, dto);
-	}
-}

src/trade/trade.module.ts

@@ -1,9 +0,0 @@
-import { Module } from "@nestjs/common";
-import { TradeController } from "./trade.controller";
-import { TradeService } from "./trade.service";
-
-@Module({
-	providers: [TradeService],
-	controllers: [TradeController],
-})
-export class TradeModule {}

src/trade/trade.service.ts

@@ -1,173 +0,0 @@
-import { ForbiddenException, Injectable } from "@nestjs/common";
-import { checkUserHasAccount, checkUserIsAdmin } from "src/utils/checkUser";
-import { PrismaService } from "../prisma/prisma.service";
-import { TradeDto } from "./dto";
-@Injectable()
-export class TradeService {
-	constructor(private prisma: PrismaService) {}
-
-	async getTrades(userId: string) {
-		await checkUserIsAdmin(userId);
-
-		return this.prisma.trade.findMany({
-			orderBy: {
-				created_at: "desc",
-			},
-			// include: {
-			//   Giver: true,
-			//   Receiver: true,
-			//   Crypto: true,
-			// },
-
-			select: {
-				Giver: {
-					select: {
-						firstName: true,
-						lastName: true,
-						pseudo: true,
-						dollarAvailables: true,
-					},
-				},
-				Receiver: {
-					select: {
-						firstName: true,
-						lastName: true,
-						pseudo: true,
-						dollarAvailables: true,
-					},
-				},
-				Crypto: true,
-			},
-		});
-	}
-	async getLastTrades() {
-		return this.prisma.trade.findMany({
-			orderBy: {
-				created_at: "desc",
-			},
-			select: {
-				amount_traded: true,
-				Crypto: true,
-			},
-		});
-	}
-
-	async createTrade(userId: string, dto: TradeDto) {
-		await checkUserHasAccount(userId);
-
-		const offer = await this.prisma.offer.findUnique({
-			where: {
-				id: dto.id_offer,
-			},
-		});
-		const crypto = await this.prisma.crypto.findFirst({
-			where: {
-				id: offer.id_crypto,
-			},
-		});
-
-		const buyer = await this.prisma.user.findFirst({
-			where: {
-				id: offer.id_user,
-			},
-		});
-
-		const price = crypto.value * offer.amount;
-		if (buyer.dollarAvailables < price) {
-			throw new ForbiddenException(
-				`Acqueror ${buyer.pseudo} doesnt have enough money to make this trade`,
-			);
-		}
-
-		const asset = await this.prisma.userHasCrypto.findFirst({
-			where: {
-				id_crypto: offer.id_crypto,
-				id_user: offer.id_user,
-			},
-		});
-
-		if (!asset || asset.amount < offer.amount) {
-			throw new ForbiddenException(`Seller doesnt have enough ${crypto.name} `);
-		}
-
-		const trade = await this.prisma.trade.create({
-			data: {
-				id_giver: offer.id_user,
-				id_receiver: userId,
-				id_crypto: offer.id_crypto,
-				amount_traded: offer.amount,
-			},
-		});
-
-		const newBalanceGiver = (asset.amount -= offer.amount);
-		await this.prisma.userHasCrypto.update({
-			where: {
-				id: asset.id,
-			},
-			data: {
-				amount: newBalanceGiver,
-			},
-		});
-
-		const receiverAssets = await this.prisma.userHasCrypto.findFirst({
-			where: {
-				id_user: userId,
-				id_crypto: offer.id_crypto,
-			},
-		});
-		if (!receiverAssets) {
-			await this.prisma.userHasCrypto.create({
-				data: {
-					id_user: userId,
-					id_crypto: offer.id_crypto,
-					amount: offer.amount,
-					createdAt: new Date(),
-				},
-			});
-		} else {
-			const newBalanceReceiver = receiverAssets.amount + offer.amount;
-			await this.prisma.userHasCrypto.update({
-				where: {
-					id: receiverAssets.id,
-				},
-				data: {
-					amount: newBalanceReceiver,
-				},
-			});
-		}
-
-		const newValue = crypto.value * 1.1;
-		await this.prisma.cryptoHistory.create({
-			data: {
-				id_crypto: crypto.id,
-				value: newValue,
-			},
-		});
-
-		await this.prisma.crypto.update({
-			where: {
-				id: crypto.id,
-			},
-			data: {
-				value: newValue,
-			},
-		});
-
-		const prevAmount = buyer.dollarAvailables;
-
-		await this.prisma.user.update({
-			where: {
-				id: userId,
-			},
-			data: {
-				dollarAvailables: prevAmount - price,
-			},
-		});
-		await this.prisma.offer.delete({
-			where: {
-				id: offer.id,
-			},
-		});
-		return trade;
-	}
-}

src/user/user.controller.ts

@@ -1,36 +0,0 @@
-import { Controller, Get, UseGuards } from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
-import { User } from "@prisma/client";
-import { GetUser } from "../auth/decorator";
-import { JwtGuard } from "../auth/guard";
-import { UserService } from "./user.service";
-
-@ApiTags("user")
-@UseGuards(JwtGuard)
-@Controller("user")
-export class UserController {
-	constructor(private userService: UserService) {}
-
-	@Get("/my-assets")
-	GetMyAssets(
-		@GetUser()
-		user: User,
-	) {
-		return this.userService.getMyAssets(user.id);
-	}
-
-	@Get("/users-assets")
-	GetAlLAssets(
-		@GetUser()
-		user: User,
-	) {
-		return this.userService.getUsersAssets(user.id);
-	}
-	@Get("/my-trades")
-	GetMyTrades(
-		@GetUser()
-		user: User,
-	) {
-		return this.userService.getMyTrades(user.id);
-	}
-}

src/user/user.module.ts

@@ -1,8 +0,0 @@
-import { Module } from "@nestjs/common";
-import { UserController } from "./user.controller";
-import { UserService } from "./user.service";
-@Module({
-	providers: [UserService],
-	controllers: [UserController],
-})
-export class UserModule {}

src/user/user.service.ts

@@ -1,80 +0,0 @@
-import { PrismaService } from "@/prisma/prisma.service";
-import { Injectable } from "@nestjs/common";
-import { checkUserHasAccount, checkUserIsAdmin } from "src/utils/checkUser";
-
-@Injectable()
-export class UserService {
-	constructor(private prisma: PrismaService) {}
-
-	/**
-	 * Retrieves the assets of a given user, including their first name, last name, available dollars,
-	 * pseudo, and associated cryptocurrencies.
-	 *
-	 * @param {string} userId - The unique identifier of the user whose assets are being retrieved.
-	 * @return A promise that resolves to an object containing the user's assets and associated data.
-	 */
-	async getMyAssets(userId: string) {
-		await checkUserHasAccount(userId);
-
-		return this.prisma.user.findUnique({
-			where: {
-				id: userId,
-			},
-			select: {
-				firstName: true,
-				lastName: true,
-				dollarAvailables: true,
-				pseudo: true,
-				UserHasCrypto: {
-					select: {
-						Crypto: true,
-					},
-				},
-			},
-		});
-	}
-
-	/**
-	 * Retrieves the assets of users based on user ID.
-	 *
-	 * @param {string} userId - The ID of the user requesting the assets.
-	 * @return A promise that resolves to an array of user assets.
-	 */
-	async getUsersAssets(userId: string) {
-		await checkUserIsAdmin(userId);
-
-		return this.prisma.user.findMany({
-			select: {
-				firstName: true,
-				lastName: true,
-				pseudo: true,
-				dollarAvailables: true,
-				UserHasCrypto: {
-					select: {
-						Crypto: true,
-						amount: true,
-					},
-				},
-			},
-			take: 20,
-		});
-	}
-
-	/**
-	 * Fetches all trades associated with a given user.
-	 *
-	 * @param {string} userId - The unique identifier of the user.
-	 * @return A promise that resolves to an array of trade objects.
-	 */
-	async getMyTrades(userId: string) {
-		await checkUserHasAccount(userId);
-		return this.prisma.trade.findMany({
-			where: {
-				OR: [{ id_giver: userId }, { id_receiver: userId }],
-			},
-			include: {
-				Crypto: true,
-			},
-		});
-	}
-}

src/utils/checkUser.ts

@@ -1,86 +0,0 @@
-import { ForbiddenException } from "@nestjs/common";
-import { PrismaClient } from "@prisma/client";
-import { Roles } from "./const/const";
-
-const prisma = new PrismaClient();
-
-export async function checkRoleLevel(userId: string, level: string) {
-	if (!userId || !level) {
-		throw new ForbiddenException("Access to resources denied");
-	}
-
-	checkRoleExist(level);
-
-	const user = await prisma.user.findUnique({
-		where: {
-			id: userId,
-		},
-	});
-	if (user?.roleId) {
-		const role = await prisma.role.findFirst({
-			where: {
-				id: user.roleId,
-			},
-		});
-
-		if (role?.id) {
-			checkRoleExist(role.name);
-			if (level === Roles.ADMIN && role.name !== Roles.ADMIN) {
-				throw new ForbiddenException("Access to resources denied");
-			}
-		} else {
-			throw new ForbiddenException("Access to resources denied");
-		}
-	} else {
-		throw new ForbiddenException("Access to resources denied");
-	}
-}
-
-function checkRoleExist(role: string) {
-	switch (role) {
-		case Roles.ADMIN:
-		case Roles.USER:
-			break;
-		default:
-			throw new ForbiddenException("Access to resources denied");
-	}
-}
-
-export async function checkUserHasAccount(jwtId: string) {
-	if (jwtId) {
-		const user = await prisma.user.findUnique({
-			where: {
-				id: jwtId,
-				isActive: true,
-			},
-		});
-		if (!user || !user.id) {
-			throw new ForbiddenException("Access to resources denied");
-		}
-	} else {
-		throw new ForbiddenException("Access to resources denied");
-	}
-}
-
-export async function checkUserIsAdmin(jwtId: string) {
-	if (jwtId) {
-		const user = await prisma.user.findUnique({
-			where: {
-				id: jwtId,
-				isActive: true,
-			},
-			include: {
-				Role: true,
-			},
-		});
-		if (!user || !user.id) {
-			throw new ForbiddenException("Access to resources denied2");
-		}
-
-		if (user.Role.name !== Roles.ADMIN) {
-			throw new ForbiddenException("Access to resources denied3");
-		}
-	} else {
-		throw new ForbiddenException("Access to resources denied4");
-	}
-}

src/utils/const/const.ts

@@ -1,4 +0,0 @@
-export const Roles = {
-	ADMIN: "admin",
-	USER: "user",
-};

src/utils/tests/user-mock.ts

@@ -1,16 +0,0 @@
-// auth/test/mocks.ts
-import { User } from "@prisma/client";
-
-export const getMockUser = (): User => ({
-	id: "user-id",
-	email: "test@example.com",
-	firstName: "Test User",
-	lastName: "Test",
-	hash: "test-hash",
-	pseudo: "test-pseudo",
-	isActive: true,
-	created_at: new Date(),
-	updated_at: new Date(),
-	roleId: "user",
-	dollarAvailables: 1000,
-});