Add modification for post logic and add fields on user / contact

src/api/post/controllers/post.ts

@@ -30,9 +30,177 @@ export default factories.createCoreController(
       }
       ctx.request.body = { data };
       const result = await super.create(ctx);
+
+      // Créer le postOwnership associé
+      if (result.data) {
+        const userId = ctx.state.user?.id;
+        await strapi.db.query("api::post-ownership.post-ownership").create({
+          data: {
+            post: result.data.id,
+            author: userId,
+            contextType: data.contextType || "user",
+            contextId: data.contextId || null,
+            relation: "owner",
+          },
+        });
+      }
+
       return result;
     },
 
+    async feed(ctx) {
+      const userId = ctx.state.user?.id;
+      const { _limit = 20, _start = 0 } = ctx.query;
+
+      if (!userId) return ctx.badRequest("userId is required");
+
+      const queryParams = {
+        populate: {
+          post: {
+            populate: {
+              likes: true,
+              comments: {
+                populate: {
+                  owner: {
+                    populate: {
+                      avatar: true,
+                    },
+                  },
+                },
+              },
+              author: {
+                populate: {
+                  avatar: true,
+                },
+              },
+              media: true,
+            },
+          },
+          author: {
+            populate: {
+              avatar: true,
+            },
+          },
+          // populate context info if needed
+        },
+        sort: { createdAt: "desc" },
+        pagination: {
+          start: parseInt(String(_start)),
+          limit: parseInt(String(_limit)),
+        },
+      };
+
+      // 1️⃣ Récupérer les groupes de l'utilisateur
+      const groups = await strapi.db
+        .query("api::group-membership.group-membership")
+        .findMany({
+          where: { user: { id: parseInt(userId) } },
+          populate: ["group"],
+        });
+      const groupIds = groups.map((g) => g.group.id);
+
+      // 2️⃣ Récupérer les amis (contacts acceptés) et les follows
+      const friendsContacts = await strapi.db
+        .query("api::contact.contact")
+        .findMany({
+          where: {
+            $or: [
+              { owner: { id: parseInt(userId) } },
+              { user: { id: parseInt(userId) } },
+            ],
+            state: "accepted",
+          },
+          populate: ["owner", "user"],
+        });
+      const friendIds = friendsContacts.map((c) =>
+        c.owner.id !== parseInt(userId) ? c.owner.id : c.user.id
+      );
+
+      // Récupérer les contacts suivis (follow)
+      const followContacts = await strapi.db
+        .query("api::contact.contact")
+        .findMany({
+          where: {
+            owner: { id: parseInt(userId) },
+            state: "follow",
+          },
+          populate: ["user"],
+        });
+      const followIds = followContacts.map((c) => c.user.id);
+
+      // 3️⃣ Récupérer les groupes où mes amis sont membres (en excluant mes propres groupes)
+      const friendsGroupMemberships = await strapi.db
+        .query("api::group-membership.group-membership")
+        .findMany({
+          where: { user: { id: friendIds } },
+          populate: ["group"],
+        });
+      const friendsGroupIds = friendsGroupMemberships
+        .map((membership) => membership.group.id)
+        .filter((groupId) => !groupIds.includes(groupId)); // Exclure mes propres groupes
+
+      // 4️⃣ Récupérer le feed
+      const feed = await strapi.db
+        .query("api::post-ownership.post-ownership")
+        .findMany({
+          where: {
+            $or: [
+              { author: { id: friendIds } }, // Posts de mes amis
+              { author: { id: followIds } }, // Posts des contacts que je suis
+              { contextType: "group", contextId: groupIds }, // Posts de mes groupes
+              { contextType: "group", contextId: friendsGroupIds }, // Posts des groupes de mes amis
+              { contextType: "system" }, // Posts système
+            ],
+            relation: { $ne: "hidden" }, // exclure les posts masqués
+          },
+          ...queryParams,
+        });
+
+      // 5️⃣ Récupérer tous les groupes mentionnés dans le feed pour les populer
+      const allGroupIds = [...new Set([...groupIds, ...friendsGroupIds])];
+      const allGroups = await strapi.db.query("api::group.group").findMany({
+        where: { id: allGroupIds },
+      });
+
+      // Créer un map pour un accès rapide aux groupes par ID
+      const groupsMap = new Map(allGroups.map((group) => [group.id, group]));
+
+      // 6️⃣ Enrichir le feed avec les propriétés friend, member, contactFollow et group
+      const enrichedFeed = feed.map((postOwnership) => {
+        const authorId = postOwnership.author?.id;
+        const contextType = postOwnership.contextType;
+        const contextId = postOwnership.contextId;
+
+        // Vérifier si l'auteur est un ami
+        const isFriend = authorId ? friendIds.includes(authorId) : false;
+
+        // Vérifier si l'auteur est un contact suivi
+        const isContactFollow = authorId ? followIds.includes(authorId) : false;
+
+        // Vérifier si je suis membre du groupe (seulement pour les posts de groupe)
+        const isMember =
+          contextType === "group" && contextId
+            ? groupIds.includes(contextId)
+            : false;
+
+        // Ajouter l'objet group si contextType est "group"
+        const group =
+          contextType === "group" && contextId
+            ? groupsMap.get(contextId)
+            : null;
+
+        return {
+          ...postOwnership,
+          friend: isFriend,
+          contactFollow: isContactFollow,
+          member: isMember,
+          ...(group && { group }), // Ajouter group seulement s'il existe
+        };
+      });
+
+      ctx.send(enrichedFeed);
+    },
+
     async savePost(ctx) {
       console.log("🎯 savePost called with params:", ctx.params);
       console.log("🎯 Request method:", ctx.request.method);