Name

global.CSManagementUtils

Description

Helper functions for Customer Service Management

Script

var CSManagementUtils = Class.create();
CSManagementUtils.prototype = Object.extendsObject(AbstractAjaxProcessor, {
  generateCreateCaseHiddenValue: function(company) {
  	company = company || gs.getUser().getCompanyID();
  	var value = "company-" + company;
  	var gr = new GlideRecord('customer_account');
  	if (gr.get(company)) {
  		value += "#isCustomer-" + gr.customer;
  		value += "#isPartner-" + gr.partner;

  		var count = new GlideAggregate('customer_account');
  		count.addQuery('account_path', 'STARTSWITH', gr.account_path + '/');
  		count.addAggregate('COUNT');
  		count.setWorkflow(false);
  		count.query();
  		if (count.next())
  			value += "#hasSubAccounts-" + (count.getAggregate('COUNT') > 0);

  		var ar = new GlideAggregate('sn_customerservice_contact_relationship');
  		ar.addQuery('contact', gs.getUserID());
  		ar.addAggregate('COUNT');
  		ar.setWorkflow(false);
  		ar.query();
  		if (ar.next())
  			value += "#hasAccountContactRelation-"  + (ar.getAggregate('COUNT') > 0);
  	}
// 		gs.info("generateCreateCaseHiddenValue -->" + value);
  	return value;
  },

// 	isEntitlementValid:function(entitlement_sysId){
// 		var valid = false;
// 		if(entitlement_sysId){
// 			var entitlement = new GlideRecord("service_entitlement");
// 			if(entitlement.get(entitlement_sysId) && entitlement.state == 1){
// 				var startDate = new GlideDateTime(entitlement.start_date);
// 				var endDate = new GlideDateTime(entitlement.end_date);
// 				var currentDate = new GlideDateTime();
// 				if(currentDate.compareTo(startDate)==1 && currentDate.compareTo(endDate)== -1){
// 					if(entitlement.getValue("per_case")==1){
// 						valid = entitlement.getValue("remaining_units") > 0 ? true : false;
// 					}else{
// 						valid = true;
// 					}
// 				}
// 			}
// 			return valid;
// 		}else{
// 			return valid;
// 		}
// 	},

  getEntitlements: function(account, product, channel){

  	var  cus = current.consumer;
  	var  com = account || current.account;
  	var  pro = product || current.product;
  	channel = channel || current.contact_type;
  	var query = ' ';
  	var household = current.household;


  	var entitlements = new GlideRecord("service_entitlement");
  	var	channelSysId = this.getChoiceSysIdForChannel(channel);

  	var	entqc = entitlements.addNullQuery('channel');
  	if (!gs.nil(channelSysId))
  		entqc.addOrCondition("channel", "CONTAINS", channelSysId);

  	var isQuerySet = false;
  	var qc = "";
  	if(!gs.nil(com)){
  		qc = entitlements.addNullQuery("consumer", 'ISEMPTY');
  		qc = qc.addCondition("account", com);
  		isQuerySet = true;
  	} else if(!gs.nil(cus) || !gs.nil(household)){

  		qc = entitlements.addNullQuery("account", 'ISEMPTY');
  		if (!gs.nil(cus)) {
  			qc = qc.addCondition("consumer", cus);
  		}

  		if (!gs.nil(household)) {
  			qc = qc.addCondition("household", household);
  		}
  		isQuerySet = true;
  	}

  	if(!gs.nil(pro)){
  		if(isQuerySet)
  			qc.addOrCondition("product", pro);
  		else{
  			entitlements.addQuery("product", pro);
  			isQuerySet = true;
  		}
  	}
  	if(isQuerySet){
  		entitlements.query();
  		while(entitlements.next()){
  			if (query.length > 0)
  				query += ', ' + entitlements.sys_id;
  			else
  				query = entitlements.sys_id;
  		}
  	}

  	if(!gs.nil(current.contract)){
  		entitlements = new GlideRecord("service_entitlement");
  		entqc = entitlements.addNullQuery('channel');
  		if (!gs.nil(channelSysId))
  			entqc.addOrCondition("channel", "CONTAINS", channelSysId);

  		entitlements.addQuery("contract", current.contract);
  		entitlements.query();
  		while(entitlements.next()){

  			if (query.length > 0)
  				query += ', ' + entitlements.sys_id;
  			else
  				query = entitlements.sys_id;

  		}
  	}

  	return 'sys_idIN' + query;
  },



  getEntitlement: function(){

  	var entitlement = new GlideRecord("service_entitlement");
  	if(!gs.nil(current.contract)){
  		entitlement.addQuery("contract",current.contract);
  		entitlement.query();
  		if(entitlement.getRowCount() == 1 ){
  			entitlement.next();
  			return entitlement.getValue("sys_id");
  		}else if(entitlement.getRowCount() > 1)
  		return '';

  	}

  	if(!gs.nil(current.product)){
  		entitlement = new GlideRecord("service_entitlement");
  		entitlement.addQuery("product",current.product);
  		entitlement.query();
  		if(entitlement.getRowCount() == 1 ){
  			entitlement.next();
  			return entitlement.getValue("sys_id");
  		}else if(entitlement.getRowCount() > 1)
  		return '';
  	}

  	if(!gs.nil(current.account)){
  		entitlement = new GlideRecord("service_entitlement");
  		entitlement.addQuery("account",current.account);
  		entitlement.query();
  		if(entitlement.getRowCount() == 1 ){
  			entitlement.next();
  			return entitlement.getValue("sys_id");
  		}else if(entitlement.getRowCount() > 1)
  		return '';
  	}

  	return '';


  },

  _containsChannel : function(eGrType,currGrChannel) {
  	var eGrChannels = eGrType.split(',');

  	for(var i =0;i < eGrChannels.length;i++)
  		if(eGrChannels[i] == currGrChannel)
  			return true;
  	return false;
  },
  _isValidChannel : function(eGrType,currGrChannel) {

  	return (eGrType && this._containsChannel(eGrType,currGrChannel)) || !eGrType ;
  },
  _isValidField : function(caseElement,entElement) {
  	return gs.nil(entElement) || (caseElement == entElement);

  },
  _isValidEntitlement : function(current,entitlementGr,fieldList) {
  	var valid = true;

  	for(var i =0; i < fieldList.length; i++)
  		if(current.isValidField(fieldList[i]) && entitlementGr.isValidField(fieldList[i]))
  			valid = valid && this._isValidField(current.getValue(fieldList[i]),entitlementGr.getValue(fieldList[i]));

  	return valid;
  },

  isServiceOrgPluginActive: function() {
  	if(pm.isActive("com.snc.service_organization"))
  		return true;
  	return false;
  },

  isPSSPluginActive: function() {
  	if(pm.isActive("com.sn_pss_core"))
  		return true;
  	return false;
  },

  getFirstEntitlement: function(current){


  	//Relative precidence order/weightage for each field contributing to entitlement selection
  	var weightMap = {
  		account : 1,
  		consumer : 1,
  		product : 2,
  		asset : 3,
  		sold_product : 3,
  		install_base_item : 3,
  		contract : 4
  	};

  	var maxScore = 0;
  	var score = 0;
  	var selectedEntitlement = '';
  	var caseChannelSysId = this.getChoiceSysIdForChannel(current.getValue('contact_type'));
  	var installBaseItem = '';

  	if(pm.isActive('com.snc.install_base')){
  		if(!gs.nil(current.getValue('sold_product')) && gs.nil(current.getValue('product')))
  			current.product = current.sold_product.product;

  		var affectedInstallBaseGr = new GlideRecord('sn_install_base_m2m_affected_install_base');

  			affectedInstallBaseGr.addQuery('csm_case',current.getValue('sys_id'));
  			affectedInstallBaseGr.query();
  			if(affectedInstallBaseGr.getRowCount() == 1) {
  				affectedInstallBaseGr.next();
  				if(affectedInstallBaseGr.install_base_item.getRefRecord().canRead())
  					installBaseItem = affectedInstallBaseGr.getValue('install_base_item');
  			}
  	}

  	var entitlementGr = new GlideRecord('service_entitlement');
  	entitlementGr.addActiveQuery();

  	if (this.isPSSPluginActive()) {
  		entitlementGr.addQuery("advanced", false);
  	}

  	if(gs.nil(current.getValue('contract')))
  		current.contract = this.getContractForAccount();

  	if(!gs.nil(current.account))
  		entitlementGr.addQuery('account',current.account);
  	else if(!gs.nil(current.consumer))
  		entitlementGr.addQuery('consumer',current.consumer);
  	else
  		return '';

  	entitlementGr.query();
  	while(entitlementGr.next()) {

  		var validEntitlement = this._isValidEntitlement(current,entitlementGr,Object.keys(weightMap)) &&
  			this._isValidField(installBaseItem,entitlementGr.getValue('install_base_item'));

  		//check if the entitlement is meant for a different channel type or bypass if channel type is not defined for entitlement
  		if(validEntitlement && this._isValidChannel(entitlementGr.getValue('channel'),caseChannelSysId)){

  			//check if field value exists or is null in both table records
  			var sameContract = current.getValue('contract') == entitlementGr.getValue('contract');
  			var sameAsset = current.getValue('asset') == entitlementGr.getValue('asset');
  			var sameSoldProduct = current.getValue('sold_product') == entitlementGr.getValue('sold_product');
  			var sameInstallBaseItem = installBaseItem == entitlementGr.getValue('install_base_item');
  			var sameProduct = current.getValue('product') == entitlementGr.getValue('product');
  			var sameAccount = current.getValue('account') == entitlementGr.getValue('account');
  			var sameConsumer = current.getValue('consumer') == entitlementGr.getValue('consumer');

  			score = sameContract * weightMap.contract +
  				sameAsset * weightMap.asset +
  				sameSoldProduct * weightMap.sold_product +
  				sameInstallBaseItem * weightMap.install_base_item +
  				sameProduct * weightMap.product;

  			if(!gs.nil(current.getValue('account')))
  				score += sameAccount * weightMap.account;
  			else if(!gs.nil(current.getValue('consumer')))
  				score += sameConsumer * weightMap.consumer;

  			if(score > maxScore) {
  				selectedEntitlement = entitlementGr.getValue('sys_id');
  				maxScore = score;
  			}
  		}
  	}

  	return selectedEntitlement;
  },


  getContractsForAccount: function(){
  	if(!gs.nil(current.consumer) || !gs.nil(current.household)){
  		var result = '';
  		if (!gs.nil(current.consumer))
  			result = 'consumer=' + current.consumer;
  		if (!gs.nil(current.household)) {
  			if (result.length > 0)
  				result = result + '^household=' + current.household;
  			else
  				result = 'household=' + current.household;
  		}
  		return result;
  	} else if(!gs.nil(current.account)){
  		return 'account=' + current.account;
  	}
  },


  getContractForAccountAjax : function () {
      var account = this.getParameter("sysparm_account");
  	if(gs.nil(account))
  		return '';
  	var gr = new GlideRecord("ast_contract");

  	if (this.isPSSPluginActive()) {
  		gr.addQuery("sys_class_name", "!=", "sn_pss_core_service_contract");
  	}

  	gr.addQuery("account",account);
  	gr.addQuery("state",'active');
  	gr.query();
  	if(gr.next() && gr.canRead()){
  		return gr.getValue('sys_id');
  	}
  	return '';
  },

  getContractForAccount : function (account) {

  	account = account || current.getValue('account');
      if (gs.nil(account) || gs.nil(current))
          return '';
      var contractId = '';
      var gr = new GlideRecord("ast_contract");
  	
  	if (this.isPSSPluginActive()) {
  		gr.addQuery("sys_class_name", "!=", "sn_pss_core_service_contract");
  	}

      gr.addQuery("account", account);
      gr.setLimit(1);
      gr.query();
      if (gr.next())
          contractId = gr.getValue('sys_id');
      if (gs.nil(current.asset))
          return contractId;
      var accountQuery = "contract.account=" + account + "^asset=" + current.asset;
      var clm = new GlideRecord("clm_m2m_contract_asset");
      clm.addEncodedQuery(accountQuery);
      clm.orderBy("contract.sys_created_on");
      clm.setLimit(1);
      clm.query();
      if (clm.next()) {
          contractId = clm.getValue("contract");
      }
      return contractId;
  },

  getContractsForContact :  function(){
  	if(!gs.nil(current.contact)){
  		var query = ' ';
  		var contract = new GlideRecord("ast_contract");
  		contract.addQuery("account", current.contact.account);
  		contract.query();
  		while(contract.next()){
  			if (query.length > 0)
  				query += ', ' + contract.sys_id;
  			else
  				query = contract.sys_id;
  		}
  		return 'sys_idIN' + query;
  	}
  },

  getContactsForContract :  function(){
  	if(!gs.nil(current.contract)){
  		var query = ' ';
  		var contact = new GlideRecord("customer_contact");
  		contact.addQuery("account", current.contract.account);
  		contact.query();
  		while(contact.next()){
  			if (query.length > 0)
  				query += ', ' + contact.sys_id;
  			else
  				query = contact.sys_id;
  		}
  		return 'sys_idIN' + query;
  	}
  },

  getContactsForCurrentAccount :  function(){
  	if(current.getTableName() == "customer_account"){
  		var query = ' ';
  		var contact = new GlideRecord("customer_contact");
  		contact.addQuery("account", current.sys_id);
  		contact.query();
  		while(contact.next()){
  			if (query.length > 0)
  				query += ', ' + contact.sys_id;
  			else
  				query = contact.sys_id;
  		}
  		return 'sys_idIN' + query;
  	}
  },

  getAssetForCase: function(account, product){
  	var asset;
  	if(gs.nil(account))
  		account = current.account;

  	if(gs.nil(product))
  		product = current.product;

  	var consumer = current.consumer;

  	if (current.getTableName() == 'csm_service_case') {
  		asset = new GlideRecord("alm_service");
  		if (!gs.nil(current.service)) {
  			var qc = asset.addQuery("ci", current.service);
  			qc.addOrCondition("parent.ci", current.service);
  		}
  	} else {
  		asset = new GlideRecord("alm_asset");
  		if (!gs.nil(product))
  			asset.addQuery("model", product);
  	}

  	if (!gs.nil(account))
  		asset.addQuery("account", account);
  	else if (!gs.nil(consumer))
  		asset.addQuery("consumer", consumer);

  	return asset.getEncodedQuery();

  },

  getAssetsForEntitlement: function(account, contract){
  	if(gs.nil(account))
  		account = current.account;

  	if(gs.nil(contract))
  		contract = current.contract;


  	var asset = new GlideRecord("alm_asset");

  	var query = ' ';
  	if(!gs.nil(account) && gs.nil(contract)){
  		asset.addQuery("account", account);
  		asset.query();
  		while(asset.next()){
  			if (query.length > 0)
  				query += ', ' + asset.sys_id;
  			else
  				query = asset.sys_id;
  		}
  		return 'sys_idIN' + query ;
  	}

  	if(!gs.nil(contract)){
  		var assetsCovered = new GlideRecord("clm_m2m_contract_asset");
  		assetsCovered.addQuery("contract", contract);
  		assetsCovered.query();
  		while(assetsCovered.next()){
  			if (query.length > 0)
  				query += ', ' + assetsCovered.asset;
  			else
  				query = assetsCovered.asset;
  		}
  		return 'sys_idIN' + query ;
  	}

  },

  getChannelChoicesForEntitlement: function(){
  	var query = ' ';
  	var choice = new GlideRecord("sys_choice");
  	choice.addQuery("name", "sn_customerservice_case");
  	choice.addQuery("element", "contact_type");
  	choice.query();
  	while(choice.next()){
  		if (query.length > 0)
  			query += ', ' + choice.sys_id;
  		else
  			query = choice.sys_id;
  	}
  	return 'sys_idIN' + query ;

  },

  getChoiceSysIdForChannel: function(channel){
  	var query = ' ';
  	var choice = new GlideRecord("sys_choice");
  	choice.addQuery("name", "sn_customerservice_case");
  	choice.addQuery("element", "contact_type");
  	choice.addQuery("value",channel);
  	choice.query();
  	choice.next();
  	return choice.sys_id;

  },

  addCaseToChat: function(){
  	var answer = '';
  	var caseID = this.getParameter("sysparm_case_id");
  	var chatChannelID = this.getParameter("sysparm_channel_id");
  	if(gs.nil(caseID) || gs.nil(chatChannelID)) {
  		gs.log("Invalid request, caseID : "+ caseID +" , chatChannelID : " + chatChannelID);
  		return answer;
  	}

  	var gr = new GlideRecord("chat_channel_member");
  	gr.initialize();
  	if(gr.isValid() && gr.canCreate()){
  		gr.affiliation='member';
  		gr.chat_channel=chatChannelID;
  		gr.member_id=caseID;
  		gr.member_table='sn_customerservice_case';
  		gr.status = 'active';
  		answer = gr.insert();
  	}
  	return answer;
  },


  findLatestExpiringTaskSLA: function(caseRecord) {
  	var latestExpiringTaskSla=null;
  	var gr = new GlideRecordSecure('task_sla');
  	gr.addQuery('task', caseRecord.sys_id);
  	gr.orderBy('time_left');
  	gr.query();
  	if(gr.next()) {
  		latestExpiringTaskSla = gr;
  	}
  	return latestExpiringTaskSla;
  },

  isLatestExpiringSLABreached: function(caseRecord) {
  	var isBreached = false;
  	var latestExpiringTaskSla = this.findLatestExpiringTaskSLA(caseRecord);
  	if (latestExpiringTaskSla)
  		isBreached = (latestExpiringTaskSla.stage == 'breached');
  	return isBreached;
  },

  isLatestExpiringSLABreachInNextHour: function(caseRecord) {
  	var latestExpiringTaskSla = this.findLatestExpiringTaskSLA(caseRecord);
  	if (latestExpiringTaskSla) {
  		var dur  = latestExpiringTaskSla.time_left.getGlideObject();
  		if (!gs.nil(dur)) {
  			var time_left = dur.getNumericValue();
  			return time_left > 0 && time_left <= 3600000;
  		}

  	}
  	return false;
  },

  getUsersInSameCompany: function(){
  	if(!gs.nil(current.parent.assigned_to.company)){
  		var query = ' ';
  		var users = new GlideRecord("sys_user");
  		users.addQuery("company", current.parent.assigned_to.company);
  		users.query();
  		while(users.next()){
  			if (query.length > 0)
  				query += ', ' + users.sys_id;
  			else
  				query = users.sys_id;
  		}
  		return 'sys_idIN' + query;
  	}
  },

  updateValue: function(table, id, field, value) {
  	var gr = this._getGlideRecord(table, id);
  	if (gr) {
  		gr.setValue(field, value);
  		gr.update();
  	}
  },

  deleteRecord: function(table, id) {
  	var gr = this._getGlideRecord(table, id);
  	if (gr) {
  		gr.deleteRecord();
  	}
  },

  _getGlideRecord: function(tableName, recordId) {
  	var gr = new GlideRecord(tableName);
  	if (gr.get(recordId))
  		return gr;
  	return null;
  },

  getModelFromAsset: function(){
  	var asset = this.getParameter("sysparm_asset");
  	var gr = new GlideRecord("alm_asset");
  	gr.get(asset);
  	if (gr.canRead())
  		return gr.getValue("model");
  },

  getGlideRecordData: function() {

  	var result = this.getDocument().createElement("result");
  	this.getRootElement().appendChild(result);
  	var table_name = this.getParameter("sysparm_table_name");
  	var sys_id = this.getParameter("sysparm_sys_id");
  	var fields = this.getParameter("sysparm_fields") ? this.getParameter("sysparm_fields").split(",") : [];

  	result.setAttribute("table_name", table_name);
  	result.setAttribute("sys_id", sys_id);

  	var gr = new GlideRecordSecure(table_name);
  	if (!gr.get(sys_id)) {
  		result.setAttribute("error", "NOT_FOUND");
  		return;
  	}

  	result.setAttribute("label", gr.getLabel());
  	result.setAttribute("display_value", gr.getDisplayValue());
  	for(var i = 0; i < fields.length; i++) {
  		var field = fields[i];
  		if (!field)
  			continue;

  		try {
  			var el = gr.getElement(field);
  			if (el) {
  				var item = this.getDocument().createElement("item");
  				item.setAttribute("field", field);
  				item.setAttribute("value", gr.getValue(field));
  				item.setAttribute("display_value", gr.getDisplayValue(field));
  				if (el.getED().isReference()) {
  					item.setAttribute("isReference", "true");
  					item.setAttribute("label", el.getRefRecord().getLabel());
  					item.setAttribute("dependent", el.getReferenceTable());
  				}
  				result.appendChild(item);
  			}
  		} catch (ex) {
  			gs.info("CSManagementUtils.getGlideRecordDatae : " + ex.message );
  		}
  	}
  },

  getPartnerContacts: function(account){
  	//Get contacts of my company and the company whom I am partner of
  	if(gs.nil(account))
  		account = current.account;
  	var query =' ';
  	if (account){
  		var accountsRelationship = new GlideRecord("account_relationship");
  		accountsRelationship.addQuery("to_company", account);
  		accountsRelationship.addQuery("reverse_relationship", false);
  		accountsRelationship.query();
  		var partnerContacts = [];
  		while(accountsRelationship.next()){
  			partnerContacts.push(accountsRelationship.from_company.toString());
  		}
  		query = partnerContacts.join();
  	}
  	return 'sys_idIN' + query;
  },

  getPartnerAndCustomerContacts: function(account){
  	if (!account)
  		return "";
  	var accountsRelationship = new GlideRecord("account_relationship");
  	accountsRelationship.addQuery("to_company", account);
  	accountsRelationship.query();
  	var partnerContacts = [];
  	partnerContacts.push(account); //add the current account
  	while(accountsRelationship.next()){
  		//add the current account's partners
  		partnerContacts.push(accountsRelationship.from_company.toString());
  	}
  	return this.getUsersInCompanies(partnerContacts);
  },

  getUsersInCompanies: function(companies){
  	var users = new GlideRecord("customer_contact");
  	users.addQuery('company','IN', companies);
  	users.query();
  	var contacts = [];
  	while(users.next()){
  		contacts.push(users.sys_id.toString());
  	}
  	return 'sys_idIN' + contacts;
  },

  getUserAccount: function() {
  	return gs.getUser().getCompanyID();
  },

  getUserPartnerContacts: function() {
  	//Get contacts of my company and my partner company
  	var partnerContacts = this.getMeAndPartners();
  	return this.getUsersInCompanies(partnerContacts);
  },

  getAccounts: function(account) {
  	//Reference qual used by contacts and asset variables on portal "Create Case"
  	//to filter contact/asset based on selected account
  	//if account is not selected, then return all accounts for the current user
  	if(account)
  		return account;
  	else
  		return this.getAccessibleAccounts(gs.getUser().getCompanyID(), false, true, true);
  },

  getMeAndPartners: function() {
  	//return this.getMyAccessibleAccountsStr();
  	return this.getAccessibleAccounts('', false, true, true);
  },

  getMyAccessibleAccountsStr: function(account) {
  	var accounts = this.getMyAccessibleAccounts(account);
  	if (!accounts)
  		accounts = [];
  	return accounts.join();
  },

  getMyAccessibleAccounts: function(account) {
  	//Get my accounts for which I have access to
  	var myAccessibleAccounts = [];

  	var key = this._getKey("cs_partner_accounts");
  	//gs.getSession().clearClientData(key);
  	var value = gs.getSession().getClientData(key);
  	if (!gs.nil(value)) {
  		if (value == "NIL") {
  			return [];
  		} else {
  			var valArray = value.split(',');
  			for (i=0; i < valArray.length; i++)
  				myAccessibleAccounts.push(valArray[i]);
  			return myAccessibleAccounts;
  		}
  	}

  	value = "NIL";
  	account = account || gs.getUser().getCompanyID();
  	var accountGr = new GlideRecord("customer_account");

  	if (accountGr.get(account)) {
  		//Step 1: add the user account, if account is customer
  		if (accountGr.customer)
  			myAccessibleAccounts.push(account);

  		//Step 2: if account is type of partner and user has partner role
  		//then get all partner's for current user account
  		if (accountGr.partner && gs.hasRole('sn_customerservice.partner')) {
  			var accountsRelationship = new GlideRecord("account_relationship");
  			accountsRelationship.addQuery("from_company", account);
  			accountsRelationship.addQuery("reverse_relationship", false);
  			accountsRelationship.query();
  			while(accountsRelationship.next()){
  				myAccessibleAccounts.push(accountsRelationship.getValue("to_company"));
  			}
  		}
  	}

  	//store list in user session as string to resue
  	if (myAccessibleAccounts.length > 0)
  		value =  myAccessibleAccounts.toString();
  	gs.getSession().putClientData(key, value);
  	return myAccessibleAccounts;
  },

  getAllAccessibleAccounts: function(account) {
  	//Get my accounts for which I have access to
  	var myAccessibleAccounts = [];

  	var key = this._getKey("cs_all_accounts");
  	//gs.getSession().clearClientData(key);
  	var value = gs.getSession().getClientData(key);
  	if (!gs.nil(value)) {
  		if (value == "NIL") {
  			return [];
  		} else {
  			var valArray = value.split(',');
  			for (i=0; i < valArray.length; i++)
  				myAccessibleAccounts.push(valArray[i]);
  			return myAccessibleAccounts;
  		}
  	}

  	value = "NIL";
  	account = account || gs.getUser().getCompanyID();
  	var accountGr = new GlideRecord("customer_account");

  	if (accountGr.get(account)) {

  		myAccessibleAccounts.push(account);
  		//Step 2: if account is type of partner and user has partner role
  		//then get all partner's for current user account
  		if (accountGr.partner && gs.hasRole('sn_customerservice.partner')) {
  			var accountsRelationship = new GlideRecord("account_relationship");
  			accountsRelationship.addQuery("from_company", account);
  			accountsRelationship.addQuery("reverse_relationship", false);
  			accountsRelationship.query();
  			while(accountsRelationship.next()){
  				myAccessibleAccounts.push(accountsRelationship.getValue("to_company"));
  			}
  		}
  	}

  	//store list in user session as string to resue
  	if (myAccessibleAccounts.length > 0)
  		value =  myAccessibleAccounts.toString();
  	gs.getSession().putClientData(key, value);
  	return myAccessibleAccounts;
  },

  getDefaultAccount : function(userId){
  	return getUserAccount();
  },

  isAccountAdmin: function(userId){
  	userId = userId || gs.getUserID();
  	var key = this._getKey("cs_is_user_account_admin");
  	gs.getSession().clearClientData(key);
  	var value = gs.getSession().getClientData(key);
  	if (gs.nil(value)) {
  		var userRecord = gs.getUser().getUserByID(userId);
  		var company = userRecord.getCompanyRecord();
  		value =  company && userId == company.contact;
  		gs.getSession().putClientData(key, value);
  	}
  	return  value === true;
  },

  hasPartner: function() {
  	var accountGr = new GlideRecord("customer_account");
  	if(accountGr.get(gs.getUser().getCompanyID()))
  		return accountGr.partner;

  	return false;
  },

  hasPartnerOrIsAccountAdmin : function(){
  	if ( gs.hasRole('sn_esm_user_admin') || gs.hasRole('sn_esm_partner_admin') || gs.hasRole('sn_esm_partner')) {
  		if (this.hasPartner())
  			return "hasPartner";
  		else if (this.isAccountAdmin())
  			return "accountAdmin";
  	}
  	return "none";
  },

  isPartnerOfAccount : function() {
  	var account = this.getParameter("sysparm_account");
  	return this.isPartnerOf(account);
  },

  isPartnerOf: function(account) {
  	if (!account)
  		return false;
  	var accountsRelationship = new GlideRecord("account_relationship");
  	accountsRelationship.addQuery("to_company", account);
  	accountsRelationship.setLimit(1);
  	accountsRelationship.query();
  	return accountsRelationship.hasNext();
  },

  isCustomer: function(account) {
  	var gr = new GlideRecord("customer_account");
  	if (gr.get(account))
  		return gr.customer;
  	return false;

  },
  isPartner: function(account){
  	var gr = new GlideRecord("customer_account");
  	if (gr.get(account))
  		return gr.partner;
  	return false;
  },

  hasAccountAccessForPartnerAdmin: function(account){
  	if(gs.nil(account))
  		return false;
  	var accounts = this.getAllAccessibleAccounts();
  	if(accounts.toString().indexOf(account) != -1)
  		return true;
  	return false;
  },

  hasAccountAccessForPartner: function(account, contact){
  	if(gs.nil(account))
  		return false;
  	var accounts = this.getAllAccessibleAccounts();
  	if(accounts.toString().indexOf(account) != -1){
  		if(gs.getUser().getCompanyID() == account && contact != gs.getUserID())
  			return false;
  		else
  			return true;
  	}
  	return false;
  },

  getPortalCaseListPage: function() {
  	var key = this._getKey("cs_portal_list_page");
  	var value = gs.getSession().getClientData(key);
  	if (gs.nil(value)) {
  		value = "my_cases.do";
  		if ( gs.hasRole('sn_customerservice.customer_admin') || gs.hasRole('sn_customerservice.partner_admin'))
  			value = "cases.do";
  		gs.getSession().putClientData(key, value);
  	}
  	return value;
  },
  /** Get Accounts to determine the cases to which I have read/write access in the portal.
  	account: account sys_id
  	readWriteAccess:
  		true : create access
  		false : read access
  	checkAcctCustomer: check account is a customer account for creating cases
  	returnStr:
  		true : return a string
  		false : return an array
  */
  getAccessibleAccounts: function(account, readWriteAccess, checkAcctCustomer, returnStr) {
  	var key = "cs_user_accessible_accounts";
  	var accessibleAccounts;
  	key += checkAcctCustomer ? '_customer': '';
  	key += readWriteAccess ? '_write': '_read';
  	key = this._getKey(key);
  	accessibleAccounts = gs.getSession().getClientData(key);
  	if (!gs.nil(accessibleAccounts)) {
  		if (accessibleAccounts == "NIL")
  			return [];
  		 else
  			accessibleAccounts = accessibleAccounts.split(',');

  	} else {
  		accessibleAccounts = new sn_customerservice.CSPortalUtil().getAccessibleAccounts(account, readWriteAccess, checkAcctCustomer);
  		if(accessibleAccounts.length > 0)
  			gs.getSession().putClientData(key, accessibleAccounts.join());
  		else
  			gs.getSession().putClientData(key, 'NIL');
  	}

  	if(returnStr)
  		return accessibleAccounts.slice(0).join();
  	return accessibleAccounts.slice(0);
  },


  getAssetsBasedOnAccountRelationship: function(account, checkCustomerFlag) {
  	var key = "cs_user_accessible_assets";
  	var accounts;
  	var m2mAssetContact;
  	var assets;
  	var almAsset = new GlideRecord('alm_asset');
  	var useM2MAssetContact = gs.getProperty('sn_customerservice.use_asset_contact_relationship');
  	var asset;

  	key += checkCustomerFlag ? '_customer': '';
  	key = this._getKey(key);

  	//Get from Cache only when account is empty
  	//We don't want to cache for each account
  	//Already the getAccessibleAccounts function caches the accounts

  	if(gs.nil(account))
  		assets = gs.getSession().getClientData(key);

  	if (!gs.nil(assets)) {
  		if (assets == "NIL")
  			assets = '';
  		return assets;

  	} else if(useM2MAssetContact == 'true') {
  		assets = [];
  		accounts =  this.getAccessibleAccounts(gs.getUser().getCompanyID(), false, false, true);
  		m2mAssetContact = new GlideRecord('sn_customerservice_m2m_asset_contact');
  		m2mAssetContact.addQuery('contact', gs.getUserID());
  		if(account)
  			m2mAssetContact.addQuery('asset.account', account);
  		m2mAssetContact.query();
  		while(m2mAssetContact.next()) {
  			asset = m2mAssetContact.asset.getRefRecord();
  			if(accounts.indexOf(asset.getValue('account')) > -1)
  				assets.push(m2mAssetContact.getValue('asset'));
  		}
  	} else {
  		assets = [];
  		if(!gs.nil(account))
  			almAsset.addQuery('account', account);
  		else {
  			if(checkCustomerFlag == true)
  				accounts =  this.getAccessibleAccounts(gs.getUser().getCompanyID(), false, true, true);
  			else
  				accounts =  this.getAccessibleAccounts(gs.getUser().getCompanyID(), false, false, true);
  			almAsset.addQuery('account', 'IN', accounts);
  		}
  		almAsset.query();
  		while(almAsset.next())
  			assets.push(almAsset.getValue('sys_id'));
  	}
  	if(gs.nil(account)) {
  		if(assets.length > 0)
  			gs.getSession().putClientData(key, assets.join());
  		else
  			gs.getSession().putClientData(key, 'NIL');
  	}
  	return assets.join();
  },

  hasAccessToAccount: function(company, checkAgent) {
  	var hasAccess = false;
  	if(checkAgent && gs.hasRole("sn_esm_agent")){
  		hasAccess =true;
  	} else {
  		var accounts = this.getAccessibleAccounts('', false, false, false);

  		/*if(accounts[0] == gs.getUser().getCompanyID())
  			accounts.shift();*/

  		if(company && accounts.toString().indexOf(company) != -1) {
  			if(gs.hasRole("sn_esm_user"))
  				hasAccess = true;
  		}
  		/*else if(gs.hasRole("sn_esm_user")){
  			if(company == gs.getUser().getCompanyID())
  				hasAccess = true;
  		}*/
  	}
  	return hasAccess;
  },

  hasReadAccessToAsset: function(company, asset, checkAgent) {
  	var m2mAssetContact;
  	var hasAccess = false;
  	var useM2MAssetContact = gs.getProperty('sn_customerservice.use_asset_contact_relationship');
  	if(checkAgent && gs.hasRole("sn_esm_agent")){
  		hasAccess =true;
      } else {
  		hasAccess = this.hasAccessToAccount(company, checkAgent);
  		if(hasAccess && useM2MAssetContact == 'true') {
  			m2mAssetContact = new GlideRecord('sn_customerservice_m2m_asset_contact');
  			m2mAssetContact.addQuery('asset', asset);
  			m2mAssetContact.addQuery('contact', gs.getUserID());
  			m2mAssetContact.query();
  			if(m2mAssetContact.hasNext())
  				hasAccess = true;
  		}
  	}
  	return hasAccess;
  },

  hasWriteAccessToContact: function(account, user) {
  	var hasAccess = false;
  	if(gs.hasRole("sn_esm_user") || gs.hasRole("sn_esm_partner")){
  		if(user == gs.getUserID())
  			hasAccess = true;
  		else if(gs.hasRole("sn_esm_user_admin") && account == gs.getUser().getCompanyID())
  			hasAccess = true;
  		else {
  			var accounts = this.getAccessibleAccounts('', true, false, true);
  			if(accounts.indexOf(account) != -1) {
  				hasAccess = true;
  			}
  		}
  	}
  	return hasAccess;
  },

  hasReadAccessToContact: function(account, user) {
  	var hasAccess = false;

  	if(gs.hasRole("sn_esm_agent"))
  		hasAccess = true;
  	else if(gs.hasRole("sn_esm_user")) {
  		if(user == gs.getUserID())
  			hasAccess = true;
  		else if(gs.hasRole("sn_esm_user_admin") && account == gs.getUser().getCompanyID())
  			hasAccess = true;
  		else {
  			var accounts = this.getAccessibleAccounts('', false, false, true);
  			if(accounts.indexOf(account) != -1) {
  				hasAccess = true;
  				if(!this.hasUserAdminAccess()) {
  					if(gs.getUser().getCompanyID() == account && user != gs.getUserID())
  						hasAccess = false;
  				}
  			}
  		}
  	}
  	return hasAccess;
  },

  hasUserAdminAccess: function() {
  	var key = this._getKey("cs_user_has_admin_access");
  	var value = gs.getSession().getClientData(key);
  	if (gs.nil(value)) {
  		var roles = new sn_customerservice.CSPortalUtil().getRelationshipRolesWithAdminAccess();
  		for(var i=0; i<roles.length; i++) {
  			if(gs.hasRole(roles[i])) {
  				value = true;
  				break;
  			}
  		}
  		value = value ? value : false;
  		gs.getSession().putClientData(key, value);
  	}

  	return value == 'true' ? true : false;
  },

  hasSubAccounts: function(account) {
  	var subAccounts = this.getAccountsFromHierarchy(account);
  	if(subAccounts.length > 0)
  		return true;
  	return false;
  },

  hasAccountContactRelation: function(contact) {
  	var accounts = this.getAccountsFromContactRelationship(contact);
  	if(accounts.length > 0)
  		return true;
  	return false;
  },

  getRelatedAccountContacts: function(account) {
  	//var relationshipType;
  	var accountRelationships;
  	var customerContacts;
  	//var contact;
  	//var roles;
  	var contacts = [];
  	//var relationshipRoles = new sn_customerservice.CSPortalUtil().getRelationshipRolesWithReadAccess();

  	//Add all contacts of the partner accounts who have read access for the account relationship type
  	//for(relationshipType in relationshipRoles) {
  		//roles = relationshipRoles[relationshipType];
  		accountRelationships = new GlideRecord('account_relationship');
  		//accountRelationships.addQuery('relationship_type', relationshipType);
  		accountRelationships.addQuery('reverse_relationship', false);
  		accountRelationships.addQuery('to_company', account);
  		accountRelationships.query();
  		while(accountRelationships.next()) {
  			customerContacts = new GlideRecord('customer_contact');
  			customerContacts.addQuery('account', accountRelationships.getValue('from_company'));
  			customerContacts.query();
  			while(customerContacts.next()) {
  				//contact = customerContacts.getValue('sys_id');
  				//for(var i=0 ; i<roles.length; i++) {
  					//if(gs.getUser().getUserByID(contact).hasRole(roles[i])) {
  						//contacts.push(contact);
  						contacts.push(customerContacts.getValue('sys_id'));
  						//break;
  					//}
  				//} // end of loop for contacts with roles
  			} // end of loop for contacts in account
  		} // end of loop for accounts with relationshipTypes
  	//} // end of loop for relationshipTypes
  	return contacts;
  },

  getAccountContacts: function(account) {
  	/* ReferenceQual for Account Contact Relationships:-
  	1) My Account contacts
  	2) Contacts from any Account (Partner or Account) relationship
  	3) Contacts from account hierarchy (whole account hierarchy tree)
  	4) Return all contacts if restrict_contact_relationship property is false
  	*/

  	var restrict_contact_relationship = gs.getProperty(CSMBaseConstants.RESTRICT_CONTACT_RELATIONSHIP, true) == "true";
  	if(!restrict_contact_relationship)
  		return "";
  	var query = null;
  	var gr = new GlideRecord('customer_account');
  	if (gr.get(account)) {
  		//Get related accounts
  		relatedAccounts = [account];
  		var accountRelationships = new GlideRecord('account_relationship');
  		accountRelationships.addQuery('reverse_relationship', false);
  		accountRelationships.addQuery('to_company', account);
  		accountRelationships.query();
  		while(accountRelationships.next())
  			relatedAccounts.push(accountRelationships.getValue('from_company'));

  		if (relatedAccounts.length > 0)
  			query = 'accountIN' + relatedAccounts.join(',');

  		//Accounts from account hierarchy (whole account hierarchy tree)
  		var accountPath = gr.getValue('account_path');
  		if(!gs.nil(accountPath)) {
  			if (!gs.nil(query))
  				query = query + '^ORaccount.account_pathSTARTSWITH' + accountPath.split('/')[0];
  			else
  				query =  'account.account_pathSTARTSWITH' + accountPath.split('/')[0];
  		}
  	}

  	//for invalid account or no match, make sure no contact is returned, is it right approach?
  	if (gs.nil(query))
  		query = 'sys_idISEMPTY';

  	return query;
  },


  getAssetContacts: function(asset) {
  	/* ReferenceQual for Asset Contact Relationships :-
  	1) My Account contacts
  	2) Contacts from Partner Account relationship
  	3) Contacts from "Contact Account relationship"
  	*/
  	var query = null;
  	var gr = new GlideRecord('alm_asset');
  	if (gr.get(asset)) {
  		var assetAccount = gr.getValue('account');
  		if (!gs.nil(assetAccount)) {
  			var accounts = [assetAccount]; //by default add asset.account
  			//get accounts from relationship
  			var ar = new GlideRecord('account_relationship');
  			ar.addQuery('reverse_relationship', false);
  			ar.addQuery('to_company', assetAccount);
  			ar.query();
  			while(ar.next())
  				accounts.push(ar.getValue('from_company'));

  			if (accounts.length > 0)
  				query = 'accountIN' + accounts.join(',');

  			//get contacts from account contact relationship
  			var contacts = [];
  			var ac =  new GlideRecord('sn_customerservice_contact_relationship');
  			ac.addQuery('company', 'IN', accounts.join(','));
  			ac.query();
  			while(ac.next())
  				contacts.push(ac.getValue('contact'));

  			if (contacts.length > 0)
  				query = query + '^ORsys_idIN' + contacts.join(',');
  		}
  	}

  	//for invalid asset id or no match, make sure no contact is returned, is it right approach?
  	if (gs.nil(query))
  		query = 'sys_idISEMPTY';

  	return query;
  },
  
  getContactEncodedQueryBasedOnSO: function(account, reqServiceOrg, serviceOrg) {
  	var contactGr = new GlideRecord(global.CSMBaseConstants.CONTACT_TABLE);
  	if (gs.nil(account) && (!gs.nil(reqServiceOrg) || !gs.nil(serviceOrg))) {
  		var orgs = [];
  		if (!gs.nil(reqServiceOrg)) {
  			orgs.push(reqServiceOrg);
  		}
  		if (!gs.nil(serviceOrg) && orgs.indexOf(serviceOrg) < 0) {
  			orgs.push(serviceOrg);
  		}
  		contactGr.addEncodedQuery(new ServiceOrganizationUtil().getContactRefQualifierForSelectedSO(orgs));
  	}
  	return contactGr.getEncodedQuery();
  },
  /*
  	This method should be used only if contact access is not restricted for the given account.
  	Otherwise, use the method getCaseContactRefQualifier instead of this method.
  */
  getCaseContacts : function(account, caseGr, isPortal) {
  	isPortal = gs.nil(isPortal) ? false : isPortal;
  	var contactGr = new GlideRecord(global.CSMBaseConstants.CONTACT_TABLE);
  	if (!gs.nil(caseGr)) {
  		if (this.isServiceOrgPluginActive()) {
  			var reqServiceOrg = !isPortal ? caseGr.requesting_service_organization : caseGr.variables.requesting_service_organization;
  			var serviceOrg = !isPortal ? caseGr.service_organization : caseGr.variables.service_organization;
  			contactGr.addEncodedQuery(this.getContactEncodedQueryBasedOnSO(account, reqServiceOrg, serviceOrg));
  		}
  		if (!isPortal) {
  			contactGr.addEncodedQuery(this.getCaseContactRefQualifier(caseGr));
  			return contactGr.getEncodedQuery();
  		}
  	}
  	var contacts = [];
  	var contactOr;

  	contactGr.addActiveQuery();

  	if (!gs.nil(account)) {
  		contactOr = contactGr.addQuery('account', account);
  		contacts = this.getContactsFromAccountRelationship(account.toString());
  	} else if (gs.hasRole('sn_customerservice.customer') && !gs.hasRole('admin')) {
  		var accounts = this.getAccessibleAccounts(gs.getUser().getCompanyID(), false, true, false);
  		if (!gs.nil(accounts) && accounts.length > 0) {
  			contactOr = contactGr.addQuery('account', 'IN', accounts);
  			contacts = this.getContactsFromAccountRelationship(accounts);
  		}
  	}

  	if (!gs.nil(contacts) && contacts.length > 0) {
  		if (!gs.nil(contactOr)) {
  			contactOr.addOrCondition('sys_id', 'IN', contacts);
  		} else {
  			contactGr.addQuery('sys_id', 'IN', contacts);
  		}
  	}

  	return contactGr.getEncodedQuery();
  },

  /*
  	This method looks at the account, sold product, consumer of the case,
  	and returns encoded query for the list of contacts.
  */
  getCaseContactRefQualifier: function(caseGr) {
  	if(gs.nil(caseGr)) return "";

  	var contactGr = new GlideRecord(CSMBaseConstants.CONTACT_TABLE);
  	var isInstallBasePluginActive = pm.isActive(CSMBaseConstants.INSTALL_BASE_PLUGIN);
  	if (!gs.nil(caseGr.account) && isInstallBasePluginActive && !gs.nil(caseGr.sold_product) &&
  		new global.Account().isRestrictedAccessAccount(caseGr.account)) {

  		/*
  			Install base plugin is active
  			sold product is not empty
  			Account is not empty and has restricted contact access.
  		*/
  		var installBaseUtil = new sn_install_base.InstallBaseUtil();
  		var spAuthAccounts = installBaseUtil.getSPAuthorizedAccounts(caseGr.sold_product);
          contactGr.addActiveQuery();
          var contactOr = contactGr.addQuery("account", caseGr.account);
          var contactsFromCR = this.getContactsFromAccountRelationship(caseGr.account.toString());
          var soldProductContactsWithFullAccess =
          installBaseUtil.getSPContactsHavingFullAccessWithAccessRestriction(caseGr.sold_product);
          var authContactsFromCR = [];
          for (var i = 0; i < contactsFromCR.length; i++) {
              if (soldProductContactsWithFullAccess.includes(contactsFromCR[i].toString())) {
                  authContactsFromCR.push(contactsFromCR[i].toString());
              }
          }
          if (!gs.nil(authContactsFromCR) && authContactsFromCR.length > 0) {
              contactOr.addOrCondition('sys_id', 'IN', authContactsFromCR);
          }
          if (spAuthAccounts.indexOf(caseGr.account.toString()) == -1) {
              var qc = contactGr.addQuery('sys_id', 'IN', soldProductContactsWithFullAccess);
              qc.addOrCondition("roles", "sn_customerservice.customer_admin");
          }
      } else {
          contactGr.addEncodedQuery(this.getCaseContacts(caseGr.account));
      }

  	if (!gs.nil(caseGr.consumer) && pm.isActive(CSMBaseConstants.B2B2C_PLUGIN))
  		contactGr.addEncodedQuery(new sn_acct_consumer.AccountConsumerUtil().getContactRefFromConsumer(caseGr.consumer));

      if (gs.nil(caseGr.account) && (!gs.nil(caseGr.requesting_service_organization) || !gs.nil(caseGr.service_organization))) {
          var orgs = [];
          if (!gs.nil(caseGr.requesting_service_organization)) {
              orgs.push(caseGr.requesting_service_organization);
          }

          if (!gs.nil(caseGr.service_organization)&& orgs.indexOf(caseGr.service_organization)<0) {
              orgs.push(caseGr.service_organization);
          }
          contactGr.addEncodedQuery(new ServiceOrganizationUtil().getContactRefQualifierForSelectedSO(orgs));
      }

  	return contactGr.getEncodedQuery();
  },

  /*
  	This method should be used only if contact access is not restricted for the given account.
  	Otherwise, use the method getCaseContactRefQualifier instead of this method.
  */
  getCaseContactsSysIDs : function(account) {
  	var contacts = [];
  	var accounts;
  	var gr = new GlideRecord('customer_contact');
  	gr.addActiveQuery();
  	if (account) {
  		contacts = this.getContactsFromAccountRelationship(account.toString());
  		gr.addQuery('account', account);
  	} else if (gs.hasRole('sn_customerservice.customer') && !gs.hasRole('admin')) {
  		accounts = this.getAccessibleAccounts(gs.getUser().getCompanyID(), false, true, false);
  		contacts = this.getContactsFromAccountRelationship(accounts);
  		gr.addQuery('account', 'IN', accounts.join(','));
  	}
  	gr.query();
  	while(gr.next())
  		contacts.push(gr.getValue('sys_id'));

  	return contacts.join(',');
  },

  /*
  	This method looks at the account, sold product, household of the case,
  	and returns encoded query for the list of consumers.
  */
  getCaseConsumerRefQualifier: function(caseGr) {
  	if(gs.nil(caseGr)) return "";

  	var consumerGr = new GlideRecord(CSMBaseConstants.CONSUMER_TABLE);
  	var isInstallBasePluginActive = pm.isActive(CSMBaseConstants.INSTALL_BASE_PLUGIN);
  	var isHouseholdPluginActive = pm.isActive(CSMBaseConstants.HOUSEHOLD_PLUGIN);
  	var isB2BConsumersPluginActive = pm.isActive(CSMBaseConstants.B2B2C_PLUGIN);

  	if (isInstallBasePluginActive && !gs.nil(caseGr.sold_product)) {
  		/*
  			Install base plugin is active
  			sold product is not empty
  			So restricted access for consumers can be applied here.
  		*/
  		var installBaseUtil = new sn_install_base.InstallBaseUtil();
  		var soldProductConsumersWithFullAccess =
  			installBaseUtil.getSPConsumersHavingFullAccess(caseGr.sold_product);
  		consumerGr.addEncodedQuery('sys_idIN' + soldProductConsumersWithFullAccess);
  	}

      var isAddedHouseholdOrAccount = false;

  	if(isHouseholdPluginActive && !gs.nil(caseGr.household)){
  		consumerGr.addEncodedQuery(new sn_csm_household.HouseHoldUtils().getConsumersAvailableForHousehold(caseGr.household));
          isAddedHouseholdOrAccount = true;
  	}

      if (!gs.nil(caseGr.account) && isB2BConsumersPluginActive) {
  		consumerGr.addEncodedQuery(new sn_acct_consumer.AccountConsumerUtil().getConsumerRefFromAccount(caseGr.account));
          isAddedHouseholdOrAccount = true;
      }

      if (!isAddedHouseholdOrAccount && (!gs.nil(caseGr.service_organization) || !gs.nil(caseGr.requesting_service_organization))) {
          var orgs = [];
          if (!gs.nil(caseGr.requesting_service_organization)) {
              orgs.push(caseGr.requesting_service_organization);
          }

          if (!gs.nil(caseGr.service_organization) && orgs.indexOf(caseGr.service_organization)<0) {
              orgs.push(caseGr.service_organization);
          }
          consumerGr.addEncodedQuery(new ServiceOrganizationUtil().getConsumerReferenceQualifier(orgs));

      }

      return consumerGr.getEncodedQuery();
  },

  /*
  	This method looks at the consumer of the case,
  	and returns encoded query for the list of accounts.
  */
  getCaseAccountRefQualifier: function (caseGr){
  	if(gs.nil(caseGr)) return "";

      var accountGr = new GlideRecord(CSMBaseConstants.ACCOUNT_TABLE);
      accountGr.addQuery('customer', true);
      if (!gs.nil(caseGr.consumer) && pm.isActive(CSMBaseConstants.B2B2C_PLUGIN)) {
          accountGr.addEncodedQuery(new sn_acct_consumer.AccountConsumerUtil().getAccountRefFromConsumer(caseGr.consumer));
      } else if (!gs.nil(caseGr.service_organization) || !gs.nil(caseGr.requesting_service_organization)) {
          var orgs = [];
          if (!gs.nil(caseGr.requesting_service_organization)) {
              orgs.push(caseGr.requesting_service_organization);
          }

          if (!gs.nil(caseGr.service_organization) && orgs.indexOf(caseGr.service_organization)<0) {
              orgs.push(caseGr.service_organization);
          }
          accountGr.addEncodedQuery(new ServiceOrganizationUtil().getAccountReferenceQualifier(orgs));
      }
      return accountGr.getEncodedQuery();
  },

  getServiceRefQualifierForCase: function(caseGR) {
  	if (gs.nil(caseGR))
  		return;
  	var encodedQuery = 'active=true^table='+caseGR.sys_class_name;
  	if (pm.isActive(global.CSMBaseConstants.SERVICE_ORGANIZATION_PLUGIN) && caseGR.service_organization) {
  		//get the services that are supported for the given products or service org
  		var services = new ServiceOrganizationUtil().getServicesAvailableForCase(caseGR);
  		//if it is empty, it will not fetch any records
  		if(!gs.nil(services))
  			encodedQuery += '^sys_idIN'+services;
  	}
  	return encodedQuery;
  },

  getCasePartnerContacts : function(partner, caseGr) {
  	var contacts = [];
  	var gr = new GlideRecord('customer_contact');
  	gr.addActiveQuery();
  	gr.addQuery('account',partner);
  	gr.query();
  	while(gr.next())
  		contacts.push(gr.getValue('sys_id'));
  	var partnerContacts ='';
  	partnerContacts = contacts.join(',');
  	var isInstallBasePluginActive = pm.isActive(CSMBaseConstants.INSTALL_BASE_PLUGIN);
  	if (!gs.nil(caseGr) && !gs.nil(caseGr.account) && isInstallBasePluginActive && new global.Account().isRestrictedAccessAccount(caseGr.account)) {
  		var installBaseUtil = new sn_install_base.InstallBaseUtil();
  		if(!gs.nil(caseGr.sold_product)) {
  			/*
  			Install base plugin is active
  			sold product is not empty
  			Account is not empty and has restricted contact access.
  			*/
  			var soldProductAuthorizedAccounts = installBaseUtil.getSPAuthorizedAccounts(caseGr.sold_product);
  			if(gs.nil(soldProductAuthorizedAccounts) || (soldProductAuthorizedAccounts.indexOf(caseGr.partner+'') == -1 )){
  				var soldProductAuthContacts = installBaseUtil.getSPContactsHavingFullAccessWithAccessRestriction(caseGr.sold_product);
  				partnerContacts = this.getPartnerContactsList(partner, soldProductAuthContacts);
  			}
  			return partnerContacts;
  		}

  		if(!gs.nil(caseGr.install_base)) {
  			/*
  			Install base plugin is active
  			install base is not empty
  			Account is not empty and has restricted contact access.
  			*/
  			var installBase = caseGr.install_base;
  			// If the current Install base is a child IB, then we will use its root IB to get the related parties.
  			if (!gs.nil(installBase.root)) {
  				installBase = installBase.root;
  			}
  			var installBaseAuthorizedAccounts = installBaseUtil.getIBAuthorizedAccounts(installBase);
  			if(gs.nil(installBaseAuthorizedAccounts) || (installBaseAuthorizedAccounts.indexOf(caseGr.partner+'') == -1 )){
  				var installBaseAuthContacts = installBaseUtil.getIBContactsHavingFullAccessWithAccessRestriction(installBase);
  				partnerContacts = this.getPartnerContactsList(partner, installBaseAuthContacts);
  			}
  			return partnerContacts;
  		}
  		}
  	return partnerContacts;
  },

  getPartnerContactsList : function(partner, authorizedContacts) {
  	var contacts = [];
  	var gr = new GlideRecord('customer_contact');
  	gr.addActiveQuery();
  	gr.addQuery('account',partner);
  	gr.addQuery("roles","sn_customerservice.partner_admin").addOrCondition('sys_id', 'IN', authorizedContacts);
  	gr.query();
  	while(gr.next()) {
  		contacts.push(gr.getValue('sys_id'));
  	}
  	return contacts.join(',');
  },

  getAccountsFromHierarchy : function(account, includeWholeTree) {
  	var accounts = new sn_customerservice.CSPortalUtil().getAccountsFromHierarchy(account, includeWholeTree);
  	return accounts;
  },

  getAccountsFromContactRelationship : function(contact) {
  	var accounts = new sn_customerservice.CSPortalUtil().getAccountsFromContactRelationship(contact);
  	return accounts;
  },

  getAccountsFromAccountRelationship : function(account) {
  	var accounts = new sn_customerservice.CSPortalUtil().getAccountsFromHierarchy(account);
  	return accounts;
  },

  getContactsFromAccountRelationship : function(account) {
  	var contacts = new sn_customerservice.CSPortalUtil().getContactsFromAccountRelationship(account);
  	return contacts;
  },

  isConnectCompatibility: function(){
  	return new GlideCollaborationCompatibility().getCompatibility();
  },

  checkCompatibility: function(browser){
      var message = '';
      if(typeof browser !== "undefined"){
          if (browser['isMSIE']) {
              if (browser.versionString <= 8) {
                  message = 'unsupported_browser';
              }
          }
      } else {
          var device = new GlideMobileExtensions().getDeviceType();
          if (device == "m" || device == "mobile" || device == "tablet")
              message = 'unsupported_device';
      }
      return message;
  },
  scopedGlideMobileExtensions: function(){
  	return GlideMobileExtensions();
  },

  scopedGlideCollaborationCompatibility: function(){
  	return GlideCollaborationCompatibility();
  },

  addRemoveRolesForContact: function(newRoles, contactId) {
  	if (gs.hasRole("sn_customerservice.customer_admin")) {
  		var availableRoles = gs.getProperty('sn_customerservice.contact_role_assignment','sn_customerservice.partner_admin,sn_customerservice.partner,sn_customerservice.customer_admin,sn_customerservice.customer');
  		var rolesToAdd = [];

  		newRoles = newRoles || this.getParameter("sysparm_add_roles");
  		contactId = contactId || this.getParameter("sysparm_contact_id");
  		this._deleteContactRoles(availableRoles, contactId);
  		if(!gs.nil(newRoles)) {
  			rolesToAdd = newRoles.split(',');
  			for(var k=0; k<rolesToAdd.length; k++)
  				this._addContactRole(rolesToAdd[k], contactId);
  		}
  	}
  },

  getChildAccounts: function() {
  	var id = this.getParameter('account_id');
  	var expanded_nodes = this.getParameter('expanded_nodes');
  	var expanded_nodes_arr = expanded_nodes.split(',');
  	var expanded_nodes_map = {};
  	for (var e_node in expanded_nodes_arr) {
  		expanded_nodes_map[expanded_nodes_arr[e_node]] = true;
  	}
  	var gr = new GlideRecordSecure('customer_account');
  	gr.addQuery('account_parent', id);
  	gr.orderBy('account_code');
  	gr.query();

  	var accountItems = [];
  	var childrenCounts = {};

  	while(gr.next()) {
  		var accountItem = {};
  		accountItem.sys_id = gr.getValue('sys_id');
  		accountItem.label = gr.getValue('name')+"  -  "+gr.getValue('number');
  		accountItems.push(accountItem);
  		childrenCounts[gr.getValue('sys_id')] = -1;
  	}

  	var countgr = new GlideAggregate('customer_account');
  	countgr.addAggregate('COUNT', 'account_parent');
  	countgr.addQuery('account_parent', 'IN', Object.keys(childrenCounts).join());
  	countgr.query();

  	while(countgr.next()) {
  		childrenCounts[countgr.getValue('account_parent')] = countgr.getAggregate('COUNT', 'account_parent');
  	}

  	for(var i = 0; i < accountItems.length; i++) {
  		if(expanded_nodes_map[accountItems[i].sys_id] == true){
  			this._getChildAccountItems(accountItems[i], childrenCounts);
  		}
  	}

  	for(var j = 0; j < accountItems.length; j++) {
  		if(expanded_nodes_map[accountItems[j].sys_id] != true){
  			this._getChildAccountItems(accountItems[j], childrenCounts);
  		}
  	}
  },

  _getChildAccountItems: function(accountItem, childrenCounts) {
  	item = this.newItem();
  	item.setAttribute('sys_id',  accountItem.sys_id);
  	item.setAttribute('label', accountItem.label);
  	if(childrenCounts[accountItem.sys_id] < 1) {
  		item.setAttribute('has_children', false);
  	} else {
  		item.setAttribute('has_children', true);
  	}
  },

  /**
  * Get login user consumer sys_id
  */
  getConsumerId: function(){
  	var consumer;
  	var key = "consumer_id_" + gs.getUserID();
  	consumer = gs.getSession().getProperty(key);
  	if (consumer == "NIL" || gs.nil(consumer)) {
  		var gr = new GlideRecord("csm_consumer");
  		gr.addQuery('user',gs.getUserID());
  		gr._skip_before_query_filter = true;
  		gr.query();
  		if(gr.next())
  			consumer = gr.getUniqueValue();
  		gs.getSession().putProperty(key, gs.nil(consumer) ? 'NIL' : consumer);
  	}
  	return consumer == 'NIL' ? null : consumer;
  },

  /**
   * param1 - csm_consumer sys_id
   * returns - true if the consumer is active, false otherwise
   */
  isActiveConsumer: function(consumerId) {
  	var gr = new GlideRecord("csm_consumer");
  	gr.addQuery('sys_id', consumerId);
  	gr.addQuery('active', 'true');
  	gr.setLimit(1);
  	gr.setWorkflow(false);
  	gr.query();
  	return gr.hasNext();
  },

  /**
  * Get login user consumer record, return null if consumer record not found for login user
  */
  getConsumerRecord: function(){
  	var gr = new GlideRecord("csm_consumer");
  	if (gr.get(this.getConsumerId()))
  		return gr;

  	return null;
  },

  /**
  * param1 - consumer sys_id
  * return - consumer_user sys_id
  */
  getConsumerUserFromConsumer: function(consumerId) {
  	var consumerRecord = new GlideRecord('csm_consumer');
  	consumerRecord.setWorkflow(false);
  	consumerRecord.get(consumerId);
  	return consumerRecord.user + '';
  },

  verifyCaptcha: function(grc) {
  	try {
  		if(GlideUtil.isDeveloperInstance() || (gs.getProperty('sn_customerservice.captchaEnabled', 'true') == 'false'))
  			return true;
  		else if(grc){
  			// Create REST message to check the passed token with Google recaptcha service:
  			/* eslint-disable no-undef */
  			var r = new sn_ws.RESTMessageV2();
  			/* eslint-disable no-undef */

  			r.setHttpMethod('post');
  			r.setEndpoint('https://www.google.com/recaptcha/api/siteverify');

                              var secret= GlidePropertiesDB.get('google.captcha.secret');
  			r.setQueryParameter('secret', secret);
  			r.setQueryParameter('response', grc);

  			var response = r.execute();

  			var responseBody = response.getBody();

  			var parser = new JSONParser();
  			var parsed = parser.parse(responseBody);

  			return parsed.success;
  		}else
  			return false;


  	}
  	catch(ex) {
  		return false;
  	}
  },

  _deleteContactRoles: function(roles, contactId) {
  	var gr = new GlideRecord('sys_user_has_role');
  	gr.addQuery('role.name', 'IN', roles);
  	gr.addQuery('user', contactId);
  	gr.deleteMultiple();
  },

  _addContactRole: function(role, contactId) {
  	var gr = new GlideRecord('sys_user_has_role');
  	gr.initialize();
  	gr.user = contactId;
  	gr.role = role;
  	gr.insert();
  },

  _getKey: function(name) {
  	var key = name + "_" + gs.getUserID();
  	return key;
  },
  _getCaseSyncProp :function(){
  	return gs.getProperty("sn_customerservice.parent_child_ case_sync",false);
  },
  isChatConversation: function(conversation) {
  	return conversation.type === 'support' && conversation.table === 'chat_queue_entry';
  },
  isAgent: function() {
  	return gs.hasRole('sn_customerservice.consumer_agent') || gs.hasRole('sn_customerservice_agent');
  },
  showConfirmationDialog :function(){
  	var canSync =this._getCaseSyncProp();
  	var modifiedfields= this.getParameter('sysparm_modifiedfields');
  	modifiedfields=JSON.parse(modifiedfields);
  	if(canSync == 'true')
  	{

  		//Additional Check to see if the Record is eligible for Synching
  		var sys_id = this.getParameter("sysparm_parent_sysid");
  		var parentGr = new GlideRecord("sn_customerservice_case");
  		parentGr.get(sys_id);

  		var syncHelper = new sn_customerservice.CSCaseSyncHelper();
  		syncEnabled = syncHelper.isCaseSyncEnabled(parentGr);

  		if(syncEnabled){
  			var childRec = new GlideRecord("sn_customerservice_case");
  			childRec.addQuery("parent", sys_id);
  			childRec.query();
  			if (childRec.next()){
  				var field_list= gs.getProperty('sn_customerservice.case_fields_to_sync','').split(',');
  				for(var i=0; i<field_list.length;i++){

  					var field_name="sn_customerservice_case."+field_list[i].trim();
  					if(field_name in modifiedfields){
  						return true;
  					}
  				}
  			}
  		}
  	}
  	return false;
  },

  //Method to check access to fields under Related Records section on case form
  hasAccessToRelatedRecords:function(){
  	var hasAccess = false;
  	if(pm.isActive(CSMBaseConstants.CASE_DIGEST_PLUGIN)){
  		var caseDigest = new sn_csm_case_digest.CaseDigest();
  		var hasPCRAccess = caseDigest.hasAccessToPCR();
  		var hasCASAccess = caseDigest.hasAccessToCAS();
  		hasAccess = hasPCRAccess || hasCASAccess;
  	}
  	//return true if there is access to any one of the fields
  	return hasAccess;
  },
  filterOnAccountAndProduct: function(currentRec) {
  var refQualifier = '';
  // account and consumer are mutually exclusive.
  if (!currentRec.account.nil())
      refQualifier = 'account=' + currentRec.account;
  else if (!currentRec.consumer.nil())
      refQualifier = 'consumer=' + currentRec.consumer;

  if (!currentRec.product.nil())
      refQualifier = refQualifier + (refQualifier.length > 0 ? '^' : '') +
      'product=' + currentRec.product;
  return refQualifier;
},
  populateEntitlement : function(caseGr) {
  	var entitlement = this.getFirstEntitlement(caseGr);
  	if(!gs.nil(entitlement)) {
  		caseGr.entitlement = entitlement;
  		caseGr.update();
  	}
  },

  /*
  * Get Project Task Details
  */
  getProjectTaskDetails: function() {
  	var result = {};
  	var projectTaskId = this.getParameter('sysparm_projectTask');

  	if(!gs.nil(projectTaskId)){
  		var projectGr = new GlideRecord(sn_csm_ppm.CSMProjectManagementConstants.PROJECT_TASK_TABLE);
  		projectGr.get(projectTaskId);
  		if (!projectGr.canRead())
  			return;

  		result.projectValue = projectGr.sub_tree_root+'';
  		result.projectDisplayValue = projectGr.project_name+'';
  		result.accountValue = projectGr.project_account+'';
  		result.accountDisplayValue = projectGr.sub_tree_root.account.getDisplayValue();

  		return JSON.stringify(result);
  	}
  },

  isCMDBService: function() {
  	var sys_id = this.getParameter("sysparm_sys_id");
  	var result = this.getDocument().createElement("result");
  	this.getRootElement().appendChild(result);

  	var gr = new GlideRecordSecure("cmdb_ci");
  	if (!gr.get(sys_id)) {
  		result.setAttribute("error", "NOT_FOUND");
  		return;
  	}
  	var item = this.getDocument().createElement("item");
  	if(gr.instanceOf('cmdb_ci_service') && !gr.instanceOf('cmdb_ci_service_group'))
  		item.setAttribute("isService", true);
  	else
  		item.setAttribute("isService", false);
  	result.appendChild(item);
  },

  /*
   * Attaches <result><item accountRestricted='${value}'></item></result> to the root xml element
   * ${value} = 'true' if restrict_contact_access for the account 'sysparm_account' is set to true
   *            'false' otherwise
   */
  isRestrictedAccount: function() {
  	var account = this.getParameter('sysparm_account');
  	var result = this.getDocument().createElement('result');
  	this.getRootElement().appendChild(result);
  	var item = this.getDocument().createElement('item');
  	item.setAttribute('accountRestricted', new global.Account().isRestrictedAccessAccount(account) + '');
  	result.appendChild(item);
  },

  /* getEncodedQueryForEntity - return encoded query string
  parameters : table - this is the table name on which the encode query is built
  			 referenceField - the field name to be appeneded throughout the query
  			 encodedQuery - the query that needs to be reconstructed
  How to use :
  			getEncodedQueryForEntity('customer_account', 'account', 'nameLikeBoxeo^cityISCanada')
  			output : account.nameLikeBoxeo^account.cityISCanada
  */
getEncodedQueryForEntity: function(table, referenceField, encodedQuery) {
  if (gs.nil(table) || gs.nil(referenceField) || gs.nil(encodedQuery))
      return;
  var queryString = new GlideQueryString(table, encodedQuery);
  queryString.deserialize();
  var terms = queryString.getTerms();
  var appendedQuery;
  var index;
  var numberOfQueryStrs = terms.size();
  for (index = 0; index < numberOfQueryStrs; index++) {
      var term = terms.get(index);
      if (gs.nil(appendedQuery)) {
          appendedQuery = referenceField + "." + term.getTerm();
      } else {
          switch (true) {
              case (term.isOR()):
                  appendedQuery = appendedQuery + "^OR" + referenceField + "." + term.getTerm();
                  break;
              case (term.isNewQuery()):
                  appendedQuery = appendedQuery + "^NQ" + referenceField + "." + term.getTerm();
                  break;
              case (term.isEndQuery()):
                  continue;
              default:
                  appendedQuery = appendedQuery + "^" + referenceField + "." + term.getTerm();
          }
      }
  }
  return appendedQuery;
},

  checkACLScript: function(current,root_rule){
  	var sm = GlideSecurityManager.get();
      var checkMe = 'record/' + root_rule + '/write';
      return sm.hasRightsTo(checkMe, current);
  },

  isProposeSolnUIActionValid: function(){
  	if((current.major_case_state != 'accepted' && (gs.hasRole("sn_esm_agent") || gs.hasRole('sn_csm_ocs.ext_agent') || gs.hasRole('sn_esm_location_agent') || gs.hasRole('sn_customerservice.relationship_agent'))) || gs.hasRole("sn_majorissue_mgt.major_issue_manager"))
  		return true;
  	return false;
  },

  getShowHTMLProperty: function(){
  	return gs.getProperty(CSMBaseConstants.CASE_DESCRIPTION_SHOW_HTML, false) == 'true';
  },

  getAssociatedInstallBasesGrForCase: function(caseSysId){
  	var installBasesGr = new GlideRecordSecure(CSMBaseConstants.AFFECTED_INSTALL_BASE_TABLE);
  	installBasesGr.addQuery('csm_case', caseSysId);
  	installBasesGr.query();
  	return installBasesGr;
  },

  getRelatedCaseTasksGrForCase: function(caseSysId){
  	var relatedCaseTasksGr = new GlideRecordSecure(CSMBaseConstants.CASE_TASK_TABLE);
  	relatedCaseTasksGr.addQuery('parent', caseSysId);
  	relatedCaseTasksGr.addQuery('visible_to_customer', 'true');
  	relatedCaseTasksGr.query();
  	return relatedCaseTasksGr;
  },

  getRelatedProjectTasksGrForCase: function(sysId){
  	var relatedProjectTasksGr = new GlideRecordSecure(CSMBaseConstants.CASE_TABLE);
  	relatedProjectTasksGr.addQuery('project_task', sysId);
  	relatedProjectTasksGr.query();
  	return relatedProjectTasksGr;
  },

  getStandardTicketTabVisibility: function(caseGr, tabName){
  	var sysId = caseGr.sys_id + '';
  	switch(tabName){
  		case CSMBaseConstants.INSTALL_BASE_TAB:
  			var installBases = this.getAssociatedInstallBasesGrForCase(sysId);
  			while(installBases.next()){
  				if (installBases.getValue("install_base_item"))
  					return sysId;
  			}
  			break;
  		case CSMBaseConstants.RELATED_RECORDS_TAB:
  			if (caseGr.canRead()){
  				var relatedRecords = new sn_customerservice.CSMServiceManagementUtil().getRelatedRecordsAssociatedToCase(caseGr);
  				if (relatedRecords && Object.keys(relatedRecords).length !== 0){
  					if(relatedRecords.hasOwnProperty('problem') && relatedRecords['problem'])
  						return sysId;
  					if(relatedRecords.hasOwnProperty('change') && relatedRecords['change'])
  						return sysId;
  					if(relatedRecords.hasOwnProperty('requests') && relatedRecords['requests'])
  						return sysId;
  					if(relatedRecords.hasOwnProperty('project_change') && relatedRecords['project_change'])
  						return sysId;
  					if(relatedRecords.hasOwnProperty('issue') && relatedRecords['issue'])
  						return sysId;
  				}
  			}
  			break;
  		case CSMBaseConstants.RELATED_CASE_TASKS_TAB:
  			var relatedCaseTasksGr = this.getRelatedCaseTasksGrForCase(sysId);
  			if(relatedCaseTasksGr.hasNext()){
  				return sysId;
  			}
  			break;
  		case CSMBaseConstants.RELATED_PROJECT_TASKS_TAB:
  			var relatedProjectTasks = getRelatedProjectTasksGrForCase(sysId);
  			if(relatedProjectTasks.hasNext()){
  				return sysId;
  			}
  			break;
  		default:return null;
  	}
  	return null;
  },

  getExtensionPoints: function(epName) {
  	var eps = new GlideScriptedExtensionPoint().getExtensions(epName);
  	return eps;
  },

  getContactsFromContactRelationship: function(accounts) {
      if (gs.nil(accounts) || !accounts.length) {
          accounts = [this.getUserAccount()];
      }
      var contacts = [];
      var ac = new GlideRecord(CSMBaseConstants.CONTACT_RELATIONSHIP);
      ac.addQuery('company', 'IN', accounts.join(','));
      ac.query();
      while (ac.next())
          contacts.push(ac.getValue('contact'));
      return contacts;
  },

  getPartnerAccounts: function(account) {
      account = account || this.getUserAccount();
      var accounts = [];
      var ar = new GlideRecord(CSMBaseConstants.ACCOUNT_RELATIONSHIP);
      ar.addQuery('reverse_relationship', false);
      ar.addQuery('to_company', account);
      ar.query();
      while (ar.next())
          accounts.push(ar.getValue('from_company'));
      return accounts;
  },

  getCustomerAccounts: function(account) {
      account = account || this.getUserAccount();
      var accounts = [];
      var ar = new GlideRecord(CSMBaseConstants.ACCOUNT_RELATIONSHIP);
      ar.addQuery('reverse_relationship', false);
      ar.addQuery('from_company', account);
      ar.query();
      while (ar.next())
          accounts.push(ar.getValue('to_company'));
      return accounts;
  },

  setHomePagePreference: function(userID) {
        var userPrefGr = new GlideRecord('sys_user_preference');
        userPrefGr.initialize();
        userPrefGr.setValue('user', userID);
        userPrefGr.setValue('description', 'Default Home Page');
        userPrefGr.setValue('name', 'my_home_navigation_page');
        userPrefGr.setValue('value', 'sn_customerservice_case_list.do?sysparm_userpref_module=e69b84b97313001022139a1ee2f6a7e8&sysparm_query=active=true^assigned_to=javascript:getMyAssignments()^EQ&active=true^assigned_to=javascript:gs.user_id()');
        userPrefGr.insert();
    },

  getNewUniqueUserName: function(current, firstName, lastName) {
      current = current || {};
      firstName = current.first_name || firstName || '';
      lastName = current.last_name || lastName || '';
      if (!firstName && !lastName)
          return;
      var USER_NAME_SEPARATOR = '.';
      userName = ((firstName || '') + (firstName && lastName ? USER_NAME_SEPARATOR : '') + (lastName || '')).toLowerCase();
      userName = userName.split(' ').join(USER_NAME_SEPARATOR);
      var uniqueUserName = userName;
      var counter = 0;
      var isExist = this._isExistingUserID(uniqueUserName);
      while (isExist) {
          counter++;
          uniqueUserName = userName + USER_NAME_SEPARATOR + counter;
          isExist = this._isExistingUserID(uniqueUserName);
      }
      return uniqueUserName;
  },

  _isExistingUserID: function(user_name) {
      var user = new GlideRecord(CSMBaseConstants.USER_TABLE);
      user.addQuery("user_name", user_name);
      user.setWorkflow(false);
      user.query();
      return user.hasNext();
  },

  populateResponsibilityFromType: function() {
  	var table = this.getParameter('sysparm_table');
  	var sysIds = this.getParameter('sysparm_sysIds');
  	var typeId = this.getParameter('sysparm_typeId');

  	if (gs.nil(table) || gs.nil(sysIds) || gs.nil(typeId))
  		return;
  	var typeGr = this.getRelatedPartyConfigGr(typeId);
  	if (gs.nil(typeGr))
  		return;

  	var responsibility = typeGr.default_responsibility + '';
  	var gr = new GlideRecordSecure(table);
  	if (!gr.isValid())
  		return;
  	gr.addQuery('sys_id', 'IN', sysIds);
  	gr.query();
  	while (gr.next()) {
  		gr.setValue('responsibility', responsibility);
  		gr.setValue('type', typeId);
  		gr.update();
  	}
  },

  getRelatedPartyConfigGr: function(sysId) {
  	if (gs.nil(sysId))
  		return;
  	var partyConfig = new GlideRecord(global.CSMBaseConstants.RELATED_PARTY_CONFIG_TABLE);
  	partyConfig.get(sysId);
  	if (partyConfig.canRead())
  		return partyConfig;
  },

  //checks if session user has global agent roles
  checkIfUserHasGlobalFulfillerRoles: function() {
  	if (gs.hasRole("sn_esm_agent") || gs.hasRole("sn_csm_ocs.ext_agent"))
  		return true;
  	return false;
  },

  //first we check for other fulfiller roles, then we check for esm_location_agent and responsibility
  checkIfLoggedInUserCanFulfillCase: function(caseGr){
  	if(this.checkIfUserHasGlobalFulfillerRoles() || gs.hasRole('sn_customerservice.relationship_agent'))
  		return true;
  	if(pm.isActive('com.snc.business_location')){
  		return new global.ServiceOrganizationUtil().isLoggedInLocationAgentFulfillerForCase(caseGr);
  	}
  	return false;
  },
  /*
  * Fetch all the parents of a given account
  *
  * @return list of account sysids (Including the given account).
  */
  getAllParentsOfAccount: function(account) {
  	var list = [];
  	var accountgr = new GlideRecord(global.CSMBaseConstants.ACCOUNT_TABLE);
  	accountgr.addQuery('sys_id', account);
  	accountgr.query();
  	while (accountgr.next()) {
  		list.push(account + '');
  		account = accountgr.account_parent;
  		accountgr = new GlideRecord(global.CSMBaseConstants.ACCOUNT_TABLE);
  		accountgr.addQuery('sys_id', account);
  		accountgr.query();
  	}
  	return list;
  },

  getCaseAccountRefQualifierBLSPPortal: function(variables) {
      var accountGr = new GlideRecord(CSMBaseConstants.ACCOUNT_TABLE);
      accountGr.addQuery('customer', true);
      var orgs = [];
      if (!gs.nil(variables.requesting_service_organization) || !gs.nil(variables.service_organization)) {
          if (!gs.nil(variables.requesting_service_organization)) {
              orgs.push(variables.requesting_service_organization);
          }
          if (!gs.nil(variables.service_organization) && orgs.indexOf(variables.service_organization) < 0) {
              orgs.push(variables.service_organization);
          }
          accountGr.addEncodedQuery(new ServiceOrganizationUtil().getAccountReferenceQualifier(orgs));
      }
      return accountGr.getEncodedQuery();
  },

  /*
   * Function which restricts the Tables  which will be shown in the configuration
   */
  getRelationshipTables: function() {
      var result = [];
  	var relatedPartyTables = [global.CSMBaseConstants.CASE_RELATED_PARTY_TABLE];
  	if (this.isServiceOrganizationPluginActive())
  		relatedPartyTables.push(global.ServiceOrganizationConstants.SO_MEMBER_RESPONSIBILITY_TABLE);
  	if (this.isInstallBasePluginActive()) {
  		relatedPartyTables.push(global.CSMBaseConstants.SOLD_PRODUCT_RELATED_PARTY);
  		relatedPartyTables.push(global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
  	}

  	// Fetch the child tables
  	for (var i = 0; i < relatedPartyTables.length; i++) {
  		var extensions = new TableUtils(relatedPartyTables[i]).getAllExtensions();
  		for (var j = 0; j < extensions.size(); j++) {
  			result.push(extensions.get(j) + "");
  		}
  	}
      return result;
  },

  /*
   * Returns list of CSMRelationshipConstants access levels which together are to be considered as FULL access level
   * FULL access will be considered implicitly with READ, WRITE or CREATE.
   * Example,
   * "Get all cases with READ access level" is same as "Get all cases with access level READ or FULL".
   * "Get all cases with WRITE access level" is same as "Get all cases with access level WRITE or FULL".
   * 
   * However,
   * "Get all cases with FULL access level" does NOT mean "Get all cases with access level READ, WRITE and CREATE".
   */
  getFullAccessLevelList: function() {
  	return [
  		global.CSMRelationshipConstants.ACCESS.READ,
  		global.CSMRelationshipConstants.ACCESS.WRITE,
  		global.CSMRelationshipConstants.ACCESS.CREATE
  	];
  },

  /*
  * returns true if service organization plugin is active.
  */
  isServiceOrganizationPluginActive: function() {
      return GlidePluginManager.isActive(global.CSMBaseConstants.SERVICE_ORGANIZATION_PLUGIN);
  },

  /*
  * returns true if install base plugin is active.
  */
  isInstallBasePluginActive: function() {
  	return GlidePluginManager.isActive(global.CSMBaseConstants.INSTALL_BASE_PLUGIN);
  },

  /*
  * returns true if domain support plugin is active.
  */
  isDomainSupportPluginActive: function() {
  	return GlidePluginManager.isActive(global.CSMBaseConstants.DOMAIN_SUPPORT_PLUGIN);
  },

  getCaseConsumerRefQualifierBLSPPortal: function(variables) {
      var consumerGr = new GlideRecord(CSMBaseConstants.CONSUMER_TABLE);
      var orgs = [];
      var pm = new GlidePluginManager();
      if (pm.isActive('com.snc.service_organization')) {
          if (!gs.nil(variables.requesting_service_organization) || !gs.nil(variables.service_organization)) {
              if (!gs.nil(variables.requesting_service_organization)) {
                  orgs.push(variables.requesting_service_organization);
              }
              if (!gs.nil(variables.service_organization) && orgs.indexOf(variables.service_organization) < 0) {
                  orgs.push(variables.service_organization);
              }
              consumerGr.addEncodedQuery(new ServiceOrganizationUtil().getConsumerReferenceQualifier(orgs));
          }
      }
      return consumerGr.getEncodedQuery();
  },

  type: 'CSManagementUtils'
});