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

src/api/contact-meta/content-types/contact-meta/schema.json

@@ -0,0 +1,33 @@
+{
+  "kind": "collectionType",
+  "collectionName": "contact_metas",
+  "info": {
+    "singularName": "contact-meta",
+    "pluralName": "contact-metas",
+    "displayName": "ContactMeta"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "contact": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "api::contact.contact",
+      "inversedBy": "metas"
+    },
+    "owner": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "plugin::users-permissions.user",
+      "inversedBy": "contact_metas"
+    },
+    "favorite": {
+      "type": "boolean"
+    },
+    "note": {
+      "type": "string"
+    }
+  }
+}

src/api/contact-meta/controllers/contact-meta.ts

@@ -0,0 +1,7 @@
+/**
+ * contact-meta controller
+ */
+
+import { factories } from '@strapi/strapi'
+
+export default factories.createCoreController('api::contact-meta.contact-meta');

src/api/contact-meta/routes/contact-meta.ts

@@ -0,0 +1,7 @@
+/**
+ * contact-meta router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::contact-meta.contact-meta');

src/api/contact-meta/services/contact-meta.ts

@@ -0,0 +1,7 @@
+/**
+ * contact-meta service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::contact-meta.contact-meta');

src/api/contact/content-types/contact/schema.json

@@ -0,0 +1,53 @@
+{
+  "kind": "collectionType",
+  "collectionName": "contacts",
+  "info": {
+    "singularName": "contact",
+    "pluralName": "contacts",
+    "displayName": "Contact",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "owner": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "plugin::users-permissions.user",
+      "inversedBy": "contacts"
+    },
+    "user": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "plugin::users-permissions.user",
+      "inversedBy": "related_contacts"
+    },
+    "state": {
+      "type": "enumeration",
+      "enum": [
+        "pending",
+        "accepted",
+        "rejected",
+        "blocked",
+        "follow"
+      ]
+    },
+    "message": {
+      "type": "text"
+    },
+    "requestedAt": {
+      "type": "datetime"
+    },
+    "respondedAt": {
+      "type": "datetime"
+    },
+    "metas": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::contact-meta.contact-meta",
+      "mappedBy": "contact"
+    }
+  }
+}

src/api/contact/controllers/contact.ts

@@ -0,0 +1,50 @@
+/**
+ * contact controller
+ */
+
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreController(
+  "api::contact.contact",
+  ({ strapi }) => ({
+    async find(ctx) {
+      // Log de la requête entrante
+      console.log("GET /contacts - Requête reçue:", {
+        query: ctx.query,
+        params: ctx.params,
+        user: ctx.state.user?.id || "anonymous",
+      });
+
+      // Appel de la méthode parent
+      const result = await super.find(ctx);
+
+      // Log du résultat avant le return
+      console.log("GET /contacts - Résultat:", {
+        dataCount: result.data?.length || 0,
+        meta: result.meta,
+      });
+
+      return result;
+    },
+
+    async findOne(ctx) {
+      // Log de la requête entrante
+      console.log("GET /contacts/:id - Requête reçue:", {
+        id: ctx.params.id,
+        query: ctx.query,
+        user: ctx.state.user?.id || "anonymous",
+      });
+
+      // Appel de la méthode parent
+      const result = await super.findOne(ctx);
+
+      // Log du résultat avant le return
+      console.log("GET /contacts/:id - Résultat:", {
+        found: !!result.data,
+        id: result.data?.id,
+      });
+
+      return result;
+    },
+  })
+);

src/api/contact/routes/contact.ts

@@ -0,0 +1,7 @@
+/**
+ * contact router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::contact.contact');

src/api/contact/services/contact.ts

@@ -0,0 +1,7 @@
+/**
+ * contact service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::contact.contact');

src/api/group-membership/content-types/group-membership/schema.json

@@ -29,7 +29,8 @@
       "enum": [
         "member",
         "admin",
-        "owner"
+        "owner",
+        "follow"
       ]
     }
   }

src/api/post-ownership/content-types/post-ownership/schema.json

@@ -0,0 +1,50 @@
+{
+  "kind": "collectionType",
+  "collectionName": "post_ownerships",
+  "info": {
+    "singularName": "post-ownership",
+    "pluralName": "post-ownerships",
+    "displayName": "PostOwnership",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "post": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::post.post",
+      "inversedBy": "post_ownership"
+    },
+    "author": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "plugin::users-permissions.user",
+      "inversedBy": "post_ownerships"
+    },
+    "contextType": {
+      "type": "enumeration",
+      "enum": [
+        "user",
+        "group",
+        "system"
+      ]
+    },
+    "contextId": {
+      "type": "integer"
+    },
+    "relation": {
+      "type": "enumeration",
+      "enum": [
+        "owner",
+        "saved",
+        "hidden"
+      ]
+    },
+    "metas": {
+      "type": "json"
+    }
+  }
+}

src/api/post-ownership/controllers/post-ownership.ts

@@ -0,0 +1,7 @@
+/**
+ * post-ownership controller
+ */
+
+import { factories } from '@strapi/strapi'
+
+export default factories.createCoreController('api::post-ownership.post-ownership');

src/api/post-ownership/routes/post-ownership.ts

@@ -0,0 +1,7 @@
+/**
+ * post-ownership router
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('api::post-ownership.post-ownership');

src/api/post-ownership/services/post-ownership.ts

@@ -0,0 +1,7 @@
+/**
+ * post-ownership service
+ */
+
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('api::post-ownership.post-ownership');

src/api/post/content-types/post/schema.json

@@ -64,6 +64,12 @@
     },
     "source": {
       "type": "string"
+    },
+    "post_ownership": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::post-ownership.post-ownership",
+      "mappedBy": "post"
     }
   }
 }

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);

src/api/post/routes/custom.ts

@@ -9,5 +9,10 @@ export default {
       path: "/posts/:id/save",
       handler: "post.savePost",
     },
+    {
+      method: "GET",
+      path: "/posts/feed",
+      handler: "post.feed",
+    },
   ],
 };

src/extensions/users-permissions/content-types/user/schema.json

@@ -203,6 +203,33 @@
       "type": "relation",
       "relation": "oneToMany",
       "target": "api::post.post"
+    },
+    "contacts": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::contact.contact",
+      "mappedBy": "owner"
+    },
+    "related_contacts": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::contact.contact",
+      "mappedBy": "user"
+    },
+    "contact_metas": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::contact-meta.contact-meta",
+      "mappedBy": "owner"
+    },
+    "phone": {
+      "type": "string"
+    },
+    "post_ownerships": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::post-ownership.post-ownership",
+      "mappedBy": "author"
     }
   }
 }