Name

sn_wa_builder.WebArtifactBuilderUtil

Description

No description available

Script

var WebArtifactBuilderUtil = Class.create();
WebArtifactBuilderUtil.prototype = {
  initialize: function() {},
  _replaceAll: function(str, find, replace) {
      return str.replace(new RegExp(find, 'g'), replace);
  },
  _securelyGetRecord: function(table, sysId, fields) {
      try {
          return new global.ACEAppBuilderGlobalScopedUtil().getRecord(table, sysId, fields);
      } catch (e) {
          return null;
      }
  },
  _securelyCreateRecord: function(table, fieldValuePairs) {
      try {
          fieldValuePairs.sys_scope = gs.getCurrentApplicationId();
          return new global.ACEAppBuilderGlobalScopedUtil()._grRecordCreator(table, fieldValuePairs, null);
      } catch (e) {
          return null;
      }
  },
  _securelyUpdateRecord: function(table, sysId, props) {
      try {
          return new global.ACEAppBuilderGlobalScopedUtil().updateRecord(table, sysId, props);
      } catch (e) {
          return null;
      }
  },
  _securelyDeleteRecord: function(table, sysId) {
      try {
          return new global.ACEAppBuilderGlobalScopedUtil().deleteRecord(table, sysId);
      } catch (e) {
          return null;
      }
  },
  _createBlankClientScript: function(controllerId, name) {
      return this._securelyCreateRecord('sys_ux_client_script', {
          name: name,
          macroponent: controllerId
      });
  },
  _createNewClientScripts: function(controllerId, clientScripts) {
      var result = [],
          _self = this;
      clientScripts.forEach(function(item) {
          var id = item.sys_id.startsWith("-") ? _self._createBlankClientScript(controllerId, item.name) : item.sys_id;
          var updateId = _self._securelyUpdateRecord('sys_ux_client_script', id, {
              type: 'default',
              target: 'macroponent',
              script: item.script,
              name: item.name
          });
          if (updateId) {
              result.push({
                  "oldId": item.sys_id,
                  "newId": updateId
              });
          }
      });
      return result;
  },
  _fetchExistingEventByNameAndUserScope: function(userScope, eventName) {
      if (!eventName) return null;
      var query = 'sys_scope=' + userScope + '^event_name=' + eventName;
      var gr = new GlideRecord('sys_ux_event');
      gr.addEncodedQuery(query);
      gr.query();
      if (gr.next()) {
          return gr.sys_id.toString();
      }
      return null;

  },
  _createEvents: function(events) {
      var result = [],
          _self = this,
          table = 'sys_ux_event';
      var userScope = gs.getCurrentApplicationId();
      events.forEach(function(item) {
          var eventId = _self._fetchExistingEventByNameAndUserScope(userScope, item.event_name);
          if (!eventId) eventId = _self._securelyCreateRecord(table, {
              label: item.label,
              event_name: item.event_name,
  			props: item.props
          });
          if (result.indexOf(eventId) == -1) result.push({
              oldId: item.sys_id,
              newId: eventId
          });
      });
      return result;
  },
  _getCurrentMacroponentScope: function(controllerMacrId) {
      var gr = new GlideRecordSecure('sys_ux_macroponent');
      gr.get(controllerMacrId);
      return gr.sys_scope.scope.toString();
  },
  _updateNewController: function(controllerMacprId, payload) {
      try {
          var _self = this;
          var clientScriptMappings, disPatchedEvents, handledEvents, parameters, states, dataResources, externalControllers, internalEventMappings, description, outputMappings;
          //Create the client scripts first and get the mapping ids
          if (payload.ct_scripts && payload.ct_scripts.client_scripts)
              clientScriptMappings = this._createNewClientScripts(controllerMacprId, payload.ct_scripts.client_scripts);
          else
              clientScriptMappings = [];

  		if (payload.ct_scripts && payload.ct_scripts.deleted_scripts) {
  			payload.ct_scripts.deleted_scripts.forEach(function(item) {
  				_self._securelyDeleteRecord('sys_ux_client_script', item);
  			});
  		}

          if (payload.ct_parameters && payload.ct_parameters.all_parameters)
              parameters = JSON.stringify(payload.ct_parameters.all_parameters, null, 4);
          else
              parameters = JSON.stringify([]);

          if (payload.ct_states && payload.ct_states.all_states)
              states = JSON.stringify(payload.ct_states.all_states, null, 4);
          else
              states = JSON.stringify([]);

          if (payload.ct_output_mapping && payload.ct_output_mapping.all_output_mappings)
              outputMappings = JSON.stringify(payload.ct_output_mapping.all_output_mappings, null, 4);
          else
              outputMappings = JSON.stringify([]);

          if (payload.ct_data_resources && payload.ct_data_resources.data_resources)
              dataResources = JSON.stringify(payload.ct_data_resources.data_resources, null, 4);
          else
              dataResources = JSON.stringify([]);

          if (payload.ct_ext_controllers && payload.ct_ext_controllers.external_controllers)
              externalControllers = JSON.stringify(payload.ct_ext_controllers.external_controllers, null, 4);
          else
              externalControllers = JSON.stringify([]);

  		if (payload.ct_internal_event_mappings && payload.ct_internal_event_mappings.internal_event_mappings)
              internalEventMappings = JSON.stringify(payload.ct_internal_event_mappings.internal_event_mappings, null, 4);
          else
              internalEventMappings = JSON.stringify([]);

          description = "Web Artifact Builder controller";
          if (payload.ct_setting && payload.ct_setting.settings && payload.ct_setting.settings.description) description = payload.ct_setting.settings.description;

          clientScriptMappings.forEach(function(item) {
              if (item.oldId !== item.newId) {
                  dataResources = _self._replaceAll(dataResources, item.oldId, item.newId);
                  externalControllers = _self._replaceAll(externalControllers, item.oldId, item.newId);
  				internalEventMappings = _self._replaceAll(internalEventMappings, item.oldId, item.newId);
              }
          });

          //Create the events
  		var dEvents = [], hEvents = [];
          if (payload.ct_events && payload.ct_events.created_events && payload.ct_events.created_events.dispatched_events) {
              dEvents = this._createEvents(payload.ct_events.created_events.dispatched_events);
              disPatchedEvents = [];
              dEvents.forEach(function(item) {
                  dataResources = _self._replaceAll(dataResources, item.oldId, item.newId);
                  externalControllers = _self._replaceAll(externalControllers, item.oldId, item.newId);
  				internalEventMappings = _self._replaceAll(internalEventMappings, item.oldId, item.newId);
                  disPatchedEvents.push(item.newId);
  				disPatchedEvents = disPatchedEvents.join();
              });
          } else {
              disPatchedEvents = "";
  		}

          if (payload.ct_events && payload.ct_events.created_events && payload.ct_events.created_events.handled_events) {
              hEvents = this._createEvents(payload.ct_events.created_events.handled_events);
              handledEvents = [];
              hEvents.forEach(function(item) {
                  dataResources = _self._replaceAll(dataResources, item.oldId, item.newId);
                  externalControllers = _self._replaceAll(externalControllers, item.oldId, item.newId);
  				internalEventMappings = _self._replaceAll(internalEventMappings, item.oldId, item.newId);
                  handledEvents.push(item.newId);
  				handledEvents = handledEvents.join();
              });
          } else {
              handledEvents = "";
  		}

          var currentScopeName = this._getCurrentMacroponentScope(controllerMacprId);
          dataResources = _self._replaceAll(dataResources, 'USER_SCOPE_TO_BE_UPDATED', currentScopeName);
          externalControllers = _self._replaceAll(externalControllers, 'USER_SCOPE_TO_BE_UPDATED', currentScopeName);
  		internalEventMappings = _self._replaceAll(internalEventMappings, 'USER_SCOPE_TO_BE_UPDATED', currentScopeName);

  		// Update dispatched and handled event list
  		var updatedDispatchedEvents = disPatchedEvents || "";
  		if (payload.ct_events.dispatched_events.value) {
  			if (disPatchedEvents) {
  				updatedDispatchedEvents = (payload.ct_events.dispatched_events.value + "," + disPatchedEvents);
  			} else {
  				updatedDispatchedEvents = payload.ct_events.dispatched_events.value;
  			}
  		}
  		var updatedHandledEvents = handledEvents || "";
  		if (payload.ct_events.handled_events.value) {
  			if (handledEvents) {
  				updatedHandledEvents = (payload.ct_events.handled_events.value + "," + handledEvents);
  			} else {
  				updatedHandledEvents = payload.ct_events.handled_events.value;
  			}
  		}

  		//patch the controller
          var updatedMacroponentSysId = _self._securelyUpdateRecord('sys_ux_macroponent', controllerMacprId, {
              props: parameters,
              state_properties: states,
              data: dataResources,
              ext_controller_dep: externalControllers,
  			internal_event_mappings: internalEventMappings,
  			dispatched_events: updatedDispatchedEvents,
  			handled_events: updatedHandledEvents,
              description: description,
              output_prop_mapping: outputMappings
          });
  		return {
  			macroponentSysId: updatedMacroponentSysId,
  			__createdMappings: {
  				client_scripts: clientScriptMappings,
  				dispatched_events: dEvents,
  				handled_events: hEvents
  			},
  			userScope: currentScopeName
  		};

      } catch (e) {
          return null;
      }
  },
  _getControllerName: function(payload) {
      var name = "WAB_Controller_" + Date.now();
      try {
          return payload.ct_setting && payload.ct_setting.settings && payload.ct_setting.settings.name || name;
      } catch (e) {
          return name;
      }
  },
  _insertNewController: function(payload) {
      //Create the base macroponent
      var name = this._getControllerName(payload);
      var controllerMacprId = this._securelyCreateRecord('sys_ux_macroponent', {
          name: name,
          category: 'controller'
      });
      this._securelyCreateRecord('sys_ux_controller', {
          name: name,
          controller_macroponent: controllerMacprId
      });
      return controllerMacprId;
  },
  submitController: function(payload) {
      var controllerMacprId = payload.controllerMacroponentId;
      if (!controllerMacprId || controllerMacprId.toString().indexOf("-") >= 0) controllerMacprId = this._insertNewController(payload);
      return this._updateNewController(controllerMacprId, payload);
  },
  submitPreset: function(payload) {
      if (payload && payload.sys_id) {
          var pairs = {
              properties: JSON.stringify(payload.properties, null, 4),
              event_handlers: JSON.stringify(payload.event_handlers, null, 4),
              name: payload.name
          };
          if (payload.component) pairs.component = payload.component;
          if (payload.controller) pairs.controller = payload.controller;
          return this._securelyUpdateRecord('sys_ux_component_preset', payload.sys_id, pairs);
      }
      return null;
  },
  _getWABScopeID: function(){
  	var gr = new GlideRecord('sys_store_app');
  	gr.addEncodedQuery('scope=sn_wa_builder');
  	gr.query();
  	if(gr.next()) return gr.sys_id.toString();
  	return null;
  },
  _getArtifactScope: function(table, sysId){
  	var gr = new GlideRecord(table);
      var returnData = {
          editAccess: gr.canWrite()
      };
  	if(gr.get(sysId)){
  		returnData.scope = gr.sys_scope.toString();
  	}
  	return returnData;
  },
  _getControllerId: function(presetId){
  	if(!presetId) return null;
  	if(presetId.toString() === '-1') return null;
  	var gr = new GlideRecord('sys_ux_component_preset');
  	if(gr.get(presetId)){
  		return {
  			controller: gr.controller.toString(),
  			macroponent: gr.controller.controller_macroponent.toString()
  		};
  	}
  	return null;
  },
  getScopeDetails: function(presetId, controllerId){
  	var response = {};
  	response.wab_scope_id = this._getWABScopeID();
  	response.current_user_scope = gs.getCurrentApplicationId();
      var presetAccessDetails = presetId ? this._getArtifactScope('sys_ux_component_preset', presetId) : {
          editAccess: false,
          scope: null
      };
      var controllerAccessDetails = controllerId ? this._getArtifactScope('sys_ux_controller', controllerId) : {
          editAccess: false,
          scope: null
      };
  	response.preset_scope = presetAccessDetails.scope;
  	response.controller_scope = controllerAccessDetails.scope;
      response.preset_access = presetAccessDetails.editAccess;
      response.controller_access = controllerAccessDetails.editAccess;
  	response.controller_id_verified = null;
  	response.controller_macroponent_id_verified = null;
  	var verifiedIds = this._getControllerId(presetId);
  	if(verifiedIds){
  		response.controller_id_verified = verifiedIds.controller;
  		response.controller_macroponent_id_verified = verifiedIds.macroponent;
  	}
  	return response;
  },
  type: 'WebArtifactBuilderUtil'
};

Sys ID

6b5e0cf6c33421104b8e88c7c840ddf9

Offical Documentation

Official Docs: