Name

sn_hr_core.hr_BulkCaseCreation

Description

Helps in creating HR cases from Users table. This Script include is also used for User Selection Directive

Script

var hr_BulkCaseCreation = Class.create();
hr_BulkCaseCreation.prototype = Object.extendsObject(global.AbstractAjaxProcessor, {
  type: 'hr_BulkCaseCreation',

  getHRCaseCreationDefaultFields: function() {
  	
  	var fields = gs.getProperty("sn_hr_core.hr_case_creation_default_fields", "");
  	if (fields.length == 0)
  		return fields;	
  	else{
  		fields = fields.split(",");
  		var validFields = []; 
  		var invalidFields = [];
  		var gr = new GlideRecord("sn_hr_core_case");
  		for(var i = 0 ; i< fields.length; i++){
  			if(gr.isValidField(fields[i])) {	
  				validFields.push(fields[i]);
  			}
  			else{
  				invalidFields.push(fields[i]);
  			} 
  		}
  		if(invalidFields.length)
  			return gs.addErrorMessage(gs.getMessage("Please change the value in {0} to continue using this template. For now you can use the default template.",invalidFields.toString()));				
  	}
  	return fields.toString();
  },

  getSysIdInGroups: function(groupsSysid, isCallFromListView) {
  	var groupMembers = [];
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return groupMembers;
  	var groups = groupsSysid.split(',');
  	var grGroup = new GlideRecord('sys_user_grmember');
  	grGroup.addEncodedQuery('group.sys_idIN' + groups.join());
  	if (gs.getProperty("sn_hr_core.hideUserSelectionCriteriaCount", true) && (isCallFromListView != true))
  		grGroup.setLimit(parseInt(gs.getProperty('sn_hr_core.userSelectionCriteriaCountLimit', 5000)));
  	grGroup.query();
  	while (grGroup.next())
  		groupMembers.push(grGroup.user.toString());
  	
  	return groupMembers;
  },

  getSysIdInRoles: function(rolesSysids, isCallFromListView) {
  	var usersWithRoles = [];
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return usersWithRoles;
  	var roles = rolesSysids.split(',');
  	var grRole = new GlideRecord('sys_user_has_role');
  	grRole.addEncodedQuery('state=active^role.sys_idIN' + roles.join());
  	if (gs.getProperty("sn_hr_core.hideUserSelectionCriteriaCount", true) && (isCallFromListView != true))
  		grRole.setLimit(parseInt(gs.getProperty('sn_hr_core.userSelectionCriteriaCountLimit', 5000)));
  	grRole.query();
  	while (grRole.next())
  		usersWithRoles.push(grRole.user.toString());
  	
  	return usersWithRoles;
  },

  //Return the unique list of users from different HR criteria
  getUniqueUsersForMultipleHRCriteria: function(givenhrCriteriaList) {
  	var hrCriteriaList = givenhrCriteriaList.split(",");
  	var returnQuery = {
  		useDynamicQuery: false,
  		dynamicQuery: "",
  		resQuery: "",
  		shouldHideCount: false
  	};

  	for (var i = 0; i < hrCriteriaList.length; i++)
  		returnQuery = this.getUsersForHRCriteriaFromUserSelection(hrCriteriaList[i], returnQuery);
  	
  	return returnQuery;
  },

  /* Modify @param returnQuery Object to describe users that match a given criteria
   *
   * @param hrCriteriaId String sys_id of an HR Criteria
   * @param returnQuery Object Describing users that match HR Criteria
   * @return Object Modified @param returnQuery object containing a query describing users that match @param hrCriteriaId
   */
  getUsersForHRCriteriaFromUserSelection: function(hrCriteriaId, returnQuery) {
  	var childReturnQuery = {
  		useDynamicQuery: false,
  		dynamicQuery: "",
  		resQuery: "",
  		shouldHideCount: false
  	};

  	var m2mConditionCriteriaGr = new GlideRecord("sn_hr_core_m2m_condition_criteria");
  	m2mConditionCriteriaGr.addQuery('hr_criteria', hrCriteriaId);
  	m2mConditionCriteriaGr.addQuery('hr_criteria.active', true);
  	m2mConditionCriteriaGr.addQuery('hr_condition.active', true);
  	m2mConditionCriteriaGr.addNotNullQuery("hr_condition.table");
  	m2mConditionCriteriaGr.addNotNullQuery('hr_condition.condition');
  	m2mConditionCriteriaGr.query();
  	if (!m2mConditionCriteriaGr.hasNext())		
  		childReturnQuery.resQuery = "sys_idISEMPTY";// No valid conditions for this criteria

  	while (m2mConditionCriteriaGr.next()) {
  		var hrConditionId = m2mConditionCriteriaGr.getValue("hr_condition");
  		var hrConditionGr = new GlideRecord("sn_hr_core_condition");
  		if (hrConditionGr.get(hrConditionId)) {
  			if (hrConditionGr.table != "sys_user") {
  				childReturnQuery.useDynamicQuery = true;
  				if (hrConditionGr.user_column.toString()) {
  					childReturnQuery.shouldHideCount = childReturnQuery.shouldHideCount || this.getUsersSysidsCountFromCriteriaConditionMatching(hrConditionId);
  					var dynamicQueryResult = "sys_idINjavascript: new sn_hr_core.hr_BulkCaseCreation().getUsersSysidsFromCriteriaConditionMatching('" + hrConditionId + "',false);";
  					childReturnQuery.dynamicQuery = childReturnQuery.dynamicQuery == "" ? dynamicQueryResult : childReturnQuery.dynamicQuery + '^' + dynamicQueryResult;
  				} else
  					childReturnQuery.dynamicQuery = "sys_idINEMPTY";
  				
  			} else if (hrConditionGr.table == "sys_user") {
  				var cond = hrConditionGr.getValue("condition");
  				cond = cond.replaceAll("^EQ", "");
  				if (cond != "") {
  					if (childReturnQuery.useDynamicQuery)
  						childReturnQuery.dynamicQuery = childReturnQuery.dynamicQuery == "" ? cond : childReturnQuery.dynamicQuery + "^" + cond;
  					else
  						childReturnQuery.resQuery = childReturnQuery.resQuery == "" ? cond : childReturnQuery.resQuery + '^' + cond;
  				}
  			}
  		}
  	}

  	returnQuery.useDynamicQuery = returnQuery.useDynamicQuery || childReturnQuery.useDynamicQuery;
  	if (childReturnQuery.useDynamicQuery)
  		returnQuery.dynamicQuery = returnQuery.dynamicQuery == "" ? childReturnQuery.dynamicQuery : returnQuery.dynamicQuery + "^NQ" + childReturnQuery.dynamicQuery;

  	returnQuery.resQuery = returnQuery.resQuery == "" ? childReturnQuery.resQuery : returnQuery.resQuery + "^NQ" + childReturnQuery.resQuery;
  	returnQuery.shouldHideCount = returnQuery.shouldHideCount || childReturnQuery.shouldHideCount;
  	return returnQuery;
  },

  getUsersSysidsFromCriteriaConditionMatching: function(hrCond, isCallFromListView) {
  	var returnSysid = [];
  	var grSnHrCoreCondition = new GlideRecord("sn_hr_core_condition");
  	if (grSnHrCoreCondition.get(hrCond)) {
  		var curGR = new GlideRecord(grSnHrCoreCondition.table);
  		curGR.addEncodedQuery(grSnHrCoreCondition.condition);
  		if (gs.getProperty("sn_hr_core.hideUserSelectionCriteriaCount", true) && (isCallFromListView != true))
  			curGR.setLimit(parseInt(gs.getProperty('sn_hr_core.userSelectionCriteriaCountLimit', 5000)));
  		curGR.query();
  		while (curGR.next()) {
  			if (grSnHrCoreCondition.user_column != null && grSnHrCoreCondition.user_column != "") {
  				var cur = curGR.getValue(grSnHrCoreCondition.user_column);
  				returnSysid.push(cur);
  			}
  		}
  	}
  	if (returnSysid.length > 0)
  		return returnSysid;
  	else
  		return "EMPTY";
  },

  getUsersSysidsCountFromCriteriaConditionMatching: function(hrCond) {
  	var returnSysid = [];
  	var grSnHrCoreCondition = new GlideRecord("sn_hr_core_condition");
  	if (grSnHrCoreCondition.get(hrCond)) {
  		var curGR = new GlideRecord(grSnHrCoreCondition.table);
  		curGR.addEncodedQuery(grSnHrCoreCondition.condition);
  		curGR.query();
  		if (curGR.getRowCount() >= parseInt(gs.getProperty('sn_hr_core.userSelectionCriteriaCountLimit', 5000)) &&
  			gs.getProperty("sn_hr_core.hideUserSelectionCriteriaCount", true))
  			return true;
  		else
  			return false;
  	}
  	return false;
  },

  getHRCriteriaDisplayValue: function(sysparm_hr_criteria_sysids) {
  	var resultHRCriteria = [];
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return resultHRCriteria;
  	var givenHRCriteria = sysparm_hr_criteria_sysids;
  	var getHRCriteria = new GlideRecord("sn_hr_core_criteria");
  	getHRCriteria.addEncodedQuery('sys_idIN' + givenHRCriteria);
  	getHRCriteria.query();
  	while (getHRCriteria.next()) {
  		var resName = getHRCriteria.getDisplayValue('name');
  		var resid = getHRCriteria.getValue('sys_id');
  		resultHRCriteria.push({
  			name: resName,
  			value: resid
  		});
  	}
  	return JSON.stringify(resultHRCriteria);
  },

  getEncodedQueryForCriteria: function(userSelectionQuery, userSelectionType) {
  	var sendEncodedCriteria = {
  		encodedCriteria: "",
  		shouldHideCount: false,
  		hrCriteria: {}
  	};
  	if (userSelectionType == "user_criteria") {
  		var resultUserCriteriaValue = new sn_hr_core.hr_UserCriteriaEvaluation().getAllUsersForUserCriteria(userSelectionQuery);
  		sendEncodedCriteria.encodedCriteria = resultUserCriteriaValue.resultQuery;
  		sendEncodedCriteria.shouldHideCount = resultUserCriteriaValue.shouldHideCount;
  	} else if (userSelectionType == "hr_criteria") {
  		var resultHrCriteriaValue = this.getUniqueUsersForMultipleHRCriteria(userSelectionQuery);
  		sendEncodedCriteria.encodedCriteria = resultHrCriteriaValue.resQuery;
  		sendEncodedCriteria.shouldHideCount = resultHrCriteriaValue.shouldHideCount;
  		sendEncodedCriteria.hrCriteria = resultHrCriteriaValue;
  	} else
  		sendEncodedCriteria.encodedCriteria = userSelectionQuery;
  	return sendEncodedCriteria;
  },

  getUsersSysidsFromCriteriaCondition: function(table, query, user_column) {
  	var returnSysid = [];
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return returnSysid;
  	var curGR = new GlideRecord(table);
  	curGR.addEncodedQuery(query);
  	curGR.query();
  	while (curGR.next()) {
  		if (user_column != null && user_column != "") {
  			var cur = curGR.getValue(user_column);
  			returnSysid.push(cur);
  		}
  	}
  	return returnSysid;
  },

  getUserCriteriaDisplayValue: function(sysparm_user_criteria_sysids) {
  	var resultUserCriteria = [];
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return resultUserCriteria;
  	var givenUserCriteria = sysparm_user_criteria_sysids;
  	var getUserCriteria = new GlideRecord("user_criteria");
  	getUserCriteria.addEncodedQuery('sys_idIN' + givenUserCriteria);
  	getUserCriteria.query();
  	while (getUserCriteria.next()) {
  		var resName = getUserCriteria.getDisplayValue('name');
  		var resid = getUserCriteria.getValue('sys_id');
  		resultUserCriteria.push({
  			name: resName,
  			value: resid
  		});
  	}
  	return JSON.stringify(resultUserCriteria);
  },

  //call to userSelectionStackPop from GlideAjax
  callUserSelectionStackPop: function() {
  	if ((gs.action.getGlideURI().toString().indexOf('stack') == -1) && (gs.action.getGlideURI().toString().indexOf('hr_userselection_view') != -1)) {
  		var gsecurity = new global.HRSecurityUtilsAjax();
  		gsecurity.userSelectionStackPop();
  		return "Success";
  	}
  	return "Failed to Clean Stack";
  },

  calculateEncodedQuery: function(encodedQuery, genOption) {
  	var resultencodedQueryURI = {
  		encodedQueryURI: "sys_idISEMPTY",
  		shouldHideCount: false
  	};

  	var resultantEncodedQuery = this.getEncodedQueryForCriteria(encodedQuery, genOption);

  	if (genOption == "hr_criteria") {
  		var resultantEncodedQueryAfter = resultantEncodedQuery.hrCriteria;
  		if (resultantEncodedQueryAfter.useDynamicQuery && resultantEncodedQueryAfter.resQuery != "")
  			resultencodedQueryURI.encodedQueryURI = resultantEncodedQueryAfter.dynamicQuery + "^NQ" + resultantEncodedQueryAfter.resQuery;
  		else if (resultantEncodedQueryAfter.useDynamicQuery)
  			resultencodedQueryURI.encodedQueryURI = resultantEncodedQueryAfter.dynamicQuery;
  		else
  			resultencodedQueryURI.encodedQueryURI = resultantEncodedQueryAfter.resQuery;
  	} else
  		resultencodedQueryURI.encodedQueryURI = resultantEncodedQuery.encodedCriteria;

  	resultencodedQueryURI.shouldHideCount = resultantEncodedQuery.shouldHideCount;

  	return resultencodedQueryURI;
  },

  getUserSelectionEncodedQuery: function(encodedQuery, genOption) {
  	var resultantEncodedValue = this.calculateEncodedQuery(encodedQuery, genOption);
  	if (genOption == "user_criteria")
  		resultantEncodedValue.encodedQueryURI = resultantEncodedValue.encodedQueryURI.replaceAll(',false)', ',true)');
  	else if (genOption == "hr_criteria")
  		resultantEncodedValue.encodedQueryURI = resultantEncodedValue.encodedQueryURI.replaceAll(',false);', ',true)');
  	return resultantEncodedValue.encodedQueryURI;
  },

  /**
   * Calculates the count of profiles/users for given encodedQuery. Used for AJAX request
   */
  getUsersCount: function(encodedQuery, countProfile, genOption) {
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return;
  	var queryWithCount = {};
  	queryWithCount.count = -1;
  	queryWithCount.query = encodedQuery;
  	queryWithCount.url = "";
  	queryWithCount.hideCount = false;

  	if (gs.hasRole("sn_hr_core.case_writer") || gs.hasRole("sn_hr_core.content_reader")) {
  		var ga;
  		if ((!countProfile) && (genOption != "upload_file"))
  			ga = new GlideAggregate("sys_user");
  		else if (genOption == "upload_file")
  			ga = new GlideAggregate("sn_hr_core_bulk_case_creation_data");
  		else
  			ga = new GlideAggregate("sn_hr_core_profile");

  		if (encodedQuery) {
  			if (genOption != "upload_file") {
  				var returnEncodedQuery = this.calculateEncodedQuery(encodedQuery, genOption);
  				gs.info(returnEncodedQuery.shouldHideCount + 'returnEncodedQuery.shouldHideCount');
  				if (returnEncodedQuery.shouldHideCount)
  					queryWithCount.hideCount = true;
  				ga.addEncodedQuery(returnEncodedQuery.encodedQueryURI);
  				if (genOption == "user_criteria") {
  					returnEncodedQuery.encodedQueryURI = returnEncodedQuery.encodedQueryURI.replaceAll(',false)', ',true)');
  					queryWithCount.url = "/sys_user_list.do?v=1&sysparm_query=" + returnEncodedQuery.encodedQueryURI + "&sysparm_preview=true";
  				} else if (genOption == "hr_criteria") {
  					returnEncodedQuery.encodedQueryURI = returnEncodedQuery.encodedQueryURI.replaceAll(',false);', ',true)');
  					queryWithCount.url = "/sys_user_list.do?v=1&sysparm_query=" + returnEncodedQuery.encodedQueryURI + "&sysparm_preview=true";
  				}
  			} else if (genOption == "upload_file") {
  				ga.addEncodedQuery("bulk_case_creation_run.sys_id=" + encodedQuery + "^query_result=Found^userISNOTEMPTY");
  				queryWithCount.url = "/sn_hr_core_bulk_case_creation_data_list.do?v=1&sysparm_query=bulk_case_creation_run.sys_id=" + encodedQuery + "^query_result=Found^userISNOTEMPTY&sysparm_preview=true";
  			}
  		} else
  			ga.addEncodedQuery(!countProfile ? "active=false^active=true" : "numberISEMPTY");

  		ga.addAggregate('COUNT');
  		ga.query();

  		var users_query;
  		if (ga.next())
  			users_query = ga.getAggregate('COUNT');
  		queryWithCount.count = users_query;
  	}

  	return queryWithCount;
  },
  
  /**
   * Calculate the the count of profiles/users for a given encodedQuery and HR Service criteria.
   */
  getServiceUsersCount: function(queryTableParm, encodedQueryParm, hrServiceSysIdParm, hrSelectionType) {
  	if (!gs.hasRole("sn_hr_core.case_writer"))
  		return 0;
  	
  	var queryTable = queryTableParm;
  	var encodedQuery = encodedQueryParm;
  	var hrServiceSysId = hrServiceSysIdParm;
  	var hrSelectedType = hrSelectionType;

  	// Get all criteria on the HR Service
  	var serviceCriteria;
  	var serviceGr = new GlideRecord("sn_hr_core_service");
  	if (serviceGr.get(hrServiceSysId))
  		serviceCriteria = serviceGr.getValue("hr_criteria");
  	else
  		return 0;

  	// Query table with passed in encoded query
  	var userGr = new GlideRecord("sys_user");
  	if (encodedQuery) {
  		if (hrSelectionType != "upload_file" && hrSelectionType != "hr_profile") {
  			var returnEncodedQuery = this.getUserSelectionEncodedQuery(encodedQuery, hrSelectionType);
  			userGr.addEncodedQuery(returnEncodedQuery);
  		} else if (hrSelectionType == "upload_file" || hrSelectionType == "hr_profile") {
  			var resultUserSysid = [];

  			if (hrSelectionType == "upload_file")
  				resultUserSysid = this.getUsersSysidsFromCriteriaCondition("sn_hr_core_bulk_case_creation_data", "bulk_case_creation_run.sys_id=" + encodedQuery + "^query_result=Found^userISNOTEMPTY", "user");
  			else if (hrSelectionType == "hr_profile")
  				resultUserSysid = this.getUsersSysidsFromCriteriaCondition("sn_hr_core_profile", encodedQuery, "user");

  			if (resultUserSysid.length > 0)
  				userGr.addEncodedQuery("sys_idIN" + resultUserSysid.join());
  			else
  				userGr.addEncodedQuery("sys_idINEMPTY");
  		}
  	} else
  		userGr.addQuery("sys_id", null);
  	
  	var firstQueryUsers = [];
  	userGr.addActiveQuery();
  	userGr.query();
  	while (userGr.next())
  		firstQueryUsers.push(userGr.getUniqueValue());
  	
  	var userArr = [];
  	if (serviceCriteria) {
  		// If HR Service have criteria
  		var hrCriteria = new sn_hr_core.hr_Criteria();
  		var criteriaList = serviceCriteria.split(',');
  		
  		userArr = firstQueryUsers.filter(function(user) {
  			for (var i = 0; i < criteriaList.length; i++) {
  				if (hrCriteria.evaluateById(criteriaList[i], user))
  					return true;
  			}
  			return false;
  		});
  	} else
  		userArr = firstQueryUsers;
  	
  	return userArr.length;
  },

  //check current user has content reader
  checkCurrentUser: function() {
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return;
  	var currentUser = gs.getUserID();
  	var hasManageContentRole = false;
  	var grSysUserHasRole = new GlideRecord('sys_user_has_role');
  	grSysUserHasRole.addQuery('user', currentUser);
  	grSysUserHasRole.addQuery('role.name', 'sn_hr_core.content_reader');
  	grSysUserHasRole.query();
  	hasManageContentRole = grSysUserHasRole.hasNext();
  	return hasManageContentRole;
  },

  getHRCriteriaQuery: function() {
  	if (!gs.hasRole('sn_hr_core.content_reader') && !gs.hasRole('sn_hr_core.case_writer'))
  		return;
  	var userList = [];
  	if (gs.hasRole("sn_hr_core.admin")) {
  		var hrCriteria = this.getParameter('sysparm_hr_criteria');
  		var HRCriteria = new hr_Criteria();
  		userList = HRCriteria.getUsersForHRCriteria(hrCriteria);
  	}

  	return JSON.stringify(userList);
  },

  /**
   * Creates HR cases for sys_user ids from encoded query. Called from CreateCasesAJAXProcessor Script Include
   */
  createCasesFromQuery: function(sysId, encodedQuery, defaultValues, haveParent, countProfile, hrSelectionType) {
  	var bulkCaseRequest = {};
  	this._changeStatus(sysId);
  	if (!gs.hasRole("sn_hr_core.case_writer"))
  		return;

  	defaultValues = JSON.parse(defaultValues);

  	var insertedCount = 0;
  	var parent = null;
  	if (haveParent) {
  		// Retrieve person who created the bulk request (and set it as 'subject person' of the parent case)
  		var currUser = '';
  		var grBulkRequest = new GlideRecord('sn_hr_core_bulk_case_request');
  		if(grBulkRequest.get(sysId)) 
  			currUser = grBulkRequest.getValue('sys_created_by');
  			
  		var userGr = new GlideRecord('sys_user');
  		userGr.addQuery('user_name', currUser);
  		userGr.setLimit(1);
  		userGr.query();

  		if (userGr.next()) {
  			parent = this.userToCaseFromSysid(userGr, defaultValues, null, true, sysId);
  			if (!gs.nil(parent))
  				this._updateParentNumber(sysId, parent);
  		}
  	}
  	// Query for HR Service
  	var hrServiceGr = new GlideRecord("sn_hr_core_service");
  	hrServiceGr.get(defaultValues.hr_service);
  	var hrServiceCriteria = hrServiceGr.getValue("hr_criteria") || "";

  	var casesCount;

  	var grSysUser = new GlideRecord("sys_user");

  	if (hrSelectionType != "upload_file" && hrSelectionType != "hr_profile") {
  		var returnEncodedQuery = this.getUserSelectionEncodedQuery(encodedQuery, hrSelectionType);
  		grSysUser.addEncodedQuery(returnEncodedQuery);
  	} else if (hrSelectionType == "upload_file" || hrSelectionType == "hr_profile") {
  		var resultUserSysid = [];

  		if (hrSelectionType == "upload_file")
  			resultUserSysid = this.getUsersSysidsFromCriteriaCondition("sn_hr_core_bulk_case_creation_data", "bulk_case_creation_run.sys_id=" + encodedQuery + "^query_result=Found^userISNOTEMPTY", "user");
  		else if (hrSelectionType == "hr_profile")
  			resultUserSysid = this.getUsersSysidsFromCriteriaCondition("sn_hr_core_profile", encodedQuery, "user");

  		if (resultUserSysid.length > 0)
  			grSysUser.addEncodedQuery("sys_idIN" + resultUserSysid.join());
  		else
  			grSysUser.addEncodedQuery("sys_idINEMPTY");
  	}
  	
  	grSysUser.addActiveQuery();
  	grSysUser.query();
  	var firstQueryUsers = [];
  	while (grSysUser.next()) {
  		firstQueryUsers.push(grSysUser.getUniqueValue());
  	}
  	var userArr = [];
  	if (hrServiceCriteria) {
  		userArr = new sn_hr_core.hr_Criteria().getUsersForHRCriteria(hrServiceCriteria);
  		userArr = userArr.filter(function (n) {
  			return firstQueryUsers.indexOf(n) !== -1;
  		});
  	} else {
  		userArr = firstQueryUsers;
  	}
  	casesCount = userArr.length;

  	for (var i = 0; i < userArr.length; ++i) {
  		grSysUser = new GlideRecord('sys_user');
  		grSysUser.get(userArr[i]);
  		var newCase = this.userToCaseFromSysid(grSysUser, defaultValues, parent, false, sysId);
  		if (!gs.nil(newCase))
  			insertedCount++;

  		if (insertedCount > 0 && insertedCount % 100 == 0)
  			this._updateCaseCount(insertedCount, sysId);
  	}
  	this._updateCaseCount(insertedCount, sysId);

  	//URL as a replacement for sys_idIN[sysids list]
  	//Generates encoded query based on created time interval and user who created
  	var hrService = new GlideRecord('sn_hr_core_service');
  	hrService.addQuery('sys_id', defaultValues.hr_service);
  	hrService.query();
  	var url;
  	if (hrService.next())
  		url = hrService.service_table+ "_list.do?sysparm_query=sys_created_by="+gs.getUserName();
  	this._updateEndStatus(sysId);

  	bulkCaseRequest.url = url;
  	return bulkCaseRequest;
  },

  _changeStatus: function(sysId) {
  	var grStatus = new GlideRecord('sn_hr_core_bulk_case_request');
  	grStatus.addQuery('sys_id', sysId);
  	grStatus.query();
  	if (grStatus.next()) {
  		grStatus.status = 'in_progress';
  		grStatus.start_time = new GlideDateTime();
  		grStatus.update();
  	}
  },

  _updateCaseCount: function(caseCount, sysId) {
  	var grCaseCount = new GlideRecord('sn_hr_core_bulk_case_request');
  	if (grCaseCount.get(sysId)) {
  		grCaseCount.cases_created_count = caseCount;
  		grCaseCount.update();
  	}
  },

  _updateParentNumber: function(sysId, parentNumber) {
  	var grParent = new GlideRecord('sn_hr_core_bulk_case_request');
  	grParent.addQuery('sys_id', sysId);
  	grParent.query();
  	if (grParent.next()) {
  		grParent.parent_case_number = parentNumber;
  		grParent.update();
  	}
  },

  _updateEndStatus: function(sysId) {
  	var grStatus = new GlideRecord('sn_hr_core_bulk_case_request');
  	grStatus.addQuery('sys_id', sysId);
  	grStatus.query();
  	if (grStatus.next()) {
  		grStatus.status = 'completed';
  		grStatus.completed_time = new GlideDateTime();
  		grStatus.update();
  	}
  },

  insertCasesFromQuery: function(encodedQuery, defaultValues, haveParent, countProfile, hrSelectionType) {
  	if (!gs.hasRole("sn_hr_core.case_writer"))
  		return;

  	var dfValues = JSON.parse(defaultValues);
  	if (dfValues.opened_for == undefined)
  		dfValues.opened_for = '';
  	var grCaseReq = new GlideRecord('sn_hr_core_bulk_case_request');
  	grCaseReq.initialize();
  	grCaseReq.query();
  	grCaseReq.user_selection_query = encodedQuery;
  	grCaseReq.default_values = defaultValues;
  	grCaseReq.user_selection_type = hrSelectionType;
  	grCaseReq.has_parent = haveParent;
  	grCaseReq.selected_user_count = countProfile;
  	grCaseReq.requested_time = new GlideDateTime();
  	grCaseReq.hr_service = dfValues.hr_service;
  	grCaseReq.opened_for = dfValues.opened_for;
  	var grReturn = {};
  	grReturn.sysId = grCaseReq.insert().toString();
  	grReturn.number = grCaseReq.number.toString();

  	return JSON.stringify(grReturn);
  },

  /**
   * Helper method to create individual HR case for each sys_user id
   * user_sysid -- sys_user sys_id for whom a profile creation must be attempted
   * caseInfoObj -- This object has data to be inserted in the profile row other than those available from sys_user row
   * returns sys_id of the new HR case created
   */
  userToCaseFromSysid: function(user_gr, caseInfoObj, parent, isParent, sysId) {
  	if (!gs.hasRole("sn_hr_core.case_writer"))
  		return;

  	var curService = caseInfoObj.hr_service;
  	var hrService = new GlideRecord('sn_hr_core_service');
  	hrService.addQuery('sys_id', curService);
  	hrService.query();

  	if (hrService.next()) {
  		var grHrCase = new GlideRecord(hrService.service_table);
  		grHrCase.initialize();
  		grHrCase.opened_for = user_gr.sys_id;
  		grHrCase.subject_person = user_gr.sys_id;
  		grHrCase.hr_service = hrService.sys_id.toString();
  		grHrCase.topic_detail = hrService.topic_detail;
  		grHrCase.topic_category = hrService.topic_detail.topic_category;
  		grHrCase.template = hrService.template;
  		grHrCase.state = hr_Constants.CASE_QUALIFIED ;
  		if(sysId)
  			grHrCase.bulk_case_request = sysId;

  		if (!gs.nil(parent))
  			grHrCase.parent = parent;

  		for (var key in caseInfoObj)
  			grHrCase.setValue(key, caseInfoObj[key]);

  		var openedFor = grHrCase.opened_for;
  		
  		// if the subject person or opened for is a VIP, set the priority
  		if (openedFor.vip|| user_gr.vip)
  			grHrCase.priority = gs.getProperty('sn_hr_core.hr_vip_default_priority',1);

  		if (isParent) {
  			var grSnHrCoreService = new GlideRecord("sn_hr_core_service");
  			grSnHrCoreService.addQuery("value", "bulk_parent_case");
  			grSnHrCoreService.query();
  			if (grSnHrCoreService.next()) {
  				grHrCase.hr_service = grSnHrCoreService.sys_id;
  				grHrCase.topic_detail = grSnHrCoreService.topic_detail;
  				grHrCase.topic_category = grSnHrCoreService.topic_detail.topic_category;
  				grHrCase.template = grSnHrCoreService.template;
  				var temp = grSnHrCoreService.template;
  				var grSnHrCoreTemplate = new GlideRecord("sn_hr_core_template");
  				if (grSnHrCoreTemplate.get(temp)) {
  					var s = grSnHrCoreTemplate.template;
  					var start = s.indexOf("short_description");
  					if (start != -1) {
  						var end = start + 17 + 1;
  						while (s.charAt(end) != "^") end++;

  						grHrCase.short_description = s.substring(start + 17 + 1, end);
  					}
  				}

  			}
  		}

  		return grHrCase.insert();
  	}
  	return null;
  }
});

Sys ID

4cdff9df5b312200502f6ede91f91ac6

Offical Documentation

Official Docs: