feat: update badges repository

src/app.module.ts

@@ -25,11 +25,7 @@ import { RankingModule } from "./ranking/ranking.module";
             inject: [ConfigService],
             useFactory: async (configService: ConfigService) => ({
                 type: "postgres",
-                host: configService.get("DB_HOST"),
-                port: configService.get("DB_PORT"),
-                username: configService.get("DB_USERNAME"),
-                password: configService.get("DB_PASSWORD"),
-                database: configService.get("DB_NAME"),
+                url: configService.get("DATABASE_URL"),
                 synchronize: true,
                 autoLoadEntities: true,
             }),

src/ask/ask.module.ts

@@ -13,10 +13,11 @@ import { User } from "src/user/entities/user.entity";
 import { Comment } from "src/comment/entities/comment.entity";
 import { CommentService } from "src/comment/comment.service";
 import { Post } from "src/post/entities/post.entity";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([Ask, Score, User, Comment, Post]),
+        TypeOrmModule.forFeature([Ask, Score, User, Comment, Post, Badge]),
         ScoreModule,
     ],
     controllers: [AskController],

src/auth/auth.module.ts

@@ -8,6 +8,7 @@ import { UserService } from "src/user/user.service";
 import { User } from "src/user/entities/user.entity";
 import { TypeOrmModule } from "@nestjs/typeorm";
 import { AuthGuard } from "./auth.guard";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
@@ -21,7 +22,7 @@ import { AuthGuard } from "./auth.guard";
                 signOptions: { expiresIn: "60m" }
             }),
         }),
-        TypeOrmModule.forFeature([User]),
+        TypeOrmModule.forFeature([User, Badge]),
     ],
     exports: [JwtService, AuthGuard],
     controllers: [AuthController],

src/badge/entities/badge.entity.ts

@@ -1,5 +1,5 @@
 import { User } from "src/user/entities/user.entity";
-import { Column, Entity, ManyToMany, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
 
 @Entity()
 export class Badge {
@@ -8,10 +8,10 @@ export class Badge {
 
     @Column({ unique: true, type: "text" })
         title: string;
+
+    @Column({ type: "int", default: 0 })
+        xp: number;
 
     @OneToMany(() => User, user => user.currentBadge)
         currentUsers: User[];
-
-    @ManyToMany(() => User, user => user.username)
-        users: User[];
 }

src/comment/comment.module.ts

@@ -11,10 +11,11 @@ import { AuthService } from "src/auth/auth.service";
 import { UserService } from "src/user/user.service";
 import { User } from "src/user/entities/user.entity";
 import { Post } from "src/post/entities/post.entity";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([Comment, Score, User, Post]),
+        TypeOrmModule.forFeature([Comment, Score, User, Post, Badge]),
         ScoreModule,
     ],
     controllers: [CommentController],

src/events/events.module.ts

@@ -13,10 +13,11 @@ import { User } from "src/user/entities/user.entity";
 import { Comment } from "src/comment/entities/comment.entity";
 import { CommentService } from "src/comment/comment.service";
 import { Post } from "src/post/entities/post.entity";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([Event, Score, User, Comment, Post]),
+        TypeOrmModule.forFeature([Event, Score, User, Comment, Post, Badge]),
         ScoreModule,
     ],
     controllers: [EventsController],

src/material/material.module.ts

@@ -13,10 +13,11 @@ import { AuthService } from "src/auth/auth.service";
 import { Comment } from "src/comment/entities/comment.entity";
 import { CommentService } from "src/comment/comment.service";
 import { Post } from "src/post/entities/post.entity";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([Material, Score, User, Comment, Post]),
+        TypeOrmModule.forFeature([Material, Score, User, Comment, Post, Badge]),
         ScoreModule,
     ],
     controllers: [MaterialController],

src/ranking/ranking.module.ts

@@ -6,10 +6,11 @@ import { JwtService } from "@nestjs/jwt";
 import { AuthService } from "src/auth/auth.service";
 import { RankingService } from "./ranking.service";
 import { UserService } from "src/user/user.service";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([User]),
+        TypeOrmModule.forFeature([User, Badge]),
     ],
     controllers: [RankingController],
     providers: [JwtService, AuthService, RankingService, UserService]

src/score/score.module.ts

@@ -10,10 +10,11 @@ import { Comment } from "src/comment/entities/comment.entity";
 import { AuthService } from "src/auth/auth.service";
 import { CommentService } from "src/comment/comment.service";
 import { Post } from "src/post/entities/post.entity";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
-        TypeOrmModule.forFeature([Score, User, Comment, Post]),
+        TypeOrmModule.forFeature([Score, User, Comment, Post, Badge]),
     ],
     controllers: [ScoreController],
     providers: [JwtService, AuthService, ScoreService, UserService, CommentService],

src/test/test.module.ts

@@ -55,7 +55,6 @@ export class TestModule {
 
         const badge = new Badge();
         badge.title = "Aprendiz";
-        badge.users = [];
         await this.badgeRepository.save(badge);
 
         const user = new User();

src/user/user.module.ts

@@ -5,11 +5,12 @@ import { TypeOrmModule } from "@nestjs/typeorm";
 import { User } from "./entities/user.entity";
 import { AuthModule } from "src/auth/auth.module";
 import { AuthService } from "src/auth/auth.service";
+import { Badge } from "src/badge/entities/badge.entity";
 
 @Module({
     imports: [
         forwardRef(() => AuthModule),
-        TypeOrmModule.forFeature([User])
+        TypeOrmModule.forFeature([User, Badge])
     ],
     controllers: [UserController],
     providers: [AuthService, UserService],

src/user/user.service.spec.ts

@@ -8,11 +8,13 @@ import { Repository } from "typeorm";
 import { UpdateUserDto } from "./dto/update-user.dto";
 import { AuthService } from "src/auth/auth.service";
 import { ExpertiseException } from "src/expertise/expertise.service";
+import { Badge } from "src/badge/entities/badge.entity";
 
 describe("UserService", () => {
     let service: UserService;
     let mockRepository: Partial<Repository<User>> = {};
     let mockAuth: Partial<AuthService> = {};
+    const badgesMock: Partial<Repository<Badge>> = {};
 
     beforeEach(async () => {
         mockRepository = {};
@@ -25,6 +27,10 @@ describe("UserService", () => {
                     provide: getRepositoryToken(User),
                     useValue: mockRepository,
                 },
+                {
+                    provide: getRepositoryToken(Badge),
+                    useValue: badgesMock,
+                },
                 {
                     provide: AuthService,
                     useValue: mockAuth,
@@ -128,16 +134,20 @@ describe("UserService", () => {
             return user;
         };
 
+        badgesMock.find = async () => [];
+
         expect(service.findOneByUsername("teste"))
             .resolves
-            .toBe(user);
+            .toSatisfy((returnedUser: User) => returnedUser.username == user.username);
     });
 
     it("should return null for non existent username", () => {
         mockRepository.findOne = async () => {
             return null;
         };
 
+        badgesMock.find = async () => [];
+
         expect(service.findOneByUsername("teste"))
             .rejects
             .toThrow(new UserException("USER DOESNT EXIST"));

src/user/user.service.ts

@@ -32,6 +32,8 @@ export class UserService {
     constructor(
         @InjectRepository(User)
         private userRepository: Repository<User>,
+        @InjectRepository(Badge)
+        private badgeRepository: Repository<Badge>,
         @Inject(forwardRef(() => AuthService))
         private authService: AuthService,
     ) { }
@@ -151,13 +153,15 @@ export class UserService {
             where,
             relations: {
                 expertises: true,
-                badges: true,
                 currentBadge: true,
             }
         });
-
+
+        const badges = await this.badgeRepository.find();
+
         if (user) {
-            return user;
+            const userBadges = badges.filter(badge => badge.xp <= user.xp);
+            return { ...user, badges: userBadges };
         } else {
             throw new UserException("USER DOESNT EXIST");
         }