Merge pull request #30 from WildCodeSchool/US0-commit-fix

modification demander par biom pour pouvoir l'utilsier enfin

Author: clement4444

.gitignore

@@ -10,4 +10,5 @@ database/
 dist
 
 # pour avoir une liste des tâche a faire qui reste en local
-toodo.md
+toodo.md
+ingnore

backend/src/entities/GroupMember.ts

@@ -1,5 +1,14 @@
 import { Field, ID, ObjectType } from "type-graphql";
-import { BaseEntity, Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, Unique } from "typeorm";
+import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Unique,
+} from "typeorm";
 import { Group } from "./Group";
 import User from "./User";
 
@@ -26,11 +35,17 @@ export class GroupMember extends BaseEntity {
   @Field()
   joined_at: Date;
 
-  @ManyToOne(() => User, (user) => user.groupMember)
+  @ManyToOne(
+    () => User,
+    (user) => user.groupMember,
+  )
   @JoinColumn({ name: "userId" })
   user: User;
 
-  @ManyToOne(() => Group, (group) => group.groupMember)
+  @ManyToOne(
+    () => Group,
+    (group) => group.groupMember,
+  )
   @JoinColumn({ name: "groupId" })
   group: Group;
 }

backend/src/entities/User.ts

@@ -76,7 +76,7 @@ class User extends BaseEntity {
   isAdmin: boolean = false;
 
   // ============= NOUVEAUX CHAMPS =============
-  
+
   @Column({ default: false })
   @Field()
   isBanned: boolean = false;
@@ -142,4 +142,4 @@ class User extends BaseEntity {
   lists: List[];
 }
 
-export default User;
+export default User;

backend/src/resolvers/GroupResolver.ts

@@ -1,10 +1,21 @@
-import { Arg, Ctx, Field, InputType, Mutation, Query, Resolver, UseMiddleware, FieldResolver, Root } from "type-graphql";
+import {
+  Arg,
+  Ctx,
+  Field,
+  FieldResolver,
+  InputType,
+  Mutation,
+  Query,
+  Resolver,
+  Root,
+  UseMiddleware,
+} from "type-graphql";
 import Group from "../entities/Group";
 import { GroupMember } from "../entities/GroupMember";
+import { Message } from "../entities/Message";
+import User from "../entities/User";
 import { RoleMiddleware } from "../middleware/RoleMiddleware";
 import type { ContextType } from "../types/context";
-import User from "../entities/User";
-import { Message } from "../entities/Message";
 
 @InputType()
 class CreateGroupInput {
@@ -33,13 +44,13 @@ export default class GroupResolver {
     const groups = await Group.find({
       where: {
         groupMember: {
-          user: { id: ctx.user?.id }
-        }
+          user: { id: ctx.user?.id },
+        },
       },
       relations: {
         groupMember: { user: true },
       },
-      order: { id: "DESC" }
+      order: { id: "DESC" },
     });
 
     // charge les 10 derniers messages de chaque groupe
@@ -58,28 +69,25 @@ export default class GroupResolver {
   @FieldResolver(() => [GroupMember])
   async groupMember(@Root() group: Group) {
     const members = await GroupMember.find({
-      where: { groupId: group.id }
+      where: { groupId: group.id },
     });
 
     return members || []; // >>> jamais null
   }
 
   @Mutation(() => Group)
   async createGroup(@Arg("data") data: CreateGroupInput, @Ctx() ctx: ContextType) {
-
     //TO DO: vérifier les inputs et les nettoyer
     if (!ctx.user) throw new Error("Utilisateur non connecté");
 
     //TO DO: ajouter l'utilisateur créant le groupe comme admin du groupe
-    let userAdmin;
+    let userAdmin: any;
     try {
       userAdmin = await User.findOneOrFail({ where: { id: ctx.user.id } });
     } catch {
       throw new Error("Utilisateur introuvable");
     }
 
-    
- 
     const group = Group.create({
       user_admin: userAdmin,
       name: data.name,
@@ -95,7 +103,6 @@ export default class GroupResolver {
         data.users.map(async (userEmail) => {
           const userToAdd = await User.findOne({ where: { email: userEmail } });
           if (!userToAdd) {
-            console.log("Cet utilisateur n'existe pas encore chez nous!");
             return;
           }
 
@@ -105,7 +112,7 @@ export default class GroupResolver {
           });
 
           await groupMember.save();
-        })
+        }),
       );
     }
 

backend/src/resolvers/MessageResolver.ts

@@ -1,55 +1,54 @@
-import { Arg, Ctx, Field, InputType, Mutation, Query, Resolver, UseMiddleware } from "type-graphql";
-import Group from "../entities/Group";
-import { GroupMember } from "../entities/GroupMember";
-import { Message } from "../entities/Message";
-import User from "../entities/User";
-import { RoleMiddleware } from "../middleware/RoleMiddleware";
-import type { ContextType } from "../types/context";
-
-@InputType()
-class NewMessageInput {
-    @Field()
-    groupId!: number;
-
-    @Field()
-    message!: string;
-}
-
-@Resolver(Group)
-export default class MessageResolver {
-    @UseMiddleware(RoleMiddleware())
-    // pour récupérer les anciens messages d'un groupe
-    @Query(() => String)
-    async fetchMessagesByGroup(@Ctx() ctx: ContextType) {
-        const userId = ctx.user?.id;
-
-        if (!userId) throw new Error("Utilisateur non authentifié");
-
-        // const group = await GroupMember.findOne({ where: { user: { id: userId }, group: { id: data.groupId } } });
-        // // verifier que l'utilisateur fait bien partie du groupe
-        // if (!group) throw new Error("Groupe non trouvé");
-
-        return "ok";
-    }
-
-    @UseMiddleware(RoleMiddleware())
-    // envoyer un nouveaux message
-    @Mutation(() => Boolean)
-    async sendMessage(@Ctx() ctx: ContextType, @Arg("data") data: NewMessageInput) {
-        const userId = ctx.user?.id;
-
-        if (!userId) throw new Error("Utilisateur non authentifié");
-
-        const group = await GroupMember.findOne({ where: { user: { id: userId }, group: { id: data.groupId } } });
-        // verifier que l'utilisateur fait bien partie du groupe
-        if (!group) throw new Error("Groupe non trouvé");
-
-        Message.create({
-            group: { id: data.groupId },
-            user: { id: userId },
-            content: data.message,
-        }).save();
-
-        return true;
-    }
-}
+import { Arg, Ctx, Field, InputType, Mutation, Query, Resolver, UseMiddleware } from "type-graphql";
+import Group from "../entities/Group";
+import { GroupMember } from "../entities/GroupMember";
+import { Message } from "../entities/Message";
+import { RoleMiddleware } from "../middleware/RoleMiddleware";
+import type { ContextType } from "../types/context";
+
+@InputType()
+class NewMessageInput {
+  @Field()
+  groupId!: number;
+
+  @Field()
+  message!: string;
+}
+
+@Resolver(Group)
+export default class MessageResolver {
+  @UseMiddleware(RoleMiddleware())
+  // pour récupérer les anciens messages d'un groupe
+  @Query(() => String)
+  async fetchMessagesByGroup(@Ctx() ctx: ContextType) {
+    const userId = ctx.user?.id;
+
+    if (!userId) throw new Error("Utilisateur non authentifié");
+
+    // const group = await GroupMember.findOne({ where: { user: { id: userId }, group: { id: data.groupId } } });
+    // // verifier que l'utilisateur fait bien partie du groupe
+    // if (!group) throw new Error("Groupe non trouvé");
+
+    return "ok";
+  }
+
+  @UseMiddleware(RoleMiddleware())
+  // envoyer un nouveaux message
+  @Mutation(() => Boolean)
+  async sendMessage(@Ctx() ctx: ContextType, @Arg("data") data: NewMessageInput) {
+    const userId = ctx.user?.id;
+
+    if (!userId) throw new Error("Utilisateur non authentifié");
+
+    const group = await GroupMember.findOne({ where: { user: { id: userId }, group: { id: data.groupId } } });
+    // verifier que l'utilisateur fait bien partie du groupe
+    if (!group) throw new Error("Groupe non trouvé");
+
+    Message.create({
+      group: { id: data.groupId },
+      user: { id: userId },
+      content: data.message,
+    }).save();
+
+    return true;
+  }
+}