fix for projects, organizations segments table

Author: epipav

backend/src/database/migrations/V1683110675__segments.sql

@@ -37,6 +37,19 @@ ALTER TABLE "reports" ADD COLUMN "segmentId" uuid;
 
 ALTER TABLE "widgets" ADD COLUMN "segmentId" uuid;
 
+ALTER TABLE "memberToMerge" ADD COLUMN "segmentId" uuid;
+
+ALTER TABLE "memberToMerge" DROP CONSTRAINT "memberToMerge_pkey";
+
+ALTER TABLE public."memberToMerge" ADD CONSTRAINT "memberToMerge_pkey" PRIMARY KEY ("memberId", "toMergeId", "segmentId");
+
+
+ALTER TABLE "memberNoMerge" ADD COLUMN "segmentId" uuid;
+
+ALTER TABLE "memberNoMerge" DROP CONSTRAINT "memberNoMerge_pkey";
+
+ALTER TABLE public."memberNoMerge" ADD CONSTRAINT "memberNoMerge_pkey" PRIMARY KEY ("memberId", "noMergeId", "segmentId");
+
 
 CREATE TABLE public."memberSegments" (
     "memberId" uuid NOT NULL,
@@ -50,4 +63,20 @@ CREATE TABLE public."memberSegments" (
     -- create index for memberId, segmentId and tenantId
 );
 
+CREATE TABLE public."organizationSegments" (
+    "organizationId" uuid NOT NULL,
+    "segmentId" uuid NOT NULL,
+    "tenantId" uuid NOT NULL,
+    "createdAt" timestamp with time zone NOT NULL,
+    foreign key ("tenantId") references tenants (id),
+    foreign key ("segmentId") references segments (id),
+    foreign key ("organizationId") references organizations (id),
+    unique("organizationId", "segmentId", "tenantId")
+    -- create index for organizationId, segmentId and tenantId
+);
+
+
+
+
+
 

backend/src/database/models/member.ts

@@ -104,6 +104,7 @@ export default (sequelize) => {
     models.member.belongsToMany(models.segment, {
       as: 'segments',
       through: 'memberSegments',
+      timestamps: false,
     })
 
     models.member.hasOne(models.memberActivityAggregatesMV, {

backend/src/database/models/organization.ts

@@ -126,6 +126,12 @@ export default (sequelize) => {
       foreignKey: 'organizationId',
     })
 
+    models.organization.belongsToMany(models.segment, {
+      as: 'segments',
+      through: 'organizationSegments',
+      timestamps: false,
+    })
+
     models.organization.belongsTo(models.tenant, {
       as: 'tenant',
       foreignKey: {

backend/src/database/models/segment.ts

@@ -46,57 +46,6 @@ export default (sequelize) => {
       sourceParentId: {
         type: DataTypes.TEXT,
       },
-
-      platform: {
-        type: DataTypes.TEXT,
-        allowNull: false,
-        validate: {
-          notEmpty: true,
-        },
-      },
-      isContribution: {
-        type: DataTypes.BOOLEAN,
-        allowNull: false,
-        defaultValue: false,
-      },
-      score: {
-        type: DataTypes.INTEGER,
-        defaultValue: 2,
-      },
-      username: {
-        type: DataTypes.TEXT,
-      },
-      objectMemberUsername: {
-        type: DataTypes.TEXT,
-      },
-      attributes: {
-        type: DataTypes.JSONB,
-        allowNull: false,
-        defaultValue: {},
-      },
-      channel: {
-        type: DataTypes.TEXT,
-      },
-      body: {
-        type: DataTypes.TEXT,
-      },
-      title: {
-        type: DataTypes.TEXT,
-      },
-      url: {
-        type: DataTypes.TEXT,
-      },
-      sentiment: {
-        type: DataTypes.JSONB,
-        defaultValue: {},
-      },
-      importHash: {
-        type: DataTypes.STRING(255),
-        allowNull: true,
-        validate: {
-          len: [0, 255],
-        },
-      },
     },
     {
       indexes: [
@@ -105,8 +54,8 @@ export default (sequelize) => {
           fields: ['slug', 'parentSlug', 'grandparentSlug', 'tenantId'],
         },
       ],
-      timestamps: true,
-      paranoid: true,
+      timestamps: false,
+      paranoid: false,
     },
   )
 

backend/src/database/repositories/activityRepository.ts

@@ -562,6 +562,15 @@ class ActivityRepository {
                 to: 'tagId',
               },
             },
+            segments: {
+              table: 'members',
+              model: 'member',
+              relationTable: {
+                name: 'memberSegments',
+                from: 'memberId',
+                to: 'segmentId',
+              },
+            },
             organizations: {
               table: 'members',
               model: 'member',

backend/src/database/repositories/filters/queryParser.ts

@@ -401,13 +401,37 @@ class QueryParser {
     // eslint-disable-next-line prefer-const
     let { filter, orderBy, limit, offset, include, fields } = query
 
-    const dbQuery: any = {
-      where: {
-        tenantId: SequelizeRepository.getCurrentTenant(this.options).id,
-        segmentId: this.options.currentSegments.map((s) => s.id),
-      },
-      limit: QueryParser.defaultPageSize,
-      offset: 0,
+    let dbQuery: any
+
+    if (this.manyToMany.segments) {
+      const segmentsQuery = this.replaceWithManyToMany(
+        {
+          segments: this.options.currentSegments.map((s) => s.id),
+        },
+        'segments',
+      )
+
+      dbQuery = {
+        where: {
+          [Op.and]: [
+            {
+              tenantId: SequelizeRepository.getCurrentTenant(this.options).id,
+            },
+            segmentsQuery,
+          ],
+        },
+        limit: QueryParser.defaultPageSize,
+        offset: 0,
+      }
+    } else {
+      dbQuery = {
+        where: {
+          tenantId: SequelizeRepository.getCurrentTenant(this.options).id,
+          segmentId: this.options.currentSegments.map((s) => s.id),
+        },
+        limit: QueryParser.defaultPageSize,
+        offset: 0,
+      }
     }
 
     if (fields) {

backend/src/database/repositories/memberRepository.ts

@@ -26,7 +26,6 @@ import {
 } from './types/memberTypes'
 import { ActivityDisplayVariant } from '../../types/activityTypes'
 import SegmentRepository from './segmentRepository'
-import { SegmentData } from '../../types/segmentTypes'
 
 const { Op } = Sequelize
 
@@ -162,6 +161,25 @@ class MemberRepository {
     })
   }
 
+  static async excludeMemberFromSegments(memberId: string, options: IRepositoryOptions) {
+    const seq = SequelizeRepository.getSequelize(options)
+
+    const transaction = SequelizeRepository.getTransaction(options)
+
+    const bulkDeleteMemberSegments = `DELETE FROM "memberSegments" WHERE "memberId" = :memberId and "segmentId" in (:segmentIds);`
+
+    await seq.query(bulkDeleteMemberSegments, {
+      replacements: {
+        memberId,
+        segmentIds: options.currentSegments.map((s) => s.id),
+      },
+      type: QueryTypes.DELETE,
+      transaction,
+    })
+
+    return this.findById(memberId, options, true, false)
+  }
+
   static async findSampleDataMemberIds(options: IRepositoryOptions) {
     const transaction = SequelizeRepository.getTransaction(options)
     const currentTenant = SequelizeRepository.getCurrentTenant(options)
@@ -432,7 +450,13 @@ class MemberRepository {
     const currentTenant = SequelizeRepository.getCurrentTenant(options)
 
     const query = `
-    with identities as (select mi."memberId",
+    with segment_ids as (
+      select "memberId", array_agg("segmentId") as "segmentIds" from
+      "memberSegments"
+      where "tenantId" = :tenantId
+      group by "memberId"
+    ),
+    identities as (select mi."memberId",
                            array_agg(distinct mi.platform)             as identities,
                            jsonb_object_agg(mi.platform, mi.usernames) as username
                     from (select "memberId",
@@ -464,10 +488,12 @@ class MemberRepository {
             m."tenantId",
             m."createdById",
             m."updatedById",
-            i.username
+            i.username,
+            si."segmentIds" as segments
       from members m
               inner join "memberIdentities" mi on m.id = mi."memberId"
               inner join identities i on i."memberId" = m.id
+              inner join segment_ids si on si."memberId" = m.id
       where mi."tenantId" = :tenantId
         and mi.platform = :platform
         and mi.username in (:usernames)
@@ -515,7 +541,6 @@ class MemberRepository {
       where: {
         id,
         tenantId: currentTenant.id,
-        segmentId: options.currentSegments.map((s) => s.id),
       },
       transaction,
     })
@@ -587,6 +612,11 @@ class MemberRepository {
         transaction,
       })
     }
+
+    if (data.segments) {
+      await MemberRepository.includeMemberToSegments(record.id, { ...options, transaction })
+    }
+
     const seq = SequelizeRepository.getSequelize(options)
 
     if (data.username) {
@@ -664,25 +694,30 @@ class MemberRepository {
 
     const currentTenant = SequelizeRepository.getCurrentTenant(options)
 
-    const record = await options.database.member.findOne({
-      where: {
-        id,
-        tenantId: currentTenant.id,
-        segmentId: options.currentSegments.map((s) => s.id),
-      },
-      transaction,
-    })
+    const member = await MemberRepository.excludeMemberFromSegments(id, { ...options, transaction })
 
-    if (!record) {
-      throw new Error404()
-    }
+    // if member doesn't belong to any other segment anymore, remove it
 
-    await record.destroy({
-      force,
-      transaction,
-    })
+    if (member.segments.length === 0) {
+      const record = await options.database.member.findOne({
+        where: {
+          id,
+          tenantId: currentTenant.id,
+          segmentId: options.currentSegments.map((s) => s.id),
+        },
+        transaction,
+      })
 
-    await this._createAuditLog(AuditLogRepository.DELETE, record, record, options)
+      if (!record) {
+        throw new Error404()
+      }
+
+      await record.destroy({
+        force,
+        transaction,
+      })
+      await this._createAuditLog(AuditLogRepository.DELETE, record, record, options)
+    }
   }
 
   static async destroyBulk(ids, options: IRepositoryOptions, force = false) {
@@ -701,6 +736,7 @@ class MemberRepository {
     })
   }
 
+  /*
   static async getSegments(
     memberIds: string[],
     options: IRepositoryOptions,
@@ -714,18 +750,37 @@ class MemberRepository {
       select "memberId", "segmentId", "tenantId", "createdAt" from "memberSegments" where "memberId" in (:memberIds) order by "createdAt" asc;
     `
 
-    await seq.query(query, {
+    const data = await seq.query(query, {
       replacements: {
         memberIds,
       },
       type: QueryTypes.SELECT,
       transaction,
     })
 
+    for (const id of memberIds) {
+      results.set(id, [])
+    }
+
+    for (const res of data as any[]) {
+      const { memberId, segmentId, username, sourceId, integrationId, createdAt } = res
+      const identities = results.get(memberId)
+
+      identities.push({
+        platform,
+        username,
+        sourceId,
+        integrationId,
+        createdAt,
+      })
+    }
+
+
     // TODO: complete
 
     return results
   }
+  */
 
   static async getIdentities(
     memberIds: string[],
@@ -778,7 +833,15 @@ class MemberRepository {
   ) {
     const transaction = SequelizeRepository.getTransaction(options)
 
-    const include = []
+    const include = [
+      {
+        model: options.database.segment,
+        as: 'segments',
+        through: {
+          attributes: [],
+        },
+      },
+    ]
 
     const where: any = {
       id,
@@ -787,7 +850,6 @@ class MemberRepository {
     if (!ignoreTenant) {
       const currentTenant = SequelizeRepository.getCurrentTenant(options)
       where.tenantId = currentTenant.id
-      where.segmentId = options.currentSegments.map((s) => s.id)
     }
 
     const record = await options.database.member.findOne({