Add Documents to Case SubFolder On Add Case Page Using An Entry Template - IBM Case Manager

Hi there guys , in a previous blog i provided a nice trick to add documents to a case sub folder directly after adding a new case ,check here :

 https://ecmmania.blogspot.com/2017/07/add-documents-to-case-subfolder-on-add.html

Today , i  would continue on this trick and add a new feature which is adding the documents to the case subfolder using an entry template

Thanks to the inspiration from this post :

 https://www.ibm.com/developerworks/community/blogs/e8206aad-10e2-4c49-b00c-fee572815374/entry/add_a_document_with_an_entry_template_using_icm_5_2?lang=en

i used the same idea he's using but simplified the code by using build-in functions instead of writing custom code myself

the only add-on to the previous code that i used is that iam now retrieving the entry template with the vs-Id and passing this entry template to the Add Content Item Dialog to open the dialog with the entry template 

 the trick here is that by default adding the document by an entry template it would add the doc to the predefined folder configured in the entry template or you would have to choose the folder manualy if configured like this from the entry template settings

so how to add the doc to the case subfolder  ? in the callback of the addContentItemDialog on pressing the add button we are filling the chosen doc to the subfolder , that's it

one limitation of this implementation is that always there will be a copy of the added doc in the folder specified in the entry template settings plus the one add in the case subfolder , i have to work on this one in the future :D 

so let's get to the code : 

on the add case page insert a new script adapter 

 :choose the wiring like this 

Case Toolbar (case created) ----> Script Adapter(Recieve eveny payload)

the code is as follows : 

make sure to change the vs-id to the one of your entry template and to change the path to the sub folder you want

	require(["dojo/Deferred",
	"dojo/dom",
	"dojo/on",
	"ecm/widget/dialog/AddContentItemDialog",
	"dojo/domReady!"
	], function(Deferred, dom, on, AddContentItemDialog) {
	var getEntryTemplate = function(repository, entryTemplateId) {
	var deferred = new Deferred();
	repository.retrieveItem(null, function(item) {
	//var entryTemplate = repository.getEntryTemplateById(item.id,item.name, item.objectStore);
	var entryTemplateItem = {};
	entryTemplateItem.entryTemplate = item;
	entryTemplateItem.repository = repository;
	deferred.resolve(entryTemplateItem);
	},
	"EntryTemplate",
	"current",
	entryTemplateId);
	return deferred.promise;
	};
	var getCaseFolder = function(payload) {
	var deferred = new Deferred();
	var caseEditable = payload.caseEditable;
	console.log("caseEditable");
	console.log(caseEditable);
	caseEditable.getCase().retrieveCaseFolder(function(parentCaseFolder) {
	deferred.resolve(parentCaseFolder);
	});
	return deferred.promise;
	};
	var getSubFolder = function(parentCaseFolder, subFolderPath) {
	var deferred = new Deferred();
	console.log("parentCaseFolder");
	console.log(parentCaseFolder);
	var rootPath = parentCaseFolder.attributes.PathName;
	var fullPath = rootPath + "/" + subFolderPath;
	parentCaseFolder.repository.retrieveItem(fullPath, function(subfolder) {
	console.log("Subfolder");
	console.log(subfolder);
	deferred.resolve(subfolder);
	}, null, null, null, null, null);
	return deferred;
	};
	var executeFn = function(payload) {
	//vs-id of the entry template
	var entryTemplateId = "{84F966D4-A6E5-C65A-8A97-67140EB00000}";
	//the sub folder path like "Sub1/Sub2/Sub3"
	var subFolderPath = "F1";
	var getCaseFolderPromise = getCaseFolder(payload);
	getCaseFolderPromise.then(function(parentCaseFolder) {
	return getSubFolder(parentCaseFolder, subFolderPath);
	}).then(function(subfolder) {
	console.log("Promise Sub Folder");
	console.log(subfolder);
	console.log("Promise Repo ID");
	console.log(subfolder.repository.repositoryId);
	var repository = ecm.model.desktop.getRepository(subfolder.repository.repositoryId);
	console.log("Promise repository");
	console.log(repository);
	var getEntryTemplatePromise = getEntryTemplate(repository, entryTemplateId);
	getEntryTemplatePromise.then(function(entryTemplateItem) {
	console.log("entryTemplateItem");
	console.log(entryTemplateItem);
	var entryTemplate = entryTemplateItem.entryTemplate;
	var repository = entryTemplateItem.repository;
	var addContentItemDialog = new AddContentItemDialog();
	addContentItemDialog.showUsingTemplateItem(repository, subfolder, true, false, function(addedItem) {
	console.log("addedItem");
	console.log(addedItem);
	subfolder.addToFolder(addedItem, function() {
	console.log('Document added to sub folder ');
	});
	}, null, entryTemplate);
	});
	});
	};
	executeFn(payload);
	});

view raw Add Documents to Case SubFolder On Add Case Page Using An Entry Template - IBM Case Manager.txt hosted with ❤ by GitHub

Advanced Attachment validation based on which step response is selected - IBM Case Manager

Hi Guys , Iam back after a long stay away from the blog ,  here i will present an advanced scenario to validate that a certain attachment of a certain document class has an item content uploaded to it and that a certain number of versions are uploaded to this attachment.

The Biggest Main change from the previous post is the usage of deferred and promises , a big problem that some people has complained about the previous method that i wrote about validating the attachment is that sometimes it's working and sometimes it's not and that problem has been risen from the fact that a lot of the functions iam using to validate the attachments are asynchronous functions so sometimes the attachment check sequence is continued without the result of the asynchronous function call being provided 

so the usage of the promises and deferred will solve this problem , as i will use a deferred for each asynchronous function so that i will use it's promise to continue execution and checking , i mean i will use a chain of promises until i can get the final result of the check 

for example let's say i want to know a certain value of variable D and variable D can be only retrieved by a chain of asynchronous function calls as follows : 

Call Function1() then the callback  ---> retrieve variable A)
 Only if variable A is retrieved i can get Variable B
 Only if variable B is retrieved i can get Variable C
 Only if variable C is retrieved i can get Variable D

so the idea here is to use a chain of deferred and promises and after resolving each promise we continue execution

please check this tutorial for further info : further reading

in this example i provide a custom logic as follows :

i retrieve all the  attachment properties  i can get from the work item then validate each attachment to see which one represents the NOC attachment , then i retrieve all the content items attached to this NOC and check that the number of versions uploaded to the NOC is 2 or greater so it means that someone re uploaded a document to the attachment

 the additional validation  will be placed in a Script Adapter widget. 

• Add a Script Adaptor widget to the hidden widgets area on a work details page
• Wire an inbound event from the Page Container's Send Work Item to the Script Adaptor's Receive Event.
• The additional data validation logic will be triggered when the appropriate response button is clicked

here is the code : 

           require(["icm/base/Constants", "icm/model/properties/controller/ControllerManager", "dojo/Deferred", "dojo/promise/all"],  
             function(Constants, ControllerManager, Deferred, all) {  
               var workItemEdt = payload.workItemEditable; // getting workitemEditable.  
               var coord = payload.coordination; // getting coordination.  
               _globalCaseEditable = workItemEdt; // assigning workitemEditable to _globalCaseEditable for global scope.  
               //validation for NOC Signing  
               coord.participate(Constants.CoordTopic.VALIDATE, function(context, complete, abort) {  
                 var collectionController = ControllerManager.bind(_globalCaseEditable);  
                 // Validate if response is Reject  
                 if (context[Constants.CoordContext.WKITEMRESPONSE] === "Submit") {  
                   //check that the document is signed  
                   var propertiesCollection = _globalCaseEditable.propertiesCollection;  
                   var isSigned = false;  
                   var checkIfSigned = function(propertiesCollection) {  
                     var deferred = new Deferred();  
                     var versionDeferred = new Deferred();  
                     var contentItemPromisArr = [];  
                     var versionsPromisArr = [];  
                     var isSignedFlag = false;  
                     if (propertiesCollection) {  
                       var k;  
                       for (k in propertiesCollection) {  
                         if (propertiesCollection.hasOwnProperty(k)) {  
                           var p = propertiesCollection[k];  
                           if (p.dataType == "xs:attachment") {  
                             console.log("Found Attachment Field-->" + k);  
                             p.retrieveAttachmentContents(function(items) {  
                               contentItemPromisArr.push(items[0]);  
                             });  
                           }  
                         }  
                       }  
                     }  
                     all(contentItemPromisArr).then(function(contentItems) {  
                       console.log("All Content Items");  
                       console.log(contentItems);  
                       for (var i = 0; i < contentItems.length; i++) {  
                         var item = contentItems[i];  
                         if (item.template == "WorkPermitNOC") {  
                           item.retrieveAllVersions(function(resultSet) {  
                             versionDeferred.resolve(resultSet);  
                           });  
                           versionDeferred.then(function(resultSet) {  
                             var versionsContentItem = resultSet.items;  
                             console.log("Versions");  
                             console.log(versionsContentItem);  
                             console.log("version length");  
                             console.log(versionsContentItem.length);  
                             if (versionsContentItem.length >= 2) {  
                               isSignedFlag = true;  
                               var lastElementIndex = versionsContentItem.length - 1;  
                               console.log("last version -- " + lastElementIndex);  
                               console.log(versionsContentItem[lastElementIndex].attributes.LastModifier);  
                               console.log("last version isSigned-- " + isSignedFlag);  
                             }  
                             deferred.resolve(isSignedFlag);  
                           });  
                         }  
                       }  
                     });  
                     return deferred;  
                   }  
                   checkIfSigned(propertiesCollection).then(function(isSigned) {  
                     if (isSigned) {  
                       console.log("Document is Signed with a working version");  
                       /*abort({  
                        "message": "<strong>Document is Signed MAN !!! :) :) </strong>"  
                       });*/  
                       complete();  
                     } else {  
                       console.log("Document is not working");  
                       abort({  
                         "message": "<strong>Please sign the NOC document before submitting the request.</strong>"  
                       });  
                     }  
                   });  
                 } else {  
                   complete();  
                 }  
                 ControllerManager.unbind(_globalCaseEditable);  
               });  
             });