@suitegeezus/suitecloud-cli 3.1.4

package/src/commands/object/import/ImportObjectsAction.js

@@ -0,0 +1,225 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const { ActionResult } = require('../../../services/actionresult/ActionResult');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const CommandsMetadataService = require('../../../core/CommandsMetadataService');
+const executeWithSpinner = require('../../../ui/CliSpinner').executeWithSpinner;
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const { getProjectDefaultAuthId } = require('../../../utils/AuthenticationUtils');
+const BaseAction = require('../../base/BaseAction');
+const {
+	COMMAND_IMPORTOBJECTS: { MESSAGES, WARNINGS },
+} = require('../../../services/TranslationKeys');
+const SdkExecutor = require('../../../SdkExecutor');
+
+const ANSWERS_NAMES = {
+	AUTH_ID: 'authid',
+	APP_ID: 'appid',
+	SCRIPT_ID: 'scriptid',
+	SPECIFY_SCRIPT_ID: 'specifyscriptid',
+	SPECIFY_SUITEAPP: 'specifysuiteapp',
+	OBJECT_TYPE: 'type',
+	SPECIFY_OBJECT_TYPE: 'specifyObjectType',
+	TYPE_CHOICES_ARRAY: 'typeChoicesArray',
+	DESTINATION_FOLDER: 'destinationfolder',
+	PROJECT_FOLDER: 'project',
+	OBJECTS_SELECTED: 'objects_selected',
+	OVERWRITE_OBJECTS: 'overwrite_objects',
+	IMPORT_REFERENCED_SUITESCRIPTS: 'import_referenced_suitescripts',
+};
+
+const COMMAND_FLAGS = {
+	EXCLUDE_FILES: 'excludefiles',
+};
+
+const LIST_OBJECTS_COMMAND_NAME = 'object:list';
+const IMPORT_OBJECTS_COMMAND_TYPE_PARAM_ALL = 'ALL';
+const IMPORT_OBJECTS_COMMAND_SCRIPT_ID_PARAM_ALL = 'ALL';
+const NUMBER_OF_SCRIPTS = 8;
+const MAX_PARALLEL_EXECUTIONS = 4;
+
+module.exports = class ImportObjectsAction extends BaseAction {
+	constructor(options) {
+		super(options);
+
+		const commandsMetadataService = new CommandsMetadataService();
+		this._listObjectsMetadata = commandsMetadataService.getCommandMetadataByName(LIST_OBJECTS_COMMAND_NAME);
+	}
+
+	preExecute(answers) {
+		answers[ANSWERS_NAMES.PROJECT_FOLDER] = CommandUtils.quoteString(this._projectFolder);
+		if (!this._runInInteractiveMode && answers.hasOwnProperty(ANSWERS_NAMES.DESTINATION_FOLDER)) {
+			answers.destinationfolder = CommandUtils.quoteString(answers.destinationfolder);
+		}
+
+		return answers;
+	}
+
+	async execute(params) {
+		if (params[ANSWERS_NAMES.OVERWRITE_OBJECTS] === false) {
+			throw NodeTranslationService.getMessage(MESSAGES.CANCEL_IMPORT);
+		}
+
+		const flags = [];
+		let commandParams = {};
+		try {
+			let scriptIdArray;
+			if (this._runInInteractiveMode) {
+				if (params[ANSWERS_NAMES.IMPORT_REFERENCED_SUITESCRIPTS] !== undefined && !params[ANSWERS_NAMES.IMPORT_REFERENCED_SUITESCRIPTS]) {
+					flags.push(COMMAND_FLAGS.EXCLUDE_FILES);
+					delete params[ANSWERS_NAMES.IMPORT_REFERENCED_SUITESCRIPTS];
+				}
+
+				scriptIdArray = params[ANSWERS_NAMES.SCRIPT_ID];
+			} else {
+				if (params[COMMAND_FLAGS.EXCLUDE_FILES]) {
+					flags.push(COMMAND_FLAGS.EXCLUDE_FILES);
+					delete params[COMMAND_FLAGS.EXCLUDE_FILES];
+				}
+
+				if (params[ANSWERS_NAMES.SCRIPT_ID] === IMPORT_OBJECTS_COMMAND_SCRIPT_ID_PARAM_ALL) {
+					if (params[ANSWERS_NAMES.OBJECT_TYPE] === IMPORT_OBJECTS_COMMAND_TYPE_PARAM_ALL) {
+						scriptIdArray = (await this._getAllScriptIds(params)).map((el) => el.scriptId);
+					} else {
+						scriptIdArray = (await this._getAllScriptIdsForObjectType(params)).map((el) => el.scriptId);
+					}
+				} else {
+					scriptIdArray = params[ANSWERS_NAMES.SCRIPT_ID];
+				}
+
+				await this._log.info(NodeTranslationService.getMessage(WARNINGS.OVERRIDE));
+			}
+
+			delete params[ANSWERS_NAMES.SCRIPT_ID];
+			const operationResultData = {
+				failedImports: [],
+				successfulImports: [],
+				errorImports: [],
+			};
+			let arrayOfPromises = [];
+			const sdkParams = CommandUtils.extractCommandOptions(params, this._commandMetadata);
+			const numberOfSdkCalls = Math.ceil(scriptIdArray.length / NUMBER_OF_SCRIPTS);
+			const numberOfSteps = Math.ceil(numberOfSdkCalls / MAX_PARALLEL_EXECUTIONS);
+
+			for (let i = 0; i < numberOfSdkCalls; i++) {
+				const partialScriptIds = scriptIdArray.slice(i * NUMBER_OF_SCRIPTS, (i + 1) * NUMBER_OF_SCRIPTS);
+				const partialScriptIdsString = partialScriptIds.join(' ');
+				const partialExecutionContextForImportObjects = SdkExecutionContext.Builder.forCommand(this._commandMetadata.sdkCommand)
+					.integration()
+					.addFlags(flags)
+					.addParams(sdkParams)
+					.addParam(ANSWERS_NAMES.SCRIPT_ID, partialScriptIdsString)
+					.build();
+
+				const sdkExecutor = new SdkExecutor(this._sdkPath, this._executionEnvironmentContext);
+				arrayOfPromises.push(
+					sdkExecutor
+						.execute(partialExecutionContextForImportObjects)
+						.then(this._parsePartialResult.bind({ partialScriptIds, operationResultData }))
+				);
+				if (i % MAX_PARALLEL_EXECUTIONS === (MAX_PARALLEL_EXECUTIONS - 1)) {
+					await executeWithSpinner({
+						action: Promise.all(arrayOfPromises),
+						message: NodeTranslationService.getMessage(MESSAGES.IMPORTING_OBJECTS, (i + 1) / MAX_PARALLEL_EXECUTIONS, numberOfSteps),
+					});
+					arrayOfPromises = [];
+				}
+			}
+
+			await executeWithSpinner({
+				action: Promise.all(arrayOfPromises),
+				message: NodeTranslationService.getMessage(MESSAGES.IMPORTING_OBJECTS, numberOfSteps, numberOfSteps),
+			});
+
+
+			//adding all the scripts id to the params
+			commandParams = {...sdkParams, [ANSWERS_NAMES.SCRIPT_ID]: scriptIdArray.join(' ')}
+
+			// At this point, the OperationResult will never be an error. It's handled before
+			return ActionResult.Builder.withData(operationResultData)
+				.withResultMessage(operationResultData.resultMessage)
+				.withCommandParameters(commandParams)
+				.withCommandFlags(flags)
+				.build();
+
+		} catch (error) {
+			return ActionResult.Builder.withErrors([error])
+				.withCommandParameters(commandParams)
+				.withCommandFlags(flags)
+				.build();
+		}
+	}
+
+	_parsePartialResult(partialOperationResult) {
+		if (partialOperationResult.status === SdkOperationResultUtils.STATUS.ERROR) {
+			this.operationResultData.errorImports = this.operationResultData.errorImports.concat({
+				scriptIds: this.partialScriptIds,
+				reason: partialOperationResult.errorMessages[0],
+			});
+		} else {
+			if (partialOperationResult.data.failedImports.length > 0) {
+				this.operationResultData.failedImports = this.operationResultData.failedImports.concat(
+					partialOperationResult.data.failedImports
+				);
+			}
+			if (partialOperationResult.data.successfulImports.length > 0) {
+				this.operationResultData.successfulImports = this.operationResultData.successfulImports.concat(
+					partialOperationResult.data.successfulImports
+				);
+			}
+			if (partialOperationResult.resultMessage){
+				this.operationResultData.resultMessage = partialOperationResult.resultMessage;
+			}
+		}
+	}
+
+	async _getAllScriptIdsForObjectType(params) {
+		const sdkParams = {};
+		sdkParams.type = params[ANSWERS_NAMES.OBJECT_TYPE];
+
+		return this._callListObjects(params, sdkParams);
+	}
+
+	async _getAllScriptIds(params) {
+		return this._callListObjects(params, {});
+	}
+
+	async _callListObjects(params, sdkParams) {
+		sdkParams.authid = params[ANSWERS_NAMES.AUTH_ID];
+		const appId = params[ANSWERS_NAMES.APP_ID];
+		if (appId) {
+			sdkParams.appid = appId;
+		}
+
+		const executionContext = SdkExecutionContext.Builder.forCommand(this._listObjectsMetadata.sdkCommand)
+			.integration()
+			.addParams(sdkParams)
+			.build();
+
+		const actionListObjects = this._sdkExecutor.execute(executionContext);
+
+		const listObjectsOperationResult = await executeWithSpinner({
+			action: actionListObjects,
+			message: NodeTranslationService.getMessage(MESSAGES.LOADING_OBJECTS),
+		});
+
+		if (listObjectsOperationResult.status === SdkOperationResultUtils.STATUS.ERROR) {
+			throw listObjectsOperationResult.errorMessages;
+		}
+
+		const listObjectsOperationResultData = listObjectsOperationResult.data;
+
+		if (listObjectsOperationResultData == null || (Array.isArray(listObjectsOperationResultData) && listObjectsOperationResultData.length === 0)) {
+			throw NodeTranslationService.getMessage(MESSAGES.NO_OBJECTS_IMPORTED);
+		}
+
+		return listObjectsOperationResultData;
+	}
+
+};

package/src/commands/object/import/ImportObjectsCommand.js

@@ -0,0 +1,20 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const Command = require('../../Command');
+const ImportObjectsAction = require('./ImportObjectsAction');
+const ImportObjectsInputHandler = require('./ImportObjectsInputHandler');
+const ImportObjectsOutputHandler = require('./ImportObjectsOutputHandler');
+
+module.exports = {
+	create(options) {
+		return Command.Builder.withOptions(options)
+			.withAction(ImportObjectsAction)
+			.withInput(ImportObjectsInputHandler)
+			.withOutput(ImportObjectsOutputHandler)
+			.build();
+	}
+};

package/src/commands/object/import/ImportObjectsInputHandler.js

@@ -0,0 +1,310 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const { join } = require('path');
+const { default : { prompt, Separator } } = require('inquirer');
+const CommandsMetadataService = require('../../../core/CommandsMetadataService');
+const executeWithSpinner = require('../../../ui/CliSpinner').executeWithSpinner;
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const { lineBreak } = require('../../../loggers/LoggerOsConstants');
+const { getProjectDefaultAuthId } = require('../../../utils/AuthenticationUtils');
+const BaseInputHandler = require('../../base/BaseInputHandler');
+const SdkExecutor = require('../../../SdkExecutor');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const FileSystemService = require('../../../services/FileSystemService');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const { PROJECT_SUITEAPP, PROJECT_ACP, FOLDERS } = require('../../../ApplicationConstants');
+const OBJECT_TYPES = require('../../../metadata/ObjectTypesMetadata');
+const {
+	COMMAND_IMPORTOBJECTS: { MESSAGES, QUESTIONS, ERRORS },
+	YES,
+	NO,
+	ERRORS: { PROMPTING_INTERACTIVE_QUESTIONS_FAILED },
+} = require('../../../services/TranslationKeys');
+const {
+	validateArrayIsNotEmpty,
+	showValidationResults,
+	validateSuiteApp,
+	validateScriptId,
+} = require('../../../validation/InteractiveAnswersValidator');
+const FileUtils = require('../../../utils/FileUtils');
+
+const ANSWERS_NAMES = {
+	AUTH_ID: 'authid',
+	APP_ID: 'appid',
+	SCRIPT_ID: 'scriptid',
+	SPECIFY_SCRIPT_ID: 'specifyscriptid',
+	SPECIFY_SUITEAPP: 'specifysuiteapp',
+	OBJECT_TYPE: 'type',
+	SPECIFY_OBJECT_TYPE: 'specifyObjectType',
+	TYPE_CHOICES_ARRAY: 'typeChoicesArray',
+	DESTINATION_FOLDER: 'destinationfolder',
+	PROJECT_FOLDER: 'project',
+	OBJECTS_SELECTED: 'objects_selected',
+	OVERWRITE_OBJECTS: 'overwrite_objects',
+	IMPORT_REFERENCED_SUITESCRIPTS: 'import_referenced_suitescripts',
+};
+
+const LIST_OBJECTS_COMMAND_NAME = 'object:list';
+const CUSTOM_SCRIPT_PREFIX = 'customscript';
+
+module.exports = class ImportObjectsInputHandler extends BaseInputHandler {
+	constructor(options) {
+		super(options);
+
+		// TODO input handlers shouldn't execute actions. rework this
+		this._sdkExecutor = new SdkExecutor(this._sdkPath, this._executionEnvironmentContext);
+
+		this._projectInfoService = new ProjectInfoService(this._projectFolder);
+		this._fileSystemService = new FileSystemService();
+		const commandsMetadataService = new CommandsMetadataService();
+		this._listObjectsMetadata = commandsMetadataService.getCommandMetadataByName(LIST_OBJECTS_COMMAND_NAME);
+	}
+
+	async getParameters(params) {
+		const listObjectQuestions = this._generateListObjectQuestions();
+		const listObjectAnswers = await prompt(listObjectQuestions);
+
+		const paramsForListObjects = this._arrangeAnswersForListObjects(listObjectAnswers);
+		const executionContextForListObjects = SdkExecutionContext.Builder.forCommand(this._listObjectsMetadata.sdkCommand)
+			.integration()
+			.addParams(paramsForListObjects)
+			.build();
+
+		let listObjectsResult;
+		try {
+			listObjectsResult = await executeWithSpinner({
+				action: this._sdkExecutor.execute(executionContextForListObjects),
+				message: NodeTranslationService.getMessage(MESSAGES.LOADING_LIST_OF_OBJECTS),
+			});
+		} catch (error) {
+			throw NodeTranslationService.getMessage(ERRORS.CALLING_LIST_OBJECTS, lineBreak, error);
+		}
+
+		if (listObjectsResult.status === SdkOperationResultUtils.STATUS.ERROR) {
+			throw listObjectsResult.errorMessages;
+		}
+		const { data } = listObjectsResult;
+
+		if (Array.isArray(data) && listObjectsResult.data.length === 0) {
+			throw NodeTranslationService.getMessage(MESSAGES.NO_OBJECTS_TO_LIST);
+		}
+
+		let selectionObjectAnswers;
+		let answersAfterObjectSelection;
+		let overwriteConfirmationAnswer;
+		try {
+			const selectionObjectQuestions = this._generateSelectionObjectQuestions(listObjectsResult);
+			selectionObjectAnswers = await prompt(selectionObjectQuestions);
+
+			const questionsAfterObjectSelection = this._generateQuestionsAfterObjectSelection(selectionObjectAnswers);
+			answersAfterObjectSelection = await prompt(questionsAfterObjectSelection);
+
+			const overwriteConfirmationQuestion = this._generateOverwriteConfirmationQuestion(answersAfterObjectSelection);
+			overwriteConfirmationAnswer = await prompt(overwriteConfirmationQuestion);
+		} catch (error) {
+			throw NodeTranslationService.getMessage(PROMPTING_INTERACTIVE_QUESTIONS_FAILED, lineBreak, error);
+		}
+
+		const combinedAnswers = { ...listObjectAnswers, ...selectionObjectAnswers, ...answersAfterObjectSelection, ...overwriteConfirmationAnswer };
+
+		const answers = this._arrangeAnswersForImportObjects(combinedAnswers);
+		return answers;
+	}
+
+	_generateListObjectQuestions() {
+		const questions = [];
+		if (this._projectInfoService.getProjectType() === PROJECT_SUITEAPP) {
+			const specifySuiteApp = {
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: ANSWERS_NAMES.SPECIFY_SUITEAPP,
+				message: NodeTranslationService.getMessage(QUESTIONS.SPECIFIC_APPID),
+				default: true,
+				choices: [
+					{ name: NodeTranslationService.getMessage(YES), value: true },
+					{ name: NodeTranslationService.getMessage(NO), value: false },
+				],
+				validate: (fieldValue) => showValidationResults(fieldValue, validateArrayIsNotEmpty),
+			};
+			questions.push(specifySuiteApp);
+
+			const specifyAppId = {
+				when: function (response) {
+					return response[ANSWERS_NAMES.SPECIFY_SUITEAPP];
+				},
+				type: CommandUtils.INQUIRER_TYPES.INPUT,
+				name: ANSWERS_NAMES.APP_ID,
+				message: NodeTranslationService.getMessage(QUESTIONS.APPID),
+				validate: (fieldValue) => showValidationResults(fieldValue, validateSuiteApp),
+			};
+			questions.push(specifyAppId);
+		}
+
+		const showAllObjects = {
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: ANSWERS_NAMES.SPECIFY_OBJECT_TYPE,
+			message: NodeTranslationService.getMessage(QUESTIONS.SHOW_ALL_CUSTOM_OBJECTS),
+			default: false,
+			choices: [
+				{ name: NodeTranslationService.getMessage(YES), value: false },
+				{ name: NodeTranslationService.getMessage(NO), value: true },
+			],
+		};
+		questions.push(showAllObjects);
+
+		const selectObjectType = {
+			when: function (answers) {
+				return answers[ANSWERS_NAMES.SPECIFY_OBJECT_TYPE];
+			},
+			type: CommandUtils.INQUIRER_TYPES.CHECKBOX,
+			name: ANSWERS_NAMES.TYPE_CHOICES_ARRAY,
+			message: NodeTranslationService.getMessage(QUESTIONS.FILTER_BY_CUSTOM_OBJECTS),
+			pageSize: 15,
+			choices: [
+				...OBJECT_TYPES.map((customObject) => ({
+					name: customObject.name,
+					value: customObject.value.type,
+				})),
+				new Separator(),
+			],
+			validate: (fieldValue) => showValidationResults(fieldValue, validateArrayIsNotEmpty),
+		};
+		questions.push(selectObjectType);
+
+		const filterByScriptId = {
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: ANSWERS_NAMES.SPECIFY_SCRIPT_ID,
+			message: NodeTranslationService.getMessage(QUESTIONS.FILTER_BY_SCRIPT_ID),
+			default: false,
+			choices: [
+				{ name: NodeTranslationService.getMessage(YES), value: true },
+				{ name: NodeTranslationService.getMessage(NO), value: false },
+			],
+		};
+		questions.push(filterByScriptId);
+
+		const specifyScriptId = {
+			when: function (response) {
+				return response[ANSWERS_NAMES.SPECIFY_SCRIPT_ID];
+			},
+			type: CommandUtils.INQUIRER_TYPES.INPUT,
+			name: ANSWERS_NAMES.SCRIPT_ID,
+			message: NodeTranslationService.getMessage(QUESTIONS.SCRIPT_ID),
+			validate: (fieldValue) => showValidationResults(fieldValue, validateScriptId),
+		};
+		questions.push(specifyScriptId);
+
+		return questions;
+	}
+
+	_generateSelectionObjectQuestions(operationResult) {
+		const questions = [];
+		const { data } = operationResult;
+
+		const choicesToShow = data.map((object) => ({
+			name: object.type + ':' + object.scriptId,
+			value: object,
+		}));
+
+		const questionListObjectsSelection = {
+			type: CommandUtils.INQUIRER_TYPES.CHECKBOX,
+			name: ANSWERS_NAMES.OBJECTS_SELECTED,
+			message: NodeTranslationService.getMessage(QUESTIONS.SELECT_OBJECTS),
+			choices: choicesToShow,
+			validate: (fieldValue) => showValidationResults(fieldValue, validateArrayIsNotEmpty),
+		};
+		questions.push(questionListObjectsSelection);
+		return questions;
+	}
+
+	_generateQuestionsAfterObjectSelection(selectionObjectAnswers) {
+		const questions = [];
+
+		const hasCustomScript = selectionObjectAnswers.objects_selected.some((element) => element.scriptId.startsWith(CUSTOM_SCRIPT_PREFIX));
+		if (this._projectInfoService.getProjectType() === PROJECT_ACP && hasCustomScript) {
+			const questionImportReferencedSuiteScripts = {
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: ANSWERS_NAMES.IMPORT_REFERENCED_SUITESCRIPTS,
+				message: NodeTranslationService.getMessage(QUESTIONS.IMPORT_REFERENCED_SUITESCRIPTS),
+				default: true,
+				choices: [
+					{ name: NodeTranslationService.getMessage(YES), value: true },
+					{ name: NodeTranslationService.getMessage(NO), value: false },
+				],
+			};
+			questions.push(questionImportReferencedSuiteScripts);
+		}
+
+		// extracting root prefix
+		// replacing '\' for '/', this is done because destinationfolder option in java-sdf works only with '/'
+		// sourroundig "" to the folder string so it will handle blank spaces case
+		const transformFoldersToChoicesFunc = (folder) => ({
+			name: folder.replace(this._projectFolder, '').replace(/\\/g, '/'),
+			value: `\"${folder.replace(this._projectFolder, '').replace(/\\/g, '/')}\"`,
+		});
+		const objectsFolder = join(this._projectFolder, FOLDERS.OBJECTS);
+		if (!FileUtils.exists(objectsFolder)) {
+			FileUtils.createDirectory(objectsFolder);
+		}
+		const objectsSubFolders = this._fileSystemService.getFoldersFromDirectory(objectsFolder);
+		const objectDirectoryChoices = [objectsFolder, ...objectsSubFolders].map(transformFoldersToChoicesFunc);
+
+		const questionDestinationFolder = {
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: ANSWERS_NAMES.DESTINATION_FOLDER,
+			message: NodeTranslationService.getMessage(QUESTIONS.DESTINATION_FOLDER),
+			choices: objectDirectoryChoices,
+		};
+		questions.push(questionDestinationFolder);
+		return questions;
+	}
+
+	_generateOverwriteConfirmationQuestion(answersAfterObjectSelection) {
+		const questions = [];
+
+		let overwriteConfirmationMessageKey;
+		if (
+			answersAfterObjectSelection[ANSWERS_NAMES.IMPORT_REFERENCED_SUITESCRIPTS] !== undefined &&
+			answersAfterObjectSelection[ANSWERS_NAMES.IMPORT_REFERENCED_SUITESCRIPTS]
+		) {
+			overwriteConfirmationMessageKey = QUESTIONS.OVERWRITE_OBJECTS_AND_FILES;
+		} else {
+			overwriteConfirmationMessageKey = QUESTIONS.OVERWRITE_OBJECTS;
+		}
+
+		const questionOverwriteConfirmation = {
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: ANSWERS_NAMES.OVERWRITE_OBJECTS,
+			message: NodeTranslationService.getMessage(overwriteConfirmationMessageKey),
+			default: true,
+			choices: [
+				{ name: NodeTranslationService.getMessage(YES), value: true },
+				{ name: NodeTranslationService.getMessage(NO), value: false },
+			],
+		};
+		questions.push(questionOverwriteConfirmation);
+		return questions;
+	}
+
+	_arrangeAnswersForListObjects(answers) {
+		answers[ANSWERS_NAMES.AUTH_ID] = this._authId;
+		if (answers[ANSWERS_NAMES.SPECIFY_OBJECT_TYPE]) {
+			answers[ANSWERS_NAMES.OBJECT_TYPE] = answers[ANSWERS_NAMES.TYPE_CHOICES_ARRAY].join(' ');
+		}
+		return CommandUtils.extractCommandOptions(answers, this._listObjectsMetadata);
+	}
+
+	_arrangeAnswersForImportObjects(answers) {
+		if (!answers[ANSWERS_NAMES.SPECIFY_OBJECT_TYPE] || answers[ANSWERS_NAMES.TYPE_CHOICES_ARRAY].length > 1) {
+			answers[ANSWERS_NAMES.OBJECT_TYPE] = 'ALL';
+		}
+		answers[ANSWERS_NAMES.SCRIPT_ID] = answers[ANSWERS_NAMES.OBJECTS_SELECTED].map((el) => el.scriptId);
+
+		return answers;
+	}
+};

package/src/commands/object/import/ImportObjectsOutputHandler.js

@@ -0,0 +1,114 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+const BaseOutputHandler = require('../../base/BaseOutputHandler');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const ActionResultUtils = require('../../../utils/ActionResultUtils');
+
+const {
+	COMMAND_IMPORTOBJECTS: { OUTPUT },
+} = require('../../../services/TranslationKeys');
+
+module.exports = class ImportObjectsOutputHandler extends BaseOutputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	parse(actionResult) {
+		if (
+			!actionResult.data ||
+			!(
+				(Array.isArray(actionResult.data.successfulImports) && actionResult.data.successfulImports.length) ||
+				(Array.isArray(actionResult.data.failedImports) && actionResult.data.failedImports.length) ||
+				(Array.isArray(actionResult.data.errorImports) && actionResult.data.errorImports.length)
+			)
+		) {
+			ActionResultUtils.logResultMessage(actionResult, this._log);
+			return actionResult;
+		}
+
+		this._logImportedObjects(actionResult.data.successfulImports);
+		this._logUnImportedObjects(actionResult.data.failedImports);
+		this._logErrorImportedObjects(actionResult.data.errorImports);
+		return actionResult;
+	}
+
+	_logImportedObjects(importedObjects) {
+		if (Array.isArray(importedObjects) && importedObjects.length) {
+			this._log.result(NodeTranslationService.getMessage(OUTPUT.IMPORTED_OBJECTS));
+			importedObjects.forEach((objectImport) => {
+				const importedObjectLogMessage = `${this._log.getPadding(1)}- ${objectImport.customObject.type}:${objectImport.customObject.id}`;
+				this._log.result(importedObjectLogMessage);
+				this._logReferencedFileImportResult(objectImport.referencedFileImportResult);
+			});
+		}
+	}
+
+	_logErrorImportedObjects(errorImports) {
+		const reasons = errorImports
+			.map((errorImport) => errorImport.reason)
+			.reduce((totalReasons, reason) => {
+				return totalReasons.includes(reason) ? totalReasons : totalReasons.concat(reason);
+			}, []);
+		reasons.forEach((reason) => {
+			this._log.error(NodeTranslationService.getMessage(OUTPUT.OBJECT_ERROR, reason));
+			errorImports
+				.filter((errorImport) => errorImport.reason === reason)
+				.forEach((errorImport) => {
+					errorImport.scriptIds.forEach((scriptId) => {
+						this._log.error(`${this._log.getPadding(1)}- ${scriptId}`);
+					});
+				});
+		});
+	}
+
+	_logReferencedFileImportResult(referencedFileImportResult) {
+		const importedFiles = referencedFileImportResult.successfulImports;
+		const unImportedFiles = referencedFileImportResult.failedImports;
+
+		const thereAreReferencedFiles =
+			(Array.isArray(importedFiles) && importedFiles.length) || (Array.isArray(unImportedFiles) && unImportedFiles.length);
+		if (thereAreReferencedFiles) {
+			const referencedFilesLogMessage = `${this._log.getPadding(2)}- ${NodeTranslationService.getMessage(OUTPUT.REFERENCED_SUITESCRIPT_FILES)}`;
+			this._log.result(referencedFilesLogMessage);
+		}
+
+		if (Array.isArray(importedFiles) && importedFiles.length) {
+			importedFiles.forEach((importedFile) => {
+				const importedFileLogMessage = `${this._log.getPadding(3)}- ${NodeTranslationService.getMessage(
+					OUTPUT.REFERENCED_SUITESCRIPT_FILE_IMPORTED,
+					importedFile.path
+				)}`;
+				this._log.result(importedFileLogMessage);
+			});
+		}
+
+		if (Array.isArray(unImportedFiles) && unImportedFiles.length) {
+			unImportedFiles.forEach((unImportedFile) => {
+				const unimportedFileLogMessage = `${this._log.getPadding(3)}- ${NodeTranslationService.getMessage(
+					OUTPUT.REFERENCED_SUITESCRIPT_FILE_IMPORT_FAILED,
+					unImportedFile.path,
+					unImportedFile.message
+				)}`;
+				this._log.warning(unimportedFileLogMessage);
+			});
+		}
+	}
+
+	_logUnImportedObjects(unImportedObjects) {
+		if (Array.isArray(unImportedObjects) && unImportedObjects.length) {
+			this._log.warning(NodeTranslationService.getMessage(OUTPUT.UNIMPORTED_OBJECTS));
+			unImportedObjects.forEach((objectImport) => {
+				const unimportedObjectLogMessage = `${this._log.getPadding(1)}- ${NodeTranslationService.getMessage(
+					OUTPUT.OBJECT_IMPORT_FAILED,
+					objectImport.customObject.type,
+					objectImport.customObject.id,
+					objectImport.customObject.result.message
+				)}`;
+				this._log.warning(unimportedObjectLogMessage);
+			});
+		}
+	}
+};