Merge branch 'crowd-linux' into lf-staging-main

backend/src/api/member/memberFind.ts

@@ -1,8 +1,8 @@
-import { isFeatureEnabled } from '@crowd/feature-flags'
 import { FeatureFlag } from '@crowd/types'
 import Permissions from '../../security/permissions'
 import MemberService from '../../services/memberService'
 import PermissionChecker from '../../services/user/permissionChecker'
+import isFeatureEnabled from '../../feature-flags/isFeatureEnabled'
 
 /**
  * GET /tenant/{tenantId}/member/{id}
@@ -34,7 +34,12 @@ export default async (req, res) => {
     }
   }
 
-  const payload = await new MemberService(req).findById(req.params.id, true, true, segmentId)
+  let payload
+  if (await isFeatureEnabled(FeatureFlag.SERVE_PROFILES_OPENSEARCH, req)) {
+    payload = await new MemberService(req).findByIdOpensearch(req.params.id, segmentId)
+  } else {
+    payload = await new MemberService(req).findById(req.params.id, true, true, segmentId)
+  }
 
   await req.responseHandler.success(req, res, payload)
 }

backend/src/api/organization/organizationFind.ts

@@ -1,8 +1,8 @@
 import { FeatureFlag } from '@crowd/types'
-import isFeatureEnabled from '@/feature-flags/isFeatureEnabled'
 import Permissions from '../../security/permissions'
 import OrganizationService from '../../services/organizationService'
 import PermissionChecker from '../../services/user/permissionChecker'
+import isFeatureEnabled from '../../feature-flags/isFeatureEnabled'
 
 /**
  * GET /tenant/{tenantId}/organization/{id}
@@ -34,7 +34,12 @@ export default async (req, res) => {
     }
   }
 
-  const payload = await new OrganizationService(req).findById(req.params.id, segmentId)
+  let payload
+  if (await isFeatureEnabled(FeatureFlag.SERVE_PROFILES_OPENSEARCH, req)) {
+    payload = await new OrganizationService(req).findByIdOpensearch(req.params.id, segmentId)
+  } else {
+    payload = await new OrganizationService(req).findById(req.params.id, segmentId)
+  }
 
   await req.responseHandler.success(req, res, payload)
 }

backend/src/api/premium/enrichment/memberEnrich.ts

@@ -1,6 +1,6 @@
 import { RedisCache } from '@crowd/redis'
 import { getServiceLogger } from '@crowd/logging'
-import { FeatureFlagRedisKey } from '@crowd/types'
+import { FeatureFlagRedisKey, SyncMode } from '@crowd/types'
 import { getSecondsTillEndOfMonth } from '../../../utils/timing'
 import Permissions from '../../../security/permissions'
 import identifyTenant from '../../../segment/identifyTenant'
@@ -29,7 +29,10 @@ const log = getServiceLogger()
 export default async (req, res) => {
   new PermissionChecker(req).validateHas(Permissions.values.memberEdit)
 
-  const payload = await new MemberEnrichmentService(req).enrichOne(req.params.id)
+  const payload = await new MemberEnrichmentService(req).enrichOne(
+    req.params.id,
+    SyncMode.SYNCHRONOUS,
+  )
 
   track('Single member enrichment', { memberId: req.params.id }, { ...req })
 

backend/src/bin/scripts/unleash-init.ts

@@ -273,6 +273,24 @@ const constaintConfiguration = {
       },
     ],
   ],
+
+  [FeatureFlag.SERVE_PROFILES_OPENSEARCH]: [
+    [
+      {
+        values: [
+          Plans.values.scale,
+          Plans.values.eagleEye,
+          Plans.values.enterprise,
+          Plans.values.essential,
+          Plans.values.growth,
+        ],
+        inverted: false,
+        operator: 'IN',
+        contextName: 'plan',
+        caseInsensitive: false,
+      },
+    ],
+  ],
 }
 
 let seq: any

backend/src/database/repositories/activityRepository.ts

@@ -677,7 +677,10 @@ class ActivityRepository {
       offset,
     })
 
-    let rows = await options.database.activity.findAll({
+    let {
+      rows,
+      count, // eslint-disable-line prefer-const
+    } = await options.database.activity.findAndCountAll({
       include,
       attributes: [
         ...SequelizeFilterUtils.getLiteralProjectionsOfModel('activity', options.database),
@@ -692,21 +695,7 @@ class ActivityRepository {
 
     rows = await this._populateRelationsForRows(rows, options)
 
-    const [countRow] = await options.database.sequelize.query(
-      `
-        SELECT n_live_tup AS count
-        FROM pg_stat_all_tables
-        WHERE schemaname = 'public'
-          AND relname = 'activities'
-      `,
-      {
-        type: Sequelize.QueryTypes.SELECT,
-        transaction: SequelizeRepository.getTransaction(options),
-      },
-    )
-    const { count } = countRow
-
-    return { rows, count: parseInt(count, 10), limit: parsed.limit, offset: parsed.offset }
+    return { rows, count, limit: parsed.limit, offset: parsed.offset }
   }
 
   static async findAllAutocomplete(query, limit, options: IRepositoryOptions) {

backend/src/database/repositories/memberRepository.ts

@@ -48,6 +48,7 @@ import {
 import OrganizationRepository from './organizationRepository'
 import MemberSyncRemoteRepository from './memberSyncRemoteRepository'
 import MemberAffiliationRepository from './memberAffiliationRepository'
+import MemberAttributeSettingsRepository from './memberAttributeSettingsRepository'
 
 const { Op } = Sequelize
 
@@ -1162,6 +1163,77 @@ class MemberRepository {
     })
   }
 
+  static async findByIdOpensearch(id, options: IRepositoryOptions, segmentId?: string) {
+    const segments = segmentId ? [segmentId] : SequelizeRepository.getSegmentIds(options)
+
+    const memberAttributeSettings = (
+      await MemberAttributeSettingsRepository.findAndCountAll({}, options)
+    ).rows
+
+    const response = await this.findAndCountAllOpensearch(
+      {
+        filter: {
+          and: [
+            {
+              id: {
+                eq: id,
+              },
+            },
+          ],
+        },
+        limit: 1,
+        offset: 0,
+        attributesSettings: memberAttributeSettings,
+        segments,
+      },
+      options,
+    )
+
+    if (response.count === 0) {
+      throw new Error404()
+    }
+
+    const result = response.rows[0]
+
+    // Get special attributes from memberAttributeSettings
+    const specialAttributes = memberAttributeSettings
+      .filter((setting) => setting.type === 'special')
+      .map((setting) => setting.name)
+
+    // Parse special attributes that are indexed as strings
+    if (result.attributes) {
+      specialAttributes.forEach((attr) => {
+        if (result.attributes[attr]) {
+          result.attributes[attr] = JSON.parse(result.attributes[attr])
+        }
+      })
+    }
+
+    // Sort the organizations based on dateStart
+    if (result.organizations) {
+      result.organizations.sort((a, b) => {
+        const dateStartA = a.memberOrganizations.dateStart
+        const dateStartB = b.memberOrganizations.dateStart
+
+        if (!dateStartA && !dateStartB) {
+          return 0
+        }
+
+        if (!dateStartA) {
+          return 1
+        }
+
+        if (!dateStartB) {
+          return -1
+        }
+
+        return new Date(dateStartB).getTime() - new Date(dateStartA).getTime()
+      })
+    }
+
+    return result
+  }
+
   static async findAndCountActiveOpensearch(
     filter: IActiveMemberFilter,
     limit: number,

backend/src/database/repositories/organizationRepository.ts

@@ -2132,6 +2132,46 @@ class OrganizationRepository {
     return results
   }
 
+  static async findByIdOpensearch(
+    id: string,
+    options: IRepositoryOptions,
+    segmentId?: string,
+  ): Promise<PageData<any>> {
+    const segments = segmentId ? [segmentId] : SequelizeRepository.getSegmentIds(options)
+
+    const response = await this.findAndCountAllOpensearch(
+      {
+        filter: {
+          and: [
+            {
+              id: {
+                eq: id,
+              },
+            },
+          ],
+        },
+        isProfileQuery: true,
+        limit: 1,
+        offset: 0,
+        segments,
+      },
+      options,
+    )
+
+    if (response.count === 0) {
+      throw new Error404()
+    }
+
+    const result = response.rows[0]
+
+    // Parse attributes that are indexed as strings
+    if (result.attributes) {
+      result.attributes = JSON.parse(result.attributes)
+    }
+
+    return result
+  }
+
   static async findAndCountAllOpensearch(
     {
       filter = {} as any,
@@ -2141,6 +2181,7 @@ class OrganizationRepository {
       countOnly = false,
       segments = [] as string[],
       customSortFunction = undefined,
+      isProfileQuery = false,
     },
     options: IRepositoryOptions,
   ): Promise<PageData<any>> {
@@ -2156,7 +2197,7 @@ class OrganizationRepository {
 
     const translator = FieldTranslatorFactory.getTranslator(OpenSearchIndex.ORGANIZATIONS)
 
-    if (filter.and) {
+    if (!isProfileQuery && filter.and) {
       filter.and.push({
         or: [
           {

backend/src/serverless/microservices/nodejs/org-merge/orgMergeWorker.ts

@@ -4,7 +4,15 @@ import { REDIS_CONFIG } from '../../../../conf'
 import getUserContext from '../../../../database/utils/getUserContext'
 import OrganizationService from '../../../../services/organizationService'
 
-async function doNotifyFrontend({ log, success, tenantId, primaryOrgId, secondaryOrgId }) {
+async function doNotifyFrontend({
+  log,
+  success,
+  tenantId,
+  primaryOrgId,
+  secondaryOrgId,
+  original,
+  toMerge,
+}) {
   const redis = await getRedisClient(REDIS_CONFIG, true)
   const apiPubSubEmitter = new RedisPubSubEmitter(
     'api-pubsub',
@@ -24,6 +32,8 @@ async function doNotifyFrontend({ log, success, tenantId, primaryOrgId, secondar
         tenantId,
         primaryOrgId,
         secondaryOrgId,
+        original,
+        toMerge,
       }),
       undefined,
       tenantId,
@@ -42,8 +52,13 @@ async function orgMergeWorker(
   const organizationService = new OrganizationService(userContext)
 
   let success = true
+  let original
+  let toMerge
   try {
-    await organizationService.mergeSync(primaryOrgId, secondaryOrgId)
+    const response = await organizationService.mergeSync(primaryOrgId, secondaryOrgId)
+
+    original = response.original
+    toMerge = response.toMerge
   } catch (err) {
     userContext.log.error(err, 'Error merging orgs')
     success = false
@@ -56,6 +71,8 @@ async function orgMergeWorker(
       tenantId,
       primaryOrgId,
       secondaryOrgId,
+      original,
+      toMerge,
     })
   }
 }

backend/src/services/integrationService.ts

@@ -1201,12 +1201,18 @@ export default class IntegrationService {
   async gitConnectOrUpdate(integrationData) {
     const transaction = await SequelizeRepository.createTransaction(this.options)
     let integration
+    const stripGit = (url: string) => {
+      if (url.endsWith('.git')) {
+        return url.slice(0, -4)
+      }
+      return url
+    }
     try {
       integration = await this.createOrUpdate(
         {
           platform: PlatformType.GIT,
           settings: {
-            remotes: integrationData.remotes,
+            remotes: integrationData.remotes.map((remote) => stripGit(remote)),
           },
           status: 'done',
         },

backend/src/services/memberService.ts

@@ -1131,6 +1131,10 @@ export default class MemberService extends LoggerBase {
     )
   }
 
+  async findByIdOpensearch(id: string, segmentId?: string) {
+    return MemberRepository.findByIdOpensearch(id, this.options, segmentId)
+  }
+
   async queryV2(data) {
     if (await isFeatureEnabled(FeatureFlag.SEGMENTS, this.options)) {
       if (data.segments.length !== 1) {

backend/src/services/organizationService.ts

@@ -274,7 +274,12 @@ export default class OrganizationService extends LoggerBase {
       )
 
       this.options.log.info({ originalId, toMergeId }, 'Organizations merged!')
-      return { status: 200, mergedId: originalId }
+      return {
+        status: 200,
+        mergedId: originalId,
+        original: original.displayName,
+        toMerge: toMerge.displayName,
+      }
     } catch (err) {
       this.options.log.error(err, 'Error while merging organizations!', {
         originalId,
@@ -811,6 +816,10 @@ export default class OrganizationService extends LoggerBase {
     return OrganizationRepository.findOrCreateByDomain(domain, this.options)
   }
 
+  async findByIdOpensearch(id: string, segmentId?: string) {
+    return OrganizationRepository.findByIdOpensearch(id, this.options, segmentId)
+  }
+
   async query(data) {
     const advancedFilter = data.filter
     const orderBy = data.orderBy