@pega/react-sdk-overrides 0.24.3 → 0.25.1

package/lib/infra/View/View.tsx

@@ -1,4 +1,4 @@
-import { PropsWithChildren } from 'react';
+import { PropsWithChildren, useEffect } from 'react';
 
 import { getComponentFromMap } from '@pega/react-sdk-components/lib/bridge/helpers/sdk_component_map';
 import { getAllFields } from '@pega/react-sdk-components/lib/components/helpers/template-utils';
@@ -18,6 +18,7 @@ interface ViewProps extends PConnProps {
   visibility?: boolean;
   name?: string;
   bInForm?: boolean;
+  type?: any;
 }
 
 //
@@ -36,12 +37,14 @@ const NO_HEADER_TEMPLATES = [
   'NarrowWideDetails',
   'WideNarrowDetails',
   'Confirmation',
-  'DynamicTabs'
+  'DynamicTabs',
+  'DetailsSubTabs'
 ];
 
 export default function View(props: PropsWithChildren<ViewProps>) {
-  const { children, template, getPConnect, mode, visibility, name: pageName } = props;
+  const { children, template, getPConnect, mode, visibility, name: pageName, type, title } = props;
   let { label = '', showLabel = false } = props;
+  const { PAGE_TYPES: { PAGE, LANDINGPAGE, LISTPAGE } = {}, MODAL } = PCore.getConstants();
 
   // Get the inherited props from the parent to determine label settings. For 8.6, this is only for embedded data form views
   // Putting this logic here instead of copy/paste in every Form template index.js
@@ -49,12 +52,43 @@ export default function View(props: PropsWithChildren<ViewProps>) {
   const inheritedProps: any = getPConnect().getInheritedProps(); // try to remove any when getInheritedProps typedefs are fixed
   label = inheritedProps.label || label;
   showLabel = inheritedProps.showLabel || showLabel;
+  const localeUtils = PCore.getLocaleUtils();
 
   const isEmbeddedDataView = mode === 'editable'; // would be better to check the reference child for `context` attribute if possible
   if (isEmbeddedDataView && showLabel === undefined) {
     showLabel = true;
   }
 
+  useEffect(() => {
+    // Get the localized application label
+    let applicationLabel = PCore.getEnvironmentInfo().getApplicationLabel();
+    applicationLabel = localeUtils.getLocaleValue(`${applicationLabel}`, '', '');
+    const caseInfo = getPConnect().getCaseInfo();
+    const isAssignmentInCreateStage = caseInfo && caseInfo.isAssignmentInCreateStage();
+    const isRenderingInModal = getPConnect().getContainerName().includes(MODAL);
+    const isRenderingInPreviewPanel = getPConnect().getContainerName().includes('preview');
+
+    /* If assignment is in create stage and rendering in modal don't update the title.
+      Title will be updated on completion of create stage and when the assignment is rendered inline to the page.
+    */
+    const canUpdateTitle =
+      !isRenderingInPreviewPanel &&
+      (type === PAGE || type === LANDINGPAGE || type === LISTPAGE) &&
+      !(isRenderingInModal && isAssignmentInCreateStage) &&
+      PCore.getEnvironmentInfo().getRenderingMode() === 'FULL_PORTAL';
+    // Incase of home route title is same as applicationLabel so setting to empty to just show applicationLabel
+    let titleVar = title === applicationLabel ? '' : title;
+
+    if (canUpdateTitle) {
+      if (caseInfo) {
+        const name = caseInfo.getName();
+        const id = caseInfo.getBusinessID();
+        titleVar = name && id ? `${name} (${id})` : titleVar;
+      }
+      document.title = titleVar ? `${titleVar} - ${applicationLabel}` : applicationLabel;
+    }
+  }, [type, title, getPConnect, PAGE, LANDINGPAGE, LISTPAGE]);
+
   const key = `${getPConnect().getContextName()}_${getPConnect().getPageReference()}_${pageName}`;
   // As long as the template is defined in the dependencies of the view
   // it will be loaded, otherwise fall back to single column

package/lib/template/AdvancedSearch/AdvancedSearch.tsx

@@ -0,0 +1,87 @@
+import { useContext, useState } from 'react';
+
+import { getComponentFromMap } from '@pega/react-sdk-components/lib/bridge/helpers/sdk_component_map';
+import DataReferenceAdvancedSearchContext from '@pega/react-sdk-components/lib/components/template/DataReference/DataReferenceAdvancedSearchContext';
+import { getFirstChildConfig } from '@pega/react-sdk-components/lib/components/template/DataReference/utils';
+
+export default function AdvancedSearch(props) {
+  const { getPConnect, targetObjectClass, localeReference } = props;
+  const SearchGroups = getComponentFromMap('SearchGroups');
+  const { dataReferenceConfigToChild, isCreateNewReferenceEnabled, disableStartingFieldsForReference, pyID, searchSelectCacheKey } = useContext(
+    DataReferenceAdvancedSearchContext
+  ) as any;
+
+  const { selectionMode, value: singleSelectFieldValue, readonlyContextList: multiSelectField } = dataReferenceConfigToChild;
+
+  let isSelectionExist = false;
+  const { MULTI } = PCore.getConstants().LIST_SELECTION_MODE;
+
+  if (selectionMode === MULTI) {
+    isSelectionExist = getPConnect().getValue(multiSelectField)?.length || false;
+  } else {
+    isSelectionExist = getPConnect().getValue(singleSelectFieldValue) || false;
+  }
+
+  const [showRecords, setShowRecords] = useState(isSelectionExist);
+
+  const pConn = getPConnect();
+  const rawViewMetadata = pConn.getRawMetadata();
+
+  const searchFieldsSet = new Set();
+  const searchFields: any = [];
+  rawViewMetadata.config.searchGroups.forEach(group => {
+    group.children.forEach(child => {
+      if (!searchFieldsSet.has(child.config.value) && !child.config.validator) {
+        searchFields.push(child);
+        searchFieldsSet.add(child.config.value);
+      }
+    });
+  });
+
+  const firstChildPConnect = getPConnect().getChildren()[0].getPConnect;
+  const [firstChildMeta] = rawViewMetadata.children;
+
+  const localizedVal = PCore.getLocaleUtils().getLocaleValue;
+  // @ts-ignore
+  const cache = PCore.getNavigationUtils().getComponentCache(searchSelectCacheKey) ?? {};
+
+  const editableFieldComp = firstChildPConnect().createComponent({
+    type: firstChildMeta.type,
+    config: {
+      ...getFirstChildConfig({
+        firstChildMeta,
+        getPConnect,
+        rawViewMetadata,
+        contextClass: targetObjectClass,
+        dataReferenceConfigToChild,
+        isCreateNewReferenceEnabled,
+        disableStartingFieldsForReference,
+        pyID
+      }),
+      searchFields,
+      showRecords,
+      label: localizedVal('Search results', 'DataReference'),
+      searchSelectCacheKey,
+      cache
+    }
+  });
+
+  const { selectionList, dataRelationshipContext } = editableFieldComp.props.getPConnect().getConfigProps();
+  const editableField = selectionMode === MULTI ? selectionList.substring(1) : dataRelationshipContext;
+
+  const searchGroupsProps = {
+    getPConnect,
+    editableField,
+    localeReference,
+    setShowRecords,
+    searchSelectCacheKey,
+    cache
+  };
+
+  return (
+    <>
+      <SearchGroups {...searchGroupsProps} />
+      {editableFieldComp}
+    </>
+  );
+}

package/lib/template/AdvancedSearch/SearchGroup/persistUtils.ts

@@ -0,0 +1,58 @@
+const SKIP_CACHE_KEY = '';
+
+export function getMappedKey(key) {
+  const mappedKey = PCore.getEnvironmentInfo().getKeyMapping(key);
+  if (!mappedKey) {
+    return key;
+  }
+  return mappedKey;
+}
+
+const getComponentStateKey = (getPConnect, propertyName: string) => {
+  const pConnect = getPConnect();
+  const caseID = `.${getMappedKey('pyID')}`; // Enhance this later when use-case arrives for data objects using S&S.
+  const resolvedCaseID = pConnect.getValue(caseID);
+
+  if (!resolvedCaseID) {
+    return SKIP_CACHE_KEY;
+  }
+
+  return `Search-${resolvedCaseID}-${pConnect.getPageReference()}-${propertyName}-${pConnect.getCurrentView()}`;
+};
+
+const getComponentStateOptions = getPConnect => {
+  return { clearOnCancelForContext: getPConnect().getContextName() };
+};
+
+interface SearchCategory {
+  // tabId of search category selected
+  selectedCategory: string;
+}
+
+interface SearchGroup {
+  // searchFields can be any object based on what fields are authored.
+  searchFields: unknown;
+  activeGroupId: string;
+}
+
+const setComponentCache = ({
+  cacheKey,
+  state,
+  options
+}: {
+  cacheKey: string;
+  state: SearchCategory | SearchGroup;
+  options: ReturnType<typeof getComponentStateOptions>;
+}) => {
+  if (cacheKey !== SKIP_CACHE_KEY) {
+    (PCore.getNavigationUtils() as any).setComponentCache(cacheKey, state, options);
+  }
+};
+
+const componentCachePersistUtils = {
+  getComponentStateKey,
+  getComponentStateOptions,
+  setComponentCache
+};
+
+export default componentCachePersistUtils;

package/lib/template/AdvancedSearch/SearchGroups/SearchGroups.tsx

@@ -0,0 +1,245 @@
+import React, { createElement, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { Button, Grid, Select, MenuItem, Box } from '@mui/material';
+
+import createPConnectComponent from '@pega/react-sdk-components/lib/bridge/react_pconnect';
+import TemplateContext from '@pega/react-sdk-components/lib/components/template/AdvancedSearch/TemplateContext';
+import componentCachePersistUtils from '@pega/react-sdk-components/lib/components/template/AdvancedSearch/SearchGroup/persistUtils';
+
+import { getCacheInfo, isValidInput } from './utils';
+import { useCacheWhenListViewReady } from './hooks';
+
+export const initializeSearchFields = (searchFields, getPConnect, referenceListClassID, searchFieldRestoreValues = {}) => {
+  const filtersProperties = {};
+  searchFields.forEach(field => {
+    let val = '';
+    const { value, defaultValue = '' } = field.config;
+    const propPath = PCore.getAnnotationUtils().getPropertyName(value);
+
+    if (searchFieldRestoreValues[propPath]) {
+      val = searchFieldRestoreValues[propPath];
+    } else if (PCore.getAnnotationUtils().isProperty(defaultValue)) {
+      val = getPConnect().getValue(defaultValue.split(' ')[1]);
+    } else if (defaultValue.startsWith('@L')) {
+      val = defaultValue.split(' ')[1];
+    } else {
+      val = defaultValue;
+    }
+
+    filtersProperties[propPath] = val;
+
+    const valueSplit = value.split('@P ')[1]?.split('.').filter(Boolean) ?? [];
+    valueSplit.pop();
+
+    if (valueSplit.length) {
+      let path = '';
+      let currentClassID = referenceListClassID;
+      valueSplit.forEach(item => {
+        path = path.length ? `${path}.${item}` : item;
+        currentClassID = (PCore.getMetadataUtils().getPropertyMetadata(item, currentClassID) as any).pageClass;
+        if (currentClassID) {
+          filtersProperties[`${path}.classID`] = currentClassID;
+        }
+      });
+    }
+  });
+  return filtersProperties;
+};
+
+const flattenObj = obj => {
+  const result = {};
+  Object.keys(obj).forEach(key => {
+    if (!['context_data', 'pageInstructions'].includes(key)) {
+      if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+        const temp = flattenObj(obj[key]);
+        Object.keys(temp).forEach(nestedKey => {
+          result[`${key}.${nestedKey}`] = temp[nestedKey];
+        });
+      } else {
+        result[key] = obj[key];
+      }
+    }
+  });
+  return result;
+};
+
+export default function SearchGroups(props) {
+  const localizedVal = PCore.getLocaleUtils().getLocaleValue;
+  const { getPConnect, editableField, localeReference, setShowRecords, searchSelectCacheKey, cache } = props;
+  const referenceFieldName = editableField.replaceAll('.', '_');
+
+  const state: any = useRef({ searchFields: {}, activeGroupId: '' }).current;
+  const options = componentCachePersistUtils.getComponentStateOptions(getPConnect);
+
+  const { searchGroups: groups, referenceList } = getPConnect().getConfigProps();
+  const { useCache, initialActiveGroupId } = getCacheInfo(cache, groups);
+  const [activeGroupId, setActiveGroupId] = useState(initialActiveGroupId);
+  const [transientItemID, setTransientItemID] = useState<any>(null);
+  const [previousFormValues, setPreviousFormValues] = useState<any>(null);
+  const viewName = getPConnect().getCurrentView();
+
+  const rawGroupsConfig = getPConnect().getRawConfigProps().searchGroups;
+  const activeGroupIndex = groups.findIndex(group => group.config.id === activeGroupId);
+  const { children: searchFieldsChildren = [] } = activeGroupIndex !== -1 ? rawGroupsConfig[activeGroupIndex] : {};
+  const searchFields = searchFieldsChildren.map(field => ({
+    ...field,
+    config: { ...field.config, isSearchField: true }
+  }));
+
+  const searchByRef = useRef(null);
+  const searchFieldsRef = useRef(null);
+  const isValidatorField = searchFields.some(field => field.config.validator);
+  const { classID: referenceListClassID } = PCore.getMetadataUtils().getDataPageMetadata(referenceList) as any;
+
+  const initialSearchFields = useMemo(
+    () =>
+      initializeSearchFields(
+        searchFields,
+        getPConnect,
+        referenceListClassID,
+        useCache && cache.activeGroupId === activeGroupId ? cache.searchFields : {}
+      ),
+    [activeGroupId, getPConnect, cache.searchFields]
+  );
+
+  useEffect(() => {
+    if (transientItemID) {
+      const filtersWithClassID = {
+        ...initialSearchFields,
+        classID: referenceListClassID
+      };
+      // @ts-ignore
+      PCore.getContainerUtils().replaceTransientData({ transientItemID, data: filtersWithClassID });
+    }
+  }, [activeGroupId]);
+
+  useEffect(() => {
+    const filtersWithClassID = {
+      ...initialSearchFields,
+      classID: referenceListClassID
+    };
+
+    const transientId = getPConnect()
+      .getContainerManager()
+      .addTransientItem({ id: `${referenceFieldName}-${viewName}`, data: filtersWithClassID });
+    setTransientItemID(transientId);
+  }, []);
+
+  const getFilterData = useCallback(() => {
+    // @ts-ignore
+    let changes = PCore.getFormUtils().getSubmitData(transientItemID, {
+      isTransientContext: true,
+      includeDisabledFields: true
+    });
+
+    if (Object.keys(cache.searchFields ?? {}).length > 0 && Object.keys(changes).length === 1) {
+      changes = cache.searchFields;
+    }
+
+    const formValues = flattenObj(changes);
+
+    if (!PCore.isDeepEqual(previousFormValues, formValues) && PCore.getFormUtils().isFormValid(transientItemID) && isValidInput(formValues)) {
+      if (isValidatorField) {
+        // @ts-ignore
+        PCore.getMessageManager().clearContextMessages({ context: transientItemID });
+      }
+      setPreviousFormValues(formValues);
+      setShowRecords(true);
+      PCore.getPubSubUtils().publish(PCore.getEvents().getTransientEvent().UPDATE_PROMOTED_FILTERS, {
+        payload: formValues,
+        showRecords: true,
+        viewName
+      });
+    }
+
+    state.activeGroupId = activeGroupId;
+    state.searchFields = changes;
+    state.selectedCategory = viewName;
+
+    componentCachePersistUtils.setComponentCache({ cacheKey: searchSelectCacheKey, state, options });
+  }, [transientItemID, setShowRecords, viewName, activeGroupId, previousFormValues]);
+
+  const resetFilterData = useCallback(() => {
+    // @ts-ignore
+    PCore.getNavigationUtils().resetComponentCache(searchSelectCacheKey);
+    const resetPayload = {
+      transientItemID,
+      data: initializeSearchFields(searchFields, getPConnect, referenceListClassID),
+      options: { reset: true }
+    };
+    // @ts-ignore
+    PCore.getContainerUtils().updateTransientData(resetPayload);
+  }, [transientItemID, initialSearchFields]);
+
+  useCacheWhenListViewReady(cache, viewName, useCache, getFilterData, searchSelectCacheKey);
+
+  const searchDropdown = groups.length > 1 && (
+    <Grid container spacing={2}>
+      <Select value={activeGroupId} onChange={e => setActiveGroupId(e.target.value)} ref={searchByRef} fullWidth>
+        {groups.map(group => (
+          <MenuItem key={group.config.id} value={group.config.id}>
+            {group.config.label}
+          </MenuItem>
+        ))}
+      </Select>
+    </Grid>
+  );
+
+  const actionButtons = (
+    <Box display='flex' gap={2}>
+      <Button variant='outlined' onClick={resetFilterData}>
+        {localizedVal('Reset', 'SimpleTable')}
+      </Button>
+      <Button variant='contained' onClick={getFilterData}>
+        {localizedVal('Search', 'SimpleTable')}
+      </Button>
+    </Box>
+  );
+
+  const searchFieldsViewConfig = {
+    name: 'SearchFields',
+    type: 'View',
+    config: {
+      template: 'DefaultForm',
+      NumCols: '3',
+      contextName: transientItemID,
+      readOnly: false,
+      context: transientItemID,
+      localeReference
+    },
+    children: [
+      {
+        name: 'Fields',
+        type: 'Region',
+        children: searchFields
+      }
+    ]
+  };
+
+  const searchFieldsC11nEnv = PCore.createPConnect({
+    meta: searchFieldsViewConfig,
+    options: {
+      hasForm: true,
+      contextName: transientItemID
+    }
+  });
+
+  const templateContext = useContext(TemplateContext);
+  const templateContextValue = useMemo(() => ({ ...templateContext, outerColumnCount: undefined }), []);
+
+  const searchFieldsViewComp = transientItemID ? (
+    <TemplateContext.Provider value={templateContextValue}>
+      <div ref={searchFieldsRef}>{createElement(createPConnectComponent(), { ...searchFieldsC11nEnv })}</div>
+    </TemplateContext.Provider>
+  ) : null;
+
+  const childrenToRender = [searchDropdown, searchFieldsViewComp, actionButtons];
+
+  return (
+    <Box display='flex' flexDirection='column' gap={2}>
+      {childrenToRender.map((child, index) => (
+        // eslint-disable-next-line react/no-array-index-key
+        <React.Fragment key={index}>{child}</React.Fragment>
+      ))}
+    </Box>
+  );
+}

package/lib/template/AdvancedSearch/SearchGroups/hooks.ts

@@ -0,0 +1,37 @@
+import { useEffect } from 'react';
+
+const listViewConstants = {
+  EVENTS: {
+    LIST_VIEW_READY: 'LIST_VIEW_READY'
+  }
+};
+/**
+ * This hook registers a callback for the whenever list view component is ready
+ * then makes a call to get the data using the search fields pre-filled with cache data.
+ */
+// eslint-disable-next-line import/prefer-default-export
+export function useCacheWhenListViewReady(
+  cache: { searchFields: unknown },
+  viewName: string,
+  useCache: boolean,
+  getFilterData: (params: { isCalledFromCache: boolean }) => void,
+  searchSelectCacheKey: string
+) {
+  useEffect(() => {
+    if (Object.keys(cache.searchFields ?? {}).length > 0) {
+      PCore.getPubSubUtils().subscribe(
+        listViewConstants.EVENTS.LIST_VIEW_READY,
+        ({ viewName: viewNameFromListView }: { viewName: string }) => {
+          if (viewNameFromListView === viewName && useCache) {
+            getFilterData({ isCalledFromCache: true });
+          }
+        },
+        `${searchSelectCacheKey}-listview-ready`
+      );
+    }
+
+    return () => {
+      PCore.getPubSubUtils().unsubscribe(listViewConstants.EVENTS.LIST_VIEW_READY, `${searchSelectCacheKey}-listview-ready`);
+    };
+  }, []);
+}

package/lib/template/AdvancedSearch/SearchGroups/index.tsx

@@ -0,0 +1 @@
+export { default } from './SearchGroups';

package/lib/template/AdvancedSearch/SearchGroups/utils.ts

@@ -0,0 +1,29 @@
+function isEmpty(value: any): boolean {
+  return (
+    // null or undefined
+    value === null ||
+    value === undefined ||
+    ((Array.isArray(value) || typeof value === 'string') && value.length === 0) ||
+    // is an Object and has no keys
+    (value.constructor === Object && Object.keys(value).length === 0)
+  );
+}
+
+export function getCacheInfo(
+  cache: { selectedCategory: string; activeGroupId: string; searchFields: unknown },
+  groups: { config: { id: string } }[]
+) {
+  let initialActiveGroupId = groups.length ? groups[0].config.id : '';
+
+  let useCache = false;
+  if (cache.activeGroupId && groups?.find(group => group.config.id === cache.activeGroupId)) {
+    initialActiveGroupId = cache.activeGroupId;
+    useCache = true;
+  }
+
+  return { useCache, initialActiveGroupId };
+}
+
+export function isValidInput(input: { [s: string]: unknown }) {
+  return Object.values(input).some(value => !isEmpty(value));
+}

package/lib/template/AdvancedSearch/TemplateContext.ts

@@ -0,0 +1,11 @@
+import { createContext } from 'react';
+
+const TemplateContext = createContext({
+  depth: 0,
+  columnCount: 1,
+  outerColumnCount: undefined,
+  templateOverrideMode: undefined,
+  inheritParentLayout: undefined,
+  lastContainerItem: undefined
+});
+export default TemplateContext;

package/lib/template/AdvancedSearch/config-ext.json

@@ -0,0 +1,9 @@
+{
+  "name": "AdvancedSearch",
+  "label": "Advanced search",
+  "type": "Template",
+  "icon": "AdvancedSearch.svg",
+  "subtype": "SEARCH",
+  "hideTemplateEdit": true,
+  "properties": []
+}

package/lib/template/AdvancedSearch/index.tsx

@@ -0,0 +1 @@
+export { default } from './AdvancedSearch';