Name

sn_collab_request.CollabTaskUtils

Description

No description available

Script

var CollabTaskUtils = (function() {
  return {
      /*
      	Generates collaboration task record for the passed user or group data
      */
      generateCollaborationTaskRecord: function(
          inviteeId,
          isGroup,
          appId,
          descriptorId,
  		shouldInsert
      ) {
          var tables = CollabTaskConstants.tables;
          var fields = CollabTaskConstants.fields.collabTask;
          var roles = CollabTaskConstants.roles;
          var errors = CollabTaskConstants.errors;

          var result = {
              inviteeId: inviteeId,
              errorDetails: []
          };

          if (!descriptorId) {
              result.errorDetails.push(errors.MISSING_DESCRIPTOR);
          }

          if (!inviteeId) {
              result.errorDetails.push(errors.MISSING_INVITEE);
          }

          if (result.errorDetails.length) {
              return result;
          }

          var collabTaskRecord = new GlideRecord(tables.COLLABORATION_TASK);

          collabTaskRecord.initialize();

          // descriptor fields
          var descriptorDetails = this.getCollabDescriptorDetails(descriptorId);

          collabTaskRecord.setValue(fields.COLLAB_DESCRIPTOR, descriptorId);
          collabTaskRecord.setValue(fields.COLLAB_DESCRIPTOR_SYS_ID, descriptorId);
          collabTaskRecord.setValue(fields.COLLAB_DESCRIPTOR_URL, descriptorDetails.descriptorUrl);
          collabTaskRecord.setValue(fields.COLLAB_DESCRIPTOR_NAME, descriptorDetails.descriptorName);

          //requestor field
          var requestorSysId = gs.getUser().getID();

          collabTaskRecord.setValue(fields.REQUESTOR, requestorSysId);
          collabTaskRecord.setValue(fields.REQUESTOR_SYS_ID, requestorSysId);
          collabTaskRecord.setValue(fields.REQUESTOR_NAME, gs.getUser().getDisplayName());
          collabTaskRecord.setValue(fields.REQUESTOR_EMAIL, gs.getUser().getEmail());

          // instance data
          var instanceId = this.getCurrentInstanceId();
          var isAESInstalledOnInstance = this.isAesInstalled();

          collabTaskRecord.setValue(fields.ORIGINATING_INSTANCE_ID, instanceId);
          collabTaskRecord.setValue(fields.ORIGINATING_INSTANCE_HAS_AES_INSTALLED, isAESInstalledOnInstance);

          // app details
          var appName = this.getAppName(appId);
          var appUrl = this.getAppUrl(appId, isAESInstalledOnInstance);

          collabTaskRecord.setValue(fields.APP_NAME, appName);
          collabTaskRecord.setValue(fields.APP_SYS_ID, appId);
          collabTaskRecord.setValue(fields.APP_URL, appUrl);

          // general record details
          var inviteeDetails = this.getInviteeDetails(inviteeId, isGroup) || {};
          var description = 'Collaboration Request for ' + inviteeDetails.name + ' - ' + appName;

          collabTaskRecord.setValue(fields.SHORT_DESCRIPTION, description);

          // invitee details
          // get role sys_ids 
          var roleDetails = this.getRoleDetails([roles.AES_ROLE, roles.DELEGATED_DEVELOPER_ROLE]);

          // check if invitee has the below roles
          var doesCollaboratorHaveAESRole = this.doesInviteeHaveRole(inviteeId, roleDetails[roles.AES_ROLE], isGroup);
          var doesCollaboratorHaveDelegatedDevRole = this.doesInviteeHaveRole(inviteeId, roleDetails[roles.DELEGATED_DEVELOPER_ROLE], isGroup);

          collabTaskRecord.setValue(fields.IS_INVITEE_GROUP, isGroup);

          if (isGroup) {
              // group invitee fields
              collabTaskRecord.setValue(fields.GROUP_INVITEE, inviteeId);
              collabTaskRecord.setValue(fields.GROUP_INVITEE_SYS_ID, inviteeId);
              collabTaskRecord.setValue(fields.GROUP_INVITEE_NAME, inviteeDetails.name);
  			collabTaskRecord.setValue(fields.GROUP_INVITEE_EMAIL, inviteeDetails.email);
              collabTaskRecord.setValue(fields.GROUP_INVITEE_HAS_AES_ROLE, doesCollaboratorHaveAESRole);
              collabTaskRecord.setValue(fields.GROUP_INVITEE_HAS_DDD_ROLE, doesCollaboratorHaveDelegatedDevRole);
          } else {
              // user invitee fields
              collabTaskRecord.setValue(fields.INVITEE, inviteeId);
              collabTaskRecord.setValue(fields.INVITEE_SYS_ID, inviteeId);
              collabTaskRecord.setValue(fields.INVITEE_NAME, inviteeDetails.name);
  			collabTaskRecord.setValue(fields.INVITEE_EMAIL, inviteeDetails.email);
              collabTaskRecord.setValue(fields.INVITEE_HAS_AES_ROLE, doesCollaboratorHaveAESRole);
              collabTaskRecord.setValue(fields.INVITEE_HAS_DD_ROLE, doesCollaboratorHaveDelegatedDevRole);
          }
  			
  		if (shouldInsert) {
  			var insertedId = collabTaskRecord.insert();
  			result.collaborationTaskId = insertedId || null;
              result.errorOnInsert = !insertedId;
  			
  		} else {
  			result.collaborationTaskRecord = collabTaskRecord;
  		}

          return result;
      },
      /*
      	Returns if user or group has the passed role
      */
      doesInviteeHaveRole: function(inviteeId, role, isGroup) {
          var tables = CollabTaskConstants.tables;
          var fields = CollabTaskConstants.fields.common;

          var result = false;

          var sourceTable = isGroup ? tables.GROUP_HAS_ROLE : tables.USER_HAS_ROLE;
          var sourceInviteeField = isGroup ? fields.GROUP : fields.USER;

          var inviteeHasRole = new GlideRecord(sourceTable);

          inviteeHasRole.addQuery(sourceInviteeField, inviteeId);
          inviteeHasRole.addQuery(fields.ROLE, role);

          inviteeHasRole.query();

          while (inviteeHasRole.next()) {
              result = true;
              break;
          }

          return result;
      },
      getInviteeDetails: function(inviteeId, isGroup) {
          var tables = CollabTaskConstants.tables;

          var sourceTable = isGroup ? tables.SYS_USER_GROUP : tables.SYS_USER;

          var sysUserOrGroupGR = new GlideRecord(sourceTable);
          sysUserOrGroupGR.get(inviteeId);

          return {
  			name: sysUserOrGroupGR.getValue('name'),
  			email: sysUserOrGroupGR.getValue('email')
  		};
      },
      /*
      	Returns a map of role name with the role sys_id
      */
      getRoleDetails: function(roleList) {
          var tables = CollabTaskConstants.tables;
          var fields = CollabTaskConstants.fields.common;

          var roleDetails = {};
          var roles = new GlideRecord(tables.USER_ROLE);


          roles.addQuery(fields.NAME, 'IN', roleList.join(','));

          roles.query();

          while (roles.next()) {
              var name = roles.getValue(fields.NAME);

              roleDetails[name] = roles.getValue(fields.SYS_ID);
          }

          return roleDetails;
      },
      /*
      	Returns the app's name based on the sys_id passed
      */
      getAppName: function(appId) {
          var tables = CollabTaskConstants.tables;
          var fields = CollabTaskConstants.fields.common;
      
          var app = new GlideRecord(tables.SYS_APP);
          
          if(app.get(appId)) {
              return app.getValue(fields.NAME);
          } else {
              var storeApp = new GlideRecord("sys_store_app");
              storeApp.get(appId);
              return storeApp.getValue(fields.NAME);
          }
      },
      /*
      	Returns current instance id
      */
      getCurrentInstanceId: function(appId) {
          return gs.getProperty(CollabTaskConstants.INSTANCE_ID);
      },
      /*
      	Returns if AES is installed on instance
      */
      isAesInstalled: function(appId) {
          return GlidePluginManager.isActive(CollabTaskConstants.AES_PLUGIN_ID);
      },
      getAppUrl: function(appId, isAESInstalledOnInstance) {
          return isAESInstalledOnInstance ?
              this.getCurrentInstanceUrl() + CollabTaskConstants.paths.AES_APP_HOME + appId :
              this.getCurrentInstanceUrl() + CollabTaskConstants.paths.DEV_STUDIO_APP + appId;
      },
      getCollabDescriptorDetails: function(descriptorId) {
          var descriptorUrl = this.getCurrentInstanceUrl() + CollabTaskConstants.paths.COLLAB_DESCRIPTOR + descriptorId;
          var descriptorName = "";
          var descriptorRecord = new GlideRecord(CollabTaskConstants.tables.COLLAB_DESCRIPTOR);
          if (descriptorRecord.get(descriptorId)) {
              descriptorName = descriptorRecord.getDisplayValue("name");
          }

          return {
              descriptorUrl: descriptorUrl,
              descriptorName: descriptorName
          };
      },
      getCurrentInstanceUrl: function(appId) {
          var instanceUrl = gs.getProperty("glide.servlet.uri");

          if (!instanceUrl) {
              return;
          }

          return instanceUrl.replace(this.getTrailingSlashRegex(), "");
      },
      getTrailingSlashRegex: function() {
          return /\/+$/;
      },
      getCollaborationRequestsInScope: function(appId, recordState) {
          var tables = CollabTaskConstants.tables;
          var fields = CollabTaskConstants.fields.collabTask;
          var collabReqUtils = new CollabReqUtils();
          var requests = [];

          var collabTaskRecord = new GlideRecord(tables.COLLABORATION_TASK);
          collabTaskRecord.addQuery(fields.APP_SYS_ID, appId);
          collabTaskRecord.addQuery(fields.STATE, recordState);
          collabTaskRecord.query();

          while (collabTaskRecord.next()) {
              var isInviteeGroup = collabTaskRecord.getValue(fields.IS_INVITEE_GROUP) === "1";

              var collabTasksFieldsList = [
                  fields.IS_INVITEE_GROUP,
                  fields.INVITEE,
                  fields.INVITEE_NAME,
                  fields.INVITEE_EMAIL,
  				fields.INVITEE_SYS_ID,
                  fields.GROUP_INVITEE,
                  fields.GROUP_INVITEE_NAME,
                  fields.GROUP_INVITEE_EMAIL,
  				fields.GROUP_INVITEE_SYS_ID,
                  fields.COLLAB_DESCRIPTOR,
                  fields.COLLAB_DESCRIPTOR_NAME,
  				fields.COLLAB_DESCRIPTOR_SYS_ID
              ];

              var collabTaskRecordInvitee = collabReqUtils.getObjectFromGlideRecord(collabTaskRecord, collabTasksFieldsList);
              collabTaskRecordInvitee[fields.IS_INVITEE_GROUP] = isInviteeGroup;
              requests.push(collabTaskRecordInvitee);
          }

          return requests;
      },
      createCollaborationTaskRecordsInController: function(collabTasks, controllerEnv) {
  		var inputs = {
              url: controllerEnv.getValue('instance_url'),
              credential: controllerEnv.instance_credential.getRefRecord(),
              collaboration_tasks: JSON.stringify(collabTasks)
          };

          var result = sn_fd.FlowAPI.getRunner()
              .action("sn_collab_request.create_collaboration_task_records_in_environment")
              .inForeground()
              .withInputs(inputs)
              .run();

          var outputs = result.getOutputs() || {};
          if (outputs.__action_status__ && outputs.__action_status__.code === 0) { // action ran successfully
  			var collabReqUtils = new CollabReqUtils();
  			return {
  				users: outputs.users.filter(collabReqUtils.objectNotAllNil),
  				groups: outputs.groups.filter(collabReqUtils.objectNotAllNil)
  			};
          } else {
  			var message = outputs.__action_status__ ? outputs.__action_status__.message : gs.getMessage("Something went wrong when creating task records in controller");
  			throw message;
          }
      },
  	getCollaborationTaskRecordsFromController: function(appId, recordState, controllerEnv) {
  		var fields = CollabTaskConstants.fields.collabTask;
  		var collabTasksFieldsList = [
  			fields.IS_INVITEE_GROUP,
  			fields.INVITEE,
  			fields.INVITEE_NAME,
  			fields.INVITEE_EMAIL,
  			fields.INVITEE_SYS_ID,
  			fields.GROUP_INVITEE,
  			fields.GROUP_INVITEE_NAME,
  			fields.GROUP_INVITEE_EMAIL,
  			fields.GROUP_INVITEE_SYS_ID,
  			fields.COLLAB_DESCRIPTOR,
  			fields.COLLAB_DESCRIPTOR_NAME,
  			fields.COLLAB_DESCRIPTOR_SYS_ID
  		];
  		
  		var inputs = {
              url: controllerEnv.getValue('instance_url'),
              credential: controllerEnv.instance_credential.getRefRecord(),
              application_sys_id: appId,
  			collaboration_task_states: recordState,
  			collaboration_task_fields: collabTasksFieldsList.join()
          };

          var result = sn_fd.FlowAPI.getRunner()
              .action("sn_collab_request.get_collaboration_tasks")
              .inForeground()
              .withInputs(inputs)
              .run();

          var outputs = result.getOutputs() || {};

          if (outputs.__action_status__ && outputs.__action_status__.code !== 0) { // action failed
  			var message = outputs.__action_status__ ? outputs.__action_status__.message : gs.getMessage("Something went wrong when fetching task records from controller");
  			return {
  				hasError: true,
  				statusCode: 500,
  				errorMessage: message
  			};
  		}
  		
  		var statusCode = outputs.status_code;
  		
  		if (statusCode !== 200) {
  			return {
  				hasError: true,
  				statusCode: statusCode,
  				errorMessage: outputs.error_message
  			};
  		}
  		
  		var responseBody = JSON.parse(outputs.response_body);
  		var collabTasksInScope = (responseBody || {}).result;
  		
  		return {
  			hasError: false,
  			statusCode: 200,
  			collabTasksInScope: collabTasksInScope.map(function (task) {
  				var isInviteeGroup  = global.JSUtil.toBoolean(task[fields.IS_INVITEE_GROUP]);
  				task[fields.IS_INVITEE_GROUP] = isInviteeGroup;
  				return task;
  			})
  		};
  	}
  };
})();

Sys ID

aaf7634ec3c13010a9f5e548fa40dd5d

Offical Documentation

Official Docs: