@pega/custom-dx-components 0.24.15 → 0.242.1

package/src/tasks/rename-lib/index.js

@@ -0,0 +1,353 @@
+import path from 'path';
+import fs from 'fs';
+import { promisify } from 'util';
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+import { checkPathAccess, showVersion, getComponentsObj, getDirectoryFiles, getPegaServerConfig, getLibraryBased, deleteLocalLibrary, getC11NB2STokenAndStaticServer, updateComponentDefaultLibrary, updateDefaultOrganization } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+
+import { buildLib } from '@pega/constellation-dx-components-build-utils/index.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+const currentDirectory = process.cwd();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+const isLibraryBased = await getLibraryBased();
+
+
+import {
+  convertIntoPascalCase,
+  getComponentDirectoryPath,
+  getPegaConfig,
+  getComponentDefaults,
+  getComponents,
+  sanitize
+} from '../../util.js';
+import { deleteLocalComponents } from '@pega/custom-dx-components/src/tasks/delete/helper.js';
+
+const copy = promisify(ncp);
+
+
+export const getOrgLib = async () => {
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  let library;
+  ({ library } = componentData);
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  const componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+  componentDefaults.organization = organization;
+
+  return componentDefaults;
+}
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    library,
+    organization,
+    componentName,
+    componentLabel,
+    version,
+    description,
+    allowedApplications,
+    targetDirectory,
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+  let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  configData.label = componentLabel;
+  configData.organization = organization;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.library = library;
+  configData.version = version;
+  configData.description = (description != '') ? description : componentLabel;
+
+  configData.allowedApplications = allowedApplications;
+
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(join(targetDirectory, "/config.json"), JSON.stringify(configData, null, 4), { encoding: 'utf8' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    targetDirectory,
+) => {
+
+  let fileData = fs.readFileSync(join(targetDirectory, "/", fileName), { encoding: 'utf8' });
+
+  if (fileData.indexOf(oldComponentKeyPC) >= 0) {
+    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);
+
+    fs.writeFileSync(join(targetDirectory, "/", fileName), fileData, { encoding: 'utf8' });
+  }
+
+};
+
+export const renameLibrary = async ({library, organization}, options) => {
+
+  const compDef = await getOrgLib();
+  const currentOrganization = compDef.organization;
+  const currentLibrary = compDef.library;
+  const currentVersion = compDef.version;
+
+  let compVersion;
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.C11NB2S === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing services token.\nBuilding a library requires authentication to acquire a token to build."));
+    process.exit(1);
+
+  }
+
+  const currentOrgLib = currentOrganization.concat("_").concat(currentLibrary);
+  const newOrgLib = organization.concat("_").concat(library);
+
+  // reaname all the components
+  const components = await getComponents();
+  for (const index in components) {
+    const componentKey = components[index];
+    const componentName = componentKey.split('_')[2];
+    const currentDirectory = await getComponentDirectoryPath(componentKey);
+
+    let configData = fs.readFileSync(join(currentDirectory, "/config.json"), { encoding: 'utf8' });
+    configData = configData && JSON.parse(configData);
+
+    const componentLabel = configData.label.substring(0, configData.label.indexOf("(")).concat(`(${newOrgLib})`);
+    const description = configData.description.substring(0, configData.description.indexOf("(")).concat(`(${newOrgLib})`);
+    const version = configData.version;
+    compVersion = version;
+    const allowedApplications = configData.allowedApplications;
+
+    await renameComponent({library, organization, componentKey, componentName, componentLabel,
+      version, description, allowedApplications}, options);
+
+
+
+  }
+
+
+  // delete and rebuild library
+  try {
+    await deleteLocalLibrary(currentOrgLib);
+  }
+  catch (ex) {}
+
+
+  // update config
+  await updateComponentDefaultLibrary(library);
+  await updateDefaultOrganization(organization);
+
+  // call constellation-dx-components-build-utils build library, which will create a directory of the "buildLibName"
+  // with subdirectories for each version.
+  // If "buildDev", we append to version "-dev".  Currently, only "-dev" versions, when published, can be deleted.
+  buildLib(newOrgLib, compVersion, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+
+
+
+}
+
+
+export const renameComponent = async (
+  {
+    library,
+    organization,
+    componentKey,
+    componentName,
+    componentLabel,
+    version,
+    description,
+    allowedApplications
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+
+  let pegaConfig = await getPegaConfig();
+
+  const newComponentKey = `${organization}_${library}_${componentName}`;
+
+  const oldComponentKey = componentKey;
+  const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
+  const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);
+
+  const currentDirectory = await getComponentDirectoryPath(componentKey);
+  const targetDirectory = await getComponentDirectoryPath(newComponentKey);
+
+
+
+
+  // custom component
+  try {
+    fs.renameSync(currentDirectory, targetDirectory);
+  } catch(err) {
+    console.log(err)
+  }
+
+  const targetFileList = await getDirectoryFiles(targetDirectory);
+
+  for (var fileIndex in targetFileList) {
+    const fileName = targetFileList[fileIndex];
+
+    if (fileName === "config.json") {
+      await updateConfig(
+        {
+          oldComponentKey,
+          newComponentKey,
+          componentName,
+          componentLabel,
+          library,
+          version,
+          description,
+          allowedApplications,
+          organization,
+          targetDirectory,
+        },
+        options
+      );
+    }
+    else {
+      await updateFile(
+          fileName,
+          oldComponentKeyPC,
+          newComponentKeyPC,
+          targetDirectory );
+
+    }
+
+  } // for
+
+
+  console.log(chalk.green(`Component ${oldComponentKey} renamed to ${newComponentKey}`));
+
+};
+
+
+
+
+
+export default async options => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    process.exit();
+  }
+
+  showVersion();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  const { library } = componentData;
+  const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  let componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+
+  const localComponents = await getComponentsObj();
+
+
+  if (options.params.length >= 11) {
+    const organization = options.params[6];
+    const library = options.params[8];
+
+
+    await renameLibrary(
+      {
+        library,
+        organization
+      },
+      options
+    );
+
+  }
+  else {
+    const questions = [
+      {
+        name: 'organization',
+        message: 'Enter new component organization',
+        default: organization,
+        validate: value => {
+          if (value) {
+            return true;
+          }
+          return 'Please provide value for organization';
+        }
+      },
+      {
+        name: 'library',
+        message: 'Enter new library name',
+        default: componentDefaults.library,
+        validate: value => {
+          /* value should not be empty
+            It should not have spaces
+            It should not start with a number
+            Only case-insensitive alphanumeric values are allowed
+          */
+          if (value && !/^\d/.test(value) && value === sanitize(value)) {
+            return true;
+          }
+          return 'Only alphanumeric values are allowed, starting with alphabets';
+        }
+      }
+    ];
+
+    await inquirer.prompt(questions).then(async answers => {
+      const {
+        organization,
+        library
+      } = answers;
+
+      await renameLibrary(
+        {
+          library,
+          organization
+        },
+        options
+      );
+
+    });
+  }
+
+
+
+};

package/src/tasks/revert-webpack/index.js

@@ -9,13 +9,15 @@ import { up } from 'inquirer/lib/utils/readline.js';
 import {
   convertIntoPascalCase,
   showVersion,
-  updateUseWebPackPromotion
+  updateUseWebPackPromotion,
+  getLibraryBased
 } from '../../util.js';
 import {
   WEBPACK_CONFIG_JS_FILENAME,
   BUILDER_INDEX_FILE_PATH
 } from '../../constants.js';
 
+const isLibraryBased = await getLibraryBased();
 
 
 export const renamePromotedWebPack = async () => {
@@ -42,6 +44,11 @@ export const renamePromotedWebPack = async () => {
 
 
 export default async options => {
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    process.exit();
+  }
+
   showVersion();
 
   await renamePromotedWebPack();

package/src/util.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import path from 'path';
 import { join } from 'path';
 import { promisify } from 'util';
 import https from 'https';
@@ -20,7 +21,10 @@ import {
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   OOTB_COMPONENTS,
-  USE_PROMOTED_WEB_PACK
+  USE_PROMOTED_WEB_PACK,
+  BOOTSTRAP_CONFIG,
+  LIBRARY_BASED,
+  SHARED_DIRECTORY
 } from './constants.js';
 
 const access = promisify(fs.access);
@@ -100,6 +104,21 @@ export const updateUseWebPackPromotion = async ( useValue = false ) => {
 
 }
 
+export const getLibraryBased = async () => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+  if (data[LIBRARY_BASED]) {
+    return data[LIBRARY_BASED];
+  }
+  else return false;
+}
+
 export const deleteLocalComponent = async componentKey => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
@@ -180,6 +199,39 @@ export const deleteServerComponent = async componentKey => {
   }
 };
 
+export const copyFileToShared = async ( fileName, fileContents) => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+
+  data = JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH]);
+  const sharedDirectory = join(directory, SHARED_DIRECTORY);
+
+  // if shared doesn't exist, create it
+  if (!fs.existsSync(sharedDirectory)) {
+    fs.mkdirSync(sharedDirectory, { recursive: true });
+  }
+
+  const filePath = join(sharedDirectory, fileName);
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, fileContents);
+  }
+
+
+};
+
 export const getComponents = async () => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
@@ -200,7 +252,7 @@ export const getComponents = async () => {
   const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH]);
   return fs
     .readdirSync(directory, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
+    .filter(dirent => dirent.isDirectory() && dirent.name !== SHARED_DIRECTORY)
     .map(dirent => dirent.name);
 };
 
@@ -262,6 +314,45 @@ export const getComponentDefaults = async () => {
   return config.component;
 };
 
+export const updateComponentDefaultLibrary = async (library) => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let config = await getPegaConfig();
+  let componentsDefault = config.component;
+  componentsDefault.library = library;
+
+
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(config, null, 4),  { encoding: 'utf8' });
+
+}
+
+export const updateComponentDefaultVersion = async (version) => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let config = await getPegaConfig();
+  let componentsDefault = config.component;
+  componentsDefault.version = version;
+
+
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(config, null, 4),  { encoding: 'utf8' });
+
+}
+
+export const updateDefaultOrganization = async (organization) => {
+  let packageData = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf-8'));
+
+  packageData.organization = organization;
+
+  fs.writeFileSync(path.resolve('package.json'), JSON.stringify(packageData, null, 4),  { encoding: 'utf8' });
+
+}
+
 export const getServerType = async () => {
   const defaultPegaServerConfig = await getPegaServerConfig();
   return defaultPegaServerConfig.serverType;
@@ -592,3 +683,111 @@ export const deleteLaunchpadServerComponent = async componentKey => {
     throw new Error(error);
   }
 };
+
+export const getBootstrapConfig = async (restServerUrl, authorizationHeader) => {
+
+  const serverConfig = await getPegaServerConfig();
+
+  return fetch(`${restServerUrl}/${BOOTSTRAP_CONFIG}`, {
+    method: 'GET',
+    agent: getHttpsAgent(serverConfig),
+    headers: new Headers({
+      Authorization: authorizationHeader
+    })
+  }).then((response) => {
+    if (response.ok) {
+      return response.json();
+    }
+    throw Error('D_pxBootstrapConfig load failed.', { cause: response.status });
+  });
+};
+
+export const updateC11NB2SForInfinity = async () => {
+  const serverConfig = await getPegaServerConfig();
+  const { server } = serverConfig;
+  const OAuthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+
+  if (OAuthData) {
+    const { access_token: accessToken, token_type: tokenType } = JSON.parse(OAuthData);
+
+    const bootstrapJSON = await getBootstrapConfig(server, `${tokenType} ${accessToken}`);
+
+    if (bootstrapJSON) {
+      const bootstrap = JSON.parse(bootstrapJSON.pyConfigJSON);
+
+      const objOauthData = JSON.parse(OAuthData);
+      objOauthData["C11NB2S"] = bootstrap.tokens.C11NB2S;
+      objOauthData["appStaticContentServer"] = bootstrap.serviceConfig.appStaticContentServer;
+
+      // write out file
+      fs.writeFileSync(TOKEN_PATH, JSON.stringify(objOauthData), { encoding: 'utf8' });
+    }
+
+  }
+};
+
+export const updateC11NB2SForLaunchpad = async () => {
+
+
+
+};
+
+export const getC11NB2STokenAndStaticServer = async () => {
+  const serverConfig = await getPegaServerConfig();
+  const { server } = serverConfig;
+  let OAuthData;
+  try {
+    OAuthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+  }
+  catch (ex) {
+    return ({});
+  }
+
+  if (OAuthData) {
+    const { C11NB2S, appStaticContentServer } = JSON.parse(OAuthData)
+
+    if (C11NB2S) {
+      return ({ C11NB2S, appStaticContentServer});
+    }
+
+  }
+  return ({});
+}
+
+export const getLibraryVersions = async (libraryName) => {
+  const currentDirectory = process.cwd();
+
+  const directory = join(currentDirectory, libraryName);
+  return fs
+    .readdirSync(directory, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+};
+
+export const deleteLocalLibrary = async (libraryName) => {
+  const currentDirectory = process.cwd();
+
+  const directory = join(currentDirectory, libraryName);
+  fs.rmSync(directory, { recursive: true }, err => {
+    if (err) {
+      throw err;
+    }
+    else {
+      console.log(`Library:${chalk.green.bold(libraryName)} is deleted from Local`);
+    }
+  });
+}
+
+export const deleteLocalLibraryVersion = async (libraryName, libraryVersion) => {
+  const currentDirectory = process.cwd();
+
+  const directory = join(currentDirectory, libraryName, libraryVersion);
+  fs.rmSync(directory, { recursive: true }, err => {
+    if (err) {
+      throw err;
+    }
+    else {
+      console.log(`Library version:${chalk.green.bold(libraryName)}:${chalk.green.bold(libraryVersion)} is deleted from Local`);
+    }
+  });
+}

package/tests/assets/components/createAll/Constellation/Pega_DXIL_MyDetails/Avatar.tsx

@@ -0,0 +1,78 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+import  React from 'react';
+import { useEffect, useState } from 'react';
+import { Avatar as CosmosAvatar, withConfiguration } from '@pega/cosmos-react-core';
+import type { PConnFieldProps } from './PConnProps';
+
+
+// interface for props
+interface PegaDxilMyDetailsAvatarProps extends PConnFieldProps {
+  // If any, enter additional props that only exist on TextInput here
+  metaObj: any;
+  showStatus: boolean;
+
+}
+
+function Avatar(props: PegaDxilMyDetailsAvatarProps) {
+  const { metaObj, showStatus = false } = props;
+  const [imageBlobUrl, setImageBlobUrl] = useState(null);
+  let userName: string;
+  let userIdentifier: string;
+
+  // TODO Below if conditions can be removed once we have apis to get worklist/mywork info
+  // This is non CaseView case (Dashboard, MyWork etc)
+  if (!metaObj) {
+    userName = PCore.getEnvironmentInfo().getOperatorName();
+    userIdentifier = PCore.getEnvironmentInfo().getOperatorIdentifier();
+  } else {
+    userName = metaObj.name;
+    userIdentifier = metaObj.ID;
+  }
+  if (!userName && userIdentifier) {
+    userName = userIdentifier;
+  }
+
+  useEffect(() => {
+    const imageKey = !metaObj ? PCore.getEnvironmentInfo().getOperatorImageInsKey() : metaObj.image;
+    if (imageKey) {
+      PCore.getAssetLoader()
+        .getSvcImage(imageKey)
+        .then((blob) => window.URL.createObjectURL(blob))
+        .then((imagePath) => setImageBlobUrl(imagePath as React.SetStateAction<any>));
+    }
+  }, [metaObj]);
+
+  if (showStatus) {
+    const currentState = PCore.getMessagingServiceManager().getUserPresence().getUserState(userIdentifier);
+    const [userState, setUserState]: any  = useState(currentState === 'online' ? 'active' : 'inactive');
+
+    // @ts-ignore
+    const handleUserStateChange = ({ state }) => {
+      setUserState(state === 'online' ? 'active' : 'inactive');
+    };
+
+    useEffect(() => {
+      const subId = PCore.getMessagingServiceManager()
+        .getUserPresence()
+        // @ts-ignore
+        .subscribe(userIdentifier, handleUserStateChange);
+
+      return function cleanup() {
+        PCore.getMessagingServiceManager().getUserPresence().unsubscribe(userIdentifier, subId);
+      };
+    }, [userIdentifier, handleUserStateChange]);
+    // @ts-ignore
+    return <CosmosAvatar name={userName} imageSrc={imageBlobUrl as React.SetStateAction<any>} status={userState} />;
+  }
+
+  // Do not render when userName does not exists
+  // TODO : In CNR case, pxRequestor is not available, please remove this condition once it populates
+  if (!userName) {
+    return null;
+  }
+
+  return <CosmosAvatar name={userName} imageSrc={imageBlobUrl as React.SetStateAction<any>} />;
+}
+
+
+export default withConfiguration(Avatar);