Merge branch 'main' into fix/CM-1999

Author: skwowet

backend/src/api/index.ts

@@ -168,6 +168,38 @@ setImmediate(async () => {
     next()
   })
 
+  app.use('/health', async (req: any, res) => {
+    try {
+      const seq = SequelizeRepository.getSequelize(req)
+
+      const [osPingRes, redisPingRes, dbPingRes, temporalPingRes] = await Promise.all([
+        // ping opensearch
+        opensearch.ping().then((res) => res.body),
+        // ping redis,
+        redis.ping().then((res) => res === 'PONG'),
+        // ping database
+        seq.query('select 1', { type: QueryTypes.SELECT }).then((rows) => rows.length === 1),
+        // ping temporal
+        req.temporal
+          ? (req.temporal as TemporalClient).workflowService.getSystemInfo({}).then(() => true)
+          : Promise.resolve(true),
+      ])
+
+      if (osPingRes && redisPingRes && dbPingRes && temporalPingRes) {
+        res.sendStatus(200)
+      } else {
+        res.status(500).json({
+          opensearch: osPingRes,
+          redis: redisPingRes,
+          database: dbPingRes,
+          temporal: temporalPingRes,
+        })
+      }
+    } catch (err) {
+      res.status(500).json({ error: err.message, stack: err.stack })
+    }
+  })
+
   // Configure the Entity routes
   const routes = express.Router()
 
@@ -207,38 +239,6 @@ setImmediate(async () => {
 
   app.use('/', routes)
 
-  app.use('/health', async (req: any, res) => {
-    try {
-      const seq = SequelizeRepository.getSequelize(req)
-
-      const [osPingRes, redisPingRes, dbPingRes, temporalPingRes] = await Promise.all([
-        // ping opensearch
-        opensearch.ping().then((res) => res.body),
-        // ping redis,
-        redis.ping().then((res) => res === 'PONG'),
-        // ping database
-        seq.query('select 1', { type: QueryTypes.SELECT }).then((rows) => rows.length === 1),
-        // ping temporal
-        req.temporal
-          ? (req.temporal as TemporalClient).workflowService.getSystemInfo({}).then(() => true)
-          : Promise.resolve(true),
-      ])
-
-      if (osPingRes && redisPingRes && dbPingRes && temporalPingRes) {
-        res.sendStatus(200)
-      } else {
-        res.status(500).json({
-          opensearch: osPingRes,
-          redis: redisPingRes,
-          database: dbPingRes,
-          temporal: temporalPingRes,
-        })
-      }
-    } catch (err) {
-      res.status(500).json({ error: err.message, stack: err.stack })
-    }
-  })
-
   app.use(errorMiddleware)
 })
 

backend/src/database/repositories/integrationRepository.ts

@@ -137,21 +137,6 @@ class IntegrationRepository {
 
     // also mark integration runs as deleted
     const seq = SequelizeRepository.getSequelize(options)
-    await seq.query(
-      `update "integrationRuns" set state = :newState
-     where "integrationId" = :integrationId and state in (:delayed, :pending, :processing)
-    `,
-      {
-        replacements: {
-          newState: IntegrationRunState.INTEGRATION_DELETED,
-          delayed: IntegrationRunState.DELAYED,
-          pending: IntegrationRunState.PENDING,
-          processing: IntegrationRunState.PROCESSING,
-          integrationId: id,
-        },
-        transaction,
-      },
-    )
 
     await seq.query(
       `update integration.runs set state = :newState

backend/src/database/repositories/member/memberOrganizationsRepository.ts

@@ -19,68 +19,56 @@ class MemberOrganizationsRepository {
     memberId: string,
     options: IRepositoryOptions,
   ): Promise<IRenderFriendlyMemberOrganization[]> {
-    const transaction = await SequelizeRepository.createTransaction(options)
-    try {
-      const txOptions = { ...options, transaction }
-      const qx = SequelizeRepository.getQueryExecutor(txOptions, transaction)
-
-      // Fetch member organizations
-      const memberOrganizations: IMemberOrganization[] = await fetchMemberOrganizations(
-        qx,
-        memberId,
-      )
-
-      // Parse unique organization ids
-      const orgIds: string[] = [...new Set(memberOrganizations.map((mo) => mo.organizationId))]
-
-      // Fetch organizations
-      let organizations: IOrganizationSummary[] = []
-      if (orgIds.length) {
-        organizations = await queryOrgs(qx, {
-          filter: {
-            [OrganizationField.ID]: {
-              in: orgIds,
-            },
-          },
-          fields: [OrganizationField.ID, OrganizationField.DISPLAY_NAME, OrganizationField.LOGO],
-        })
-      }
-
-      // Fetch affiliation overrides
-      const affiliationOverrides = await findMemberOrganizationAffiliationOverrides(
-        qx,
-        memberId,
-        memberOrganizations.map((mo) => mo.id),
-      )
-
-      // Create mapping by id to speed up the processing
-      const orgByid: Record<string, IOrganizationSummary> = organizations.reduce(
-        (obj: Record<string, IOrganizationSummary>, org) => ({
-          ...obj,
-          [org.id]: org,
-        }),
-        {},
-      )
-
-      // Format the results
-      const result: IRenderFriendlyMemberOrganization[] = memberOrganizations.map((mo) => ({
-        ...(orgByid[mo.organizationId] || {}),
-        id: mo.organizationId,
-        memberOrganizations: {
-          ...mo,
-          affiliationOverride: affiliationOverrides.find((ao) => ao.memberOrganizationId === mo.id),
-        },
-      }))
+    const qx = SequelizeRepository.getQueryExecutor(options)
 
-      await SequelizeRepository.commitTransaction(transaction)
+    // Fetch member organizations
+    const memberOrganizations: IMemberOrganization[] = await fetchMemberOrganizations(qx, memberId)
 
-      return result
-    } catch (err) {
-      if (transaction) {
-        await SequelizeRepository.rollbackTransaction(transaction)
-      }
-      throw err
+    if (memberOrganizations.length === 0) {
+      return []
     }
+
+    // Parse unique organization ids
+    const orgIds: string[] = [...new Set(memberOrganizations.map((mo) => mo.organizationId))]
+
+    // Fetch organizations
+    let organizations: IOrganizationSummary[] = []
+    if (orgIds.length) {
+      organizations = await queryOrgs(qx, {
+        filter: {
+          [OrganizationField.ID]: {
+            in: orgIds,
+          },
+        },
+        fields: [OrganizationField.ID, OrganizationField.DISPLAY_NAME, OrganizationField.LOGO],
+      })
+    }
+
+    // Fetch affiliation overrides
+    const affiliationOverrides = await findMemberOrganizationAffiliationOverrides(
+      qx,
+      memberId,
+      memberOrganizations.map((mo) => mo.id),
+    )
+
+    // Create mapping by id to speed up the processing
+    const orgByid: Record<string, IOrganizationSummary> = organizations.reduce(
+      (obj: Record<string, IOrganizationSummary>, org) => ({
+        ...obj,
+        [org.id]: org,
+      }),
+      {},
+    )
+
+    // Format the results
+    return memberOrganizations.map((mo) => ({
+      ...(orgByid[mo.organizationId] || {}),
+      id: mo.organizationId,
+      memberOrganizations: {
+        ...mo,
+        affiliationOverride: affiliationOverrides.find((ao) => ao.memberOrganizationId === mo.id),
+      },
+    }))
   }
 
   static async create(

backend/src/database/repositories/memberRepository.ts

@@ -543,19 +543,14 @@ class MemberRepository {
     const tenant = SequelizeRepository.getCurrentTenant(options)
 
     for (const i of identitiesToMove) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { rowCount } = await moveToNewMember(qx, {
+      await moveToNewMember(qx, {
         tenantId: tenant.id,
         oldMemberId: fromMemberId,
         newMemberId: toMemberId,
         platform: i.platform,
         value: i.value,
         type: i.type,
       })
-
-      if (rowCount !== 1) {
-        throw new Error('One row should be updated!')
-      }
     }
 
     if (identitiesToUpdate.length > 0) {

backend/src/database/repositories/organizationRepository.ts

@@ -316,25 +316,6 @@ class OrganizationRepository {
     }
   }
 
-  static findLfxMembershipInFilters(filter: any): any {
-    if (!filter) return null
-
-    if (filter.lfxMembership) {
-      return filter.lfxMembership
-    }
-
-    if (Array.isArray(filter.and)) {
-      for (const subFilter of filter.and) {
-        const result = OrganizationRepository.findLfxMembershipInFilters(subFilter)
-        if (result) {
-          return result
-        }
-      }
-    }
-
-    return null
-  }
-
   static convertOrgAttributesForDisplay(attributes: IDbOrgAttribute[]) {
     return attributes.reduce((acc, a) => {
       if (!acc[a.name]) {
@@ -1615,7 +1596,7 @@ class OrganizationRepository {
     const withAggregates = include.aggregates
 
     // look for lfxMembership filter
-    const lfxMembershipFilter = OrganizationRepository.findLfxMembershipInFilters(filter)
+    const lfxMembershipFilter = filter.and?.find((f) => f.lfxMembership)?.lfxMembership
     let lfxMembershipFilterWhereClause = ''
 
     if (lfxMembershipFilter) {
@@ -1627,8 +1608,14 @@ class OrganizationRepository {
       }
 
       // remove lfxMembership filter from obj since filterParser doesn't support it
-      filter.and = filter.and.filter((f) => !f.and?.some((subF) => subF.lfxMembership))
+      filter.and = filter.and.filter((f) => !f.lfxMembership)
+
+      // handle edge case where filter.and is empty
+      if (filter.and.length === 0) {
+        delete filter.and
+      }
     }
+
     if (segmentId) {
       const segment = (await findSegmentById(optionsQx(options), segmentId)) as any
 

backend/src/services/memberOrganizationService.ts

@@ -101,7 +101,7 @@ export default class MemberOrganizationService extends LoggerBase {
       (m) => mergeStrat.entityId(m) === secondaryId,
     )
 
-    this.mergeRoles(primaryRoles, secondaryRoles, mergeStrat)
+    await this.mergeRoles(primaryRoles, secondaryRoles, mergeStrat)
 
     // update rest of the o2 members
     const remainingRoles = await MemberOrganizationRepository.findNonIntersectingRoles(

backend/src/services/memberService.ts

@@ -1272,20 +1272,20 @@ export default class MemberService extends LoggerBase {
             },
           }
 
+          const repoOptions: IRepositoryOptions =
+            await SequelizeRepository.createTransactionalRepositoryOptions(this.options)
+          tx = repoOptions.transaction
+
           await MergeActionsRepository.add(
             MergeActionType.MEMBER,
             originalId,
             toMergeId,
-            this.options,
+            repoOptions,
             MergeActionStep.MERGE_STARTED,
             MergeActionState.IN_PROGRESS,
             backup,
           )
 
-          const repoOptions: IRepositoryOptions =
-            await SequelizeRepository.createTransactionalRepositoryOptions(this.options)
-          tx = repoOptions.transaction
-
           const identitiesToUpdate = []
           const identitiesToMove = []
           for (const identity of toMergeIdentities) {

backend/src/services/searchSyncService.ts

@@ -48,7 +48,7 @@ export default class SearchSyncService extends LoggerBase {
     return process()
   }
 
-  async triggerMemberSync(tenantId: string, memberId: string, opts: { withAggs?: boolean } = {}) {
+  async triggerMemberSync(tenantId: string, memberId: string, opts?: { withAggs?: boolean }) {
     const client = await this.getSearchSyncClient()
 
     if (client instanceof SearchSyncApiClient) {

frontend/src/modules/contributor/components/shared/contributor-work-position.vue

@@ -41,6 +41,7 @@ import { storeToRefs } from 'pinia';
 import LfAvatar from '@/ui-kit/avatar/Avatar.vue';
 import LfIcon from '@/ui-kit/icon/Icon.vue';
 import { Contributor } from '@/modules/contributor/types/Contributor';
+import useContributorHelpers from '@/modules/contributor/helpers/contributor.helpers';
 
 const props = defineProps<{
   contributor: Contributor,
@@ -49,7 +50,9 @@ const props = defineProps<{
 const lsSegmentsStore = useLfSegmentsStore();
 const { selectedProjectGroup } = storeToRefs(lsSegmentsStore);
 
-const organization = computed(() => props.contributor.organizations?.[0]);
+const { activeOrganization } = useContributorHelpers();
+
+const organization = computed(() => activeOrganization(props.contributor));
 const jobTitle = computed(() => organization.value?.memberOrganizations?.title
     || props.contributor.attributes?.jobTitle?.default);
 </script>

frontend/src/modules/contributor/helpers/contributor.helpers.ts

@@ -66,7 +66,15 @@ const useContributorHelpers = () => {
     }));
   };
 
-  const activeOrganization = (contributor: Contributor) => contributor.organizations?.[0];
+  const activeOrganization = (contributor: Contributor) => {
+    const { organizations } = contributor;
+    console.log(organizations);
+    return organizations.find((org) => org.memberOrganizations.affiliationOverride?.isPrimaryWorkExperience
+      && !!org.memberOrganizations.dateStart
+      && !org.memberOrganizations.dateEnd)
+      || organizations.find((org) => !!org.memberOrganizations.dateStart && !org.memberOrganizations.dateEnd)
+      || organizations.find((org) => !org.memberOrganizations.dateStart && !org.memberOrganizations.dateEnd) || null;
+  };
 
   return {
     avatar,