Name

sn_theme_builder.ThemeRepository

Description

No description available

Script

var ThemeRepository = Class.create();
ThemeRepository.getScopeErrorMessage = function(scopeDisplayValue) {
  return gs.getMessage('This view is read-only. To edit, change your application scope to {0}.', scopeDisplayValue);
};
ThemeRepository.addDomainQueryToGR = function(gr) {
  gr.addQuery(Constants.SYS_DOMAIN_COLUMN_FIELD, ThemeRepository.getDomainId());
};
ThemeRepository.getQueryAfterAddingDomainToQueryArray = function(queryArray) {
  return queryArray.concat(['^sys_domain=', ThemeRepository.getDomainId()]).join(Constants.EMPTY_STR);
};
ThemeRepository.getDomainId = function() {
  return gs.getSession().getCurrentDomainID() || Constants.GLOBAL_DOMAIN_ID;
};
ThemeRepository.getScopeId = function() {
  return gs.getSession().getCurrentApplicationId() || 'global';
};
ThemeRepository.isScopeSame = function(recordScopeId, userScopeId) {
  return recordScopeId === userScopeId;
}
ThemeRepository.isStyleObjectNil = function(parsedStyle) {
  return gs.nil(parsedStyle) || gs.nil(parsedStyle.properties) || gs.nil(parsedStyle.base);
};
ThemeRepository._appendRGB = function(rgbVal) {
  return ['rgb(', rgbVal, ')'].join(Constants.EMPTY_STR);
};
ThemeRepository.initializeGR = function(table, fields) {
  var gr = new GlideRecord(table);
  gr.initialize();
  Object.keys(fields).forEach(function(key) {
      gr.setValue(key, fields[key]);
  });
  return gr;
};
ThemeRepository.getGR = function(table, query) {
  var gr = new GlideRecordSecure(table);
  gr.addEncodedQuery(query);
  gr.query();
  if (gr.next()) {
      return gr;
  }
  return null;
};
ThemeRepository.createGR = function(table, fields) {
  var gr = ThemeRepository.initializeGR(table, fields);
  if (gr.canCreate()) {
      gr.insert();
      return gr;
  }
  return null;
};
ThemeRepository.getUniqueValueAfterInsert = function(table, fields) {
  return ThemeRepository.initializeGR(table, fields).insert();
};
ThemeRepository.getUniqueNameForDuplicateTheme = function(table, name) {
  var nameStr = name + ' Copy';
  var count = 0;
  var arrayLength = nameStr.split(' ').length;
  var themeGR = new GlideRecord(table);
  themeGR.addQuery('name', 'CONTAINS', nameStr);
  themeGR.query();
  while (themeGR.next()) {
      var nameGR = themeGR.getValue('name');
      var nameGRArray = nameGR.split(' ');
      var grArrLength = nameGRArray.length;
      if (nameGR === nameStr && count <= 2) {
          count = 2;
      } else {
          if (arrayLength + 1 === grArrLength &&
              count <= parseInt(nameGRArray[grArrLength - 1])) {
              count = parseInt(nameGRArray[grArrLength - 1]) + 1;
          }
      }
  }
  if (count === 0) return nameStr;
  else return nameStr + ' ' + (count);
};
ThemeRepository.getUniqueNameForDuplicateGroup = function(name) {
      var nameStr = name + ' Copy';
      var count = 0;
      var arrayLength = nameStr.split(' ').length;
      var customizationGR = new GlideRecordSecure(Constants.SYS_UX_THEME_CUSTOMIZATION_TABLE_NAME);
      customizationGR.query();
      while (customizationGR.next()) {
          var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
          var groupName = customizationObj['groupName'];
          var nameGRArray = groupName.split(' ');
          var grArrLength = nameGRArray.length;
          if (groupName === nameStr && count <= 2) {
              count = 2;
          } else {
              if (arrayLength + 1 === grArrLength &&
                  count <= parseInt(nameGRArray[grArrLength - 1])) {
                  count = parseInt(nameGRArray[grArrLength - 1]) + 1;
              }
          }
      }
      if (count === 0) return nameStr;
      else return nameStr + ' ' + (count);
  },
  ThemeRepository.getUniqueNameForDuplicateVariant = function(name, styleType) {
      if (styleType !== Constants.STYLE_VARIANT_TYPE) return name;
      var nameStr = name + ' Copy';
      var count = 0;
      var arrayLength = nameStr.split(' ').length;
      var styleGr = new GlideRecord(Constants.SYS_UX_STYLE_TABLE_NAME);
      styleGr.addQuery('name', 'CONTAINS', nameStr);
      styleGr.query();
      while (styleGr.next()) {
          var nameGR = styleGr.getValue('name');
          var nameGRArray = nameGR.split(' ');
          var grArrLength = nameGRArray.length;
          if (nameGR === nameStr && count <= 2) {
              count = 2;
          } else {
              if (arrayLength + 1 === grArrLength &&
                  count <= parseInt(nameGRArray[grArrLength - 1])) {
                  count = parseInt(nameGRArray[grArrLength - 1]) + 1;
              }
          }
      }
      if (count === 0) return nameStr;
      else return nameStr + ' ' + (count);
  };
ThemeRepository.updateGR = function(table, query, fields) {
  var gr = new GlideRecordSecure(table);
  gr.addEncodedQuery(query);
  gr.query();
  if (gr.next()) {
      Object.keys(fields).forEach(function(key) {
          gr.setValue(key, fields[key]);
      });
      if (gr.update()) {
          return gr;
      }
  }
  return null;
};
ThemeRepository.isThemeCreatedByTB = function(themeId) {
  var customizationGR = ThemeRepository.getCustomizationGR(themeId);
  if (!customizationGR) {
      return false;
  }
  return true;
};
ThemeRepository.getThemeDescription = function(gr) {
  return gr[Constants.DESCRIPTION_COLUMN_FIELD][Constants.VALUE];
};
ThemeRepository.getScope = function(gr) {
  return {
      id: gr[Constants.SYS_SCOPE_COLUMN_FIELD][Constants.VALUE],
      label: gr[Constants.SYS_SCOPE_COLUMN_FIELD][Constants.DISPLAY_VALUE]
  };
};
ThemeRepository.getDomain = function(gr) {
  var domainObj = {};
  if (gs.nil(gr)) {
      return domainObj;
  }
  try {
      domainObj.id = gr[Constants.SYS_DOMAIN_COLUMN_FIELD] && gr[Constants.SYS_DOMAIN_COLUMN_FIELD][Constants.VALUE];
      domainObj.label = gr[Constants.SYS_DOMAIN_COLUMN_FIELD] && gr[Constants.SYS_DOMAIN_COLUMN_FIELD][Constants.DISPLAY_VALUE];
      domainObj.path = gr[Constants.SYS_DOMAIN_PATH] && gr[Constants.SYS_DOMAIN_PATH][Constants.VALUE];
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while accessing the domain details:' + e.toString());
  }
  return domainObj;
};
ThemeRepository.updatePrimaryColorInJSONObj = function(jsonObj, primaryColor) {
  jsonObj.base[Constants.PRIMARY_COLOR_HOOK_NAME] = primaryColor;
  jsonObj.base[Constants.SURFACE_BRAND_COLOR_HOOK_NAME] = primaryColor;
  jsonObj.base[Constants.SELECTION_PRIMARY_COLOR_HOOK_NAME] = primaryColor;
  jsonObj.base[Constants.CHROME_BRAND_COLOR_HOOK_NAME] = primaryColor;
  jsonObj.base[Constants.CHROME_DIVIDER_COLOR_HOOK_NAME] = primaryColor;
  jsonObj.base[Constants.INTERACTIVE_COLOR_HOOK_NAME] = primaryColor;
  jsonObj.properties[Constants.BRAND_PRIMARY_COLOR_HOOK_NAME] = primaryColor;
};
ThemeRepository.updateSecondaryColorInJSONObj = function(jsonObj, secondaryColor) {
  jsonObj.base[Constants.SECONDARY_COLOR_HOOK_NAME] = secondaryColor;
  jsonObj.base[Constants.SELECTION_SECONDARY_COLOR_HOOK_NAME] = secondaryColor;
  jsonObj.base[Constants.SURFACE_BRAND_COLOR_HOOK_NAME] = secondaryColor;
  jsonObj.properties[Constants.BRAND_SECONDARY_COLOR_HOOK_NAME] = secondaryColor;
};
ThemeRepository.updateNeutralColorInJSONObj = function(jsonObj, neutralColor) {
  jsonObj.base[Constants.NEUTRAL_COLOR_HOOK_NAME] = neutralColor;
  jsonObj.base[Constants.SECONDARY_NAV_BRAND_COLOR_HOOK_NAME] = neutralColor;
  jsonObj.base[Constants.SECONDARY_NAV_DIVIDER_COLOR_HOOK_NAME] = neutralColor;
  jsonObj.properties[Constants.BRAND_NEUTRAL_COLOR_HOOK_NAME] = neutralColor;
};
ThemeRepository.getInitialColors = function() {
  var styleObj = JSON.parse(JSON.stringify(Constants.INITIAL.colors));
  ThemeRepository.updatePrimaryColorInJSONObj(styleObj, Constants.PRIMARY_COLOR_RGB_DEFAULT);
  ThemeRepository.updateSecondaryColorInJSONObj(styleObj, Constants.SECONDARY_COLOR_RGB_DEFAULT);
  ThemeRepository.updateNeutralColorInJSONObj(styleObj, Constants.NEUTRAL_COLOR_RGB_DEFAULT);
  return JSON.stringify(styleObj);
};
ThemeRepository.validateNameInput = function(name) {
  if (gs.nil(name)) {
      return false;
  }
  var trimmedName = name.trim();
  var length = trimmedName.length;
  return length >= Constants.MINLENGTH && length < Constants.MAXLENGTH;
};

ThemeRepository.transformCustomizationObjToStr = function(sourceObj) {
  var destinationObj = {
      colors: [],
      typography: [],
      feedback: [],
      groupName: '',
      variants: [],
  };

  var sourceColors = sourceObj.colors;
  var destinationColors = destinationObj.colors;
  var sourceVariants = sourceObj.variants;
  var destinationVariants = destinationObj.variants;
  if (!gs.nil(sourceObj.groupName))
      destinationObj.groupName = sourceObj.groupName;

  ThemeRepository.transformColorsToArray(sourceColors, destinationColors);
  if (sourceVariants) {
      Object.keys(sourceVariants).forEach(function(variantId) {
          var variantObj = {};
          var sourceVariantObj = sourceVariants[variantId];
          variantObj.id = variantId;
          variantObj.colors = [];
          if (sourceVariantObj.colors)
              ThemeRepository.transformColorsToArray(sourceVariantObj.colors, variantObj.colors);
          destinationVariants.push(variantObj);
      });
  }
  var sourceTypography = sourceObj.typography;
  var destinationTypography = destinationObj.typography;
  if (sourceTypography.customizedNames) {
      Object.keys(sourceTypography.customizedNames).forEach(function(id) {
          destinationTypography.push(ThemeRepository.getEntityObject(id, sourceTypography.customizedNames[id], Constants.CUSTOMIZED_NAME));
      });
  }
  var sourceFeedback = sourceObj.feedback;
  var destinationFeedback = destinationObj.feedback;
  if (sourceFeedback) {
      Object.keys(sourceFeedback).forEach(function(id) {
          destinationFeedback.push(ThemeRepository.getEntityObject(id, sourceFeedback[id], Constants.FEEDBACK));
      });
  }
  // Extend this logic to other types, such as imagery, shape, and theme.
  if (destinationColors.length === 0) {
      delete destinationObj.colors;
  }
  if (destinationVariants.length === 0) {
      delete destinationObj.variants;
  }
  if (destinationTypography.length === 0) {
      delete destinationObj.typography;
  }
  if (destinationFeedback.length === 0) {
      delete destinationObj.destinationFeedback;
  }
  return Object.keys(destinationObj).length === 0 ? Constants.EMPTY_STR : JSON.stringify(destinationObj);
};
ThemeRepository.getAppliedThemeCustomization = function(themeId) {
  var syspropGR = new GlideRecord('sys_properties');
  syspropGR.addQuery('name=glide.ui.polaris.theme.custom');
  syspropGR.query();
  if (syspropGR.next()) {
      if (syspropGR.value == themeId)
          return {
              id: 'applied',
              value: themeId,
              type: 'applied_theme'
          }
  }
};
ThemeRepository.transformCustomizationStrToObject = function(sourceStr) {
  var destinationObj = {
      colors: {
          customizedNames: {},
          contrastRatioViolations: {},
          overrides: {},
          isSecondaryColorUpdated: false
      },
      typography: {
          customizedNames: {}
      },
      feedback: {},
      groupName: '',
      variants: {}
  };
  if (gs.nil(sourceStr)) {
      return destinationObj;
  }
  var sourceObj = JSON.parse(sourceStr);
  var sourceColors = sourceObj.colors;
  if (!gs.nil(sourceObj.groupName))
      destinationObj.groupName = sourceObj.groupName;
  if (sourceColors && Array.isArray(sourceColors)) {
      var destinationColors = destinationObj.colors;
      sourceColors.forEach(function(obj) {
          switch (obj.type) {
              case Constants.CUSTOMIZED_NAME:
                  destinationColors.customizedNames[obj.id] = obj.value;
                  break;
              case Constants.CONTRAST_RATIO_VIOLATED:
                  destinationColors.contrastRatioViolations[obj.id] = obj.value;
                  break;
              case Constants.COLOR_HOOK_OVERRIDDEN:
                  destinationColors.overrides[obj.id] = obj.value;
                  break;
              case Constants.SECONDARY_COLOR_UPDATED:
                  destinationColors.isSecondaryColorUpdated = obj.value;
                  break;
          }
      });
  }
  var sourceVariants = sourceObj.variants;
  if (sourceVariants && Array.isArray(sourceVariants)) {
      var destinationVariants = destinationObj.variants;
      sourceVariants.forEach(function(sourceVariant) {
          var variantColors = sourceVariant.colors;
          var variantId = sourceVariant.id;
          destinationVariants[variantId] = {
              colors: {
                  customizedNames: {},
                  contrastRatioViolations: {},
                  overrides: {},
                  isSecondaryColorUpdated: false
              }
          };
          variantColors.forEach(function(variantColor) {
              switch (variantColor.type) {
                  case Constants.CUSTOMIZED_NAME:
                      destinationVariants[variantId].colors.customizedNames[variantColor.id] = variantColor.value;
                      break;
                  case Constants.CONTRAST_RATIO_VIOLATED:
                      destinationVariants[variantId].colors.contrastRatioViolations[variantColor.id] = variantColor.value;
                      break;
                  case Constants.COLOR_HOOK_OVERRIDDEN:
                      destinationVariants[variantId].colors.overrides[variantColor.id] = variantColor.value;
                      break;

                  case Constants.SECONDARY_COLOR_UPDATED:
                      destinationVariants[variantId].colors.isSecondaryColorUpdated = variantColor.value;
                      break;
              }
          });
      });
  }
  var sourceTypography = sourceObj.typography;
  if (sourceTypography && Array.isArray(sourceTypography)) {
      var destinationTypography = destinationObj.typography;
      sourceTypography.forEach(function(obj) {
          switch (obj.type) {
              case Constants.CUSTOMIZED_NAME:
                  destinationTypography.customizedNames[obj.id] = obj.value;
                  break;
          }
      });
  }
  var sourceFeedback = sourceObj.feedback;
  if (sourceFeedback && Array.isArray(sourceFeedback)) {
      var destinationFeedback = destinationObj.feedback;
      sourceFeedback.forEach(function(obj) {
          switch (obj.type) {
              case Constants.FEEDBACK:
                  destinationFeedback[obj.id] = obj.value;
                  break;
          }
      });
  }
  //Extend this logic to other types, such as imagery, shape, and theme.
  return destinationObj;
};
ThemeRepository.getEntityObject = function(id, value, type) {
  return {
      id: id,
      value: value,
      type: type
  };
};
ThemeRepository.validateRGB = function(colorRGB) {
  var rgbArray = colorRGB.split(Constants.COMMA);
  var length = rgbArray.length;
  if (!length === 3) {
      return false;
  }
  for (var i = 0; i < length; i++) {
      try {
          var value = parseInt(rgbArray[i]);
          if (!(value >= Constants.MINVAL && value <= Constants.MAXVALUE)) {
              return false;
          }
      } catch (er) {
          return false;
      }
  }
  return true;
};
ThemeRepository.validateAdditionalColorsInput = function(additional) {
  if (additional && Array.isArray(additional)) {
      for (var i = 0; i < additional.length; i++) {
          if (!ThemeRepository.validateRGB(additional[i])) {
              return false;
          }
      }
  }
  return true;
};
ThemeRepository.validateColorsInput = function(primary, secondary, neutral) {
  if (primary) {
      if (!ThemeRepository.validateRGB(primary)) {
          return false;
      }
  }
  if (secondary) {
      if (!ThemeRepository.validateRGB(secondary)) {
          return false;
      }
  }
  if (neutral) {
      if (!ThemeRepository.validateRGB(neutral)) {
          return false;
      }
  }
  return true;
};
ThemeRepository.getFileNameAndExtension = function(fileName) {
  if (!fileName) return null;
  var extMatch = fileName.match(Constants.FILE_EXTENSION_REGEX);
  if (!extMatch) return null;
  return {
      fileName: extMatch[1],
      extension: extMatch[2]
  };
};
ThemeRepository.uploadFile = function(record, fileName, fileType, file) {
  return new GlideSysAttachment().writeBase64(record, fileName, fileType, file);
};
ThemeRepository.deleteFile = function(table, id) {
  var attachmentGR = new GlideRecord(Constants.SYS_ATTACHEMENT_TABLE_NAME);
  attachmentGR.addQuery(Constants.TABLE_NAME_COLUMN_FIELD, table);
  attachmentGR.addQuery(Constants.TABLE_ID_COLUMN_FIELD, id);
  attachmentGR.query();
  if (attachmentGR.next()) {
      new GlideSysAttachment().deleteAttachment(attachmentGR.sys_id);
      return true;
  }
  return false;
};
ThemeRepository.getTBCreatedThemeIds = function() {
  var themeIds = [];
  var customizationGR = new GlideRecordSecure(Constants.SYS_UX_THEME_CUSTOMIZATION_TABLE_NAME);
  customizationGR.addActiveQuery();
  ThemeRepository.addDomainQueryToGR(customizationGR);
  customizationGR.query();
  while (customizationGR.next()) {
      themeIds.push(customizationGR.getValue(Constants.THEME_COLUMN_FIELD));
  }
  return themeIds;
};
ThemeRepository.getCustomizationGR = function(themeId) {
  var customizationGR = new GlideRecordSecure(Constants.SYS_UX_THEME_CUSTOMIZATION_TABLE_NAME);
  customizationGR.setLimit(1);
  customizationGR.addActiveQuery();
  if (themeId) {
      customizationGR.addQuery(Constants.THEME_COLUMN_FIELD, themeId);
  }
  ThemeRepository.addDomainQueryToGR(customizationGR);
  customizationGR.query();
  if (customizationGR.next()) {
      return customizationGR;
  }
  return null;
};
ThemeRepository.getTheme = function(themeId) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      if (!ThemeRepository.isThemeCreatedByTB(themeId) && !ThemeRepository.isThemeReadOnly(themeId)) {
          logObject.message = gs.getMessage('You need to get permission to view this theme. Contact your system administrator for permission.');
          return logObject;
      }
      var themeGR = new GlideRecordSecure(Constants.SYS_UX_THEME_TABLE_NAME);
      themeGR.setLimit(1);
      themeGR.addActiveQuery();
      themeGR.addQuery(Constants.SYS_ID_COLUMN_FIELD, themeId);
      ThemeRepository.addDomainQueryToGR(themeGR);
      themeGR.query();
      if (themeGR.next()) {
          return themeGR;
      }
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while accessing the theme: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to get your theme. Try it again or contact your system administrator for more help.');
      return logObject;
  }
  return logObject;
};
ThemeRepository.getAllThemes = function(encodedQuery) {
  try {
      var themesGR = new GlideRecordSecure(Constants.SYS_UX_THEME_TABLE_NAME);
      themesGR.addActiveQuery();
      var TBCreatedThemeIds = ThemeRepository.getTBCreatedThemeIds();
      TBCreatedThemeIds = ThemeRepository.getReadOnlyThemeIds().concat(TBCreatedThemeIds);
      themesGR.addQuery(Constants.SYS_ID_COLUMN_FIELD, Constants.IN_OPERATOR, TBCreatedThemeIds);
      ThemeRepository.addDomainQueryToGR(themesGR);
      if (encodedQuery) themesGR.addEncodedQuery(encodedQuery);
      else {
          var sortEncodedQuery = 'ORDERBY';
          var sortByGr = ThemeRepository.getGR(Constants.SYS_USER_PREFERENCE_TABLE_NAME, 'name=' + Constants.USER_PREFERENCE_SORT_BY);
          var sortByDirGr = ThemeRepository.getGR(Constants.SYS_USER_PREFERENCE_TABLE_NAME, 'name=' + Constants.USER_PREFERENCE_SORT_DIRECTION);
          if (!gs.nil(sortByDirGr) && sortByDirGr.getValue(Constants.VALUE) === 'DESC') sortEncodedQuery += 'DESC';
          if (!gs.nil(sortByGr)) {
              sortEncodedQuery += sortByGr.getValue(Constants.VALUE);
              themesGR.addEncodedQuery(sortEncodedQuery);
          }
      }
      themesGR.query();
      return themesGR;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while accessing the themes: ' + e.toString());
      return [];
  }
};
ThemeRepository.getMobileThemes = function() {
  var mobileThemeGR = new GlideRecordSecure(Constants.SYS_SG_NATIVE_CLIENT_TABLE_NAME);
  mobileThemeGR.query();
  return mobileThemeGR;
};
ThemeRepository.getStyleType = function(styleRecord) {
  try {
      switch (styleRecord.name.value) {
          case Constants.IMAGERY_STYLE_TYPE:
              return Constants.IMAGERY_STYLE_GRAPHQL_TYPE;
          case Constants.TYPOGRAPHY_STYLE_TYPE:
              return Constants.TYPOGRAPHY_STYLE_GRAPHQL_TYPE;
          case Constants.COLORS_STYLE_TYPE:
              return Constants.COLORS_STYLE_GRAPHQL_TYPE;
          case Constants.SHAPE_STYLE_TYPE:
              return Constants.SHAPE_STYLE_GRAPHQL_TYPE;
          default:
              return Constants.UNKNOWN_STYLE_GRAPHQL_TYPE;
      }
  } catch (e) {
      return Constants.UNKNOWN_STYLE_GRAPHQL_TYPE;
  }
};
ThemeRepository.getThemeStyles = function(themeId) {
  var themeStyleIds = [];
  var themeStyleM2M = new GlideRecordSecure(Constants.M2M_THEME_STYLE_TABLE_NAME);
  themeStyleM2M.addQuery(Constants.THEME_COLUMN_FIELD, themeId);
  themeStyleM2M.query();
  while (themeStyleM2M.next()) {
      themeStyleIds.push(themeStyleM2M.getValue(Constants.STYLE_COLUMN_FIELD));
  }
  var stylesGR = new GlideRecordSecure(Constants.SYS_UX_STYLE_TABLE_NAME);
  stylesGR.addQuery(Constants.SYS_ID_COLUMN_FIELD, themeStyleIds);
  stylesGR.query();
  return stylesGR;
};
ThemeRepository.getColors = function(styleStr) {
  var styleObj = JSON.parse(styleStr);
  if (ThemeRepository.isStyleObjectNil(styleObj)) {
      return null;
  }
  var colors = {};
  colors.primary = ThemeRepository._appendRGB(styleObj.properties[Constants.BRAND_PRIMARY_COLOR_HOOK_NAME]);
  colors.secondary = ThemeRepository._appendRGB(styleObj.properties[Constants.BRAND_SECONDARY_COLOR_HOOK_NAME]);
  colors.neutral = ThemeRepository._appendRGB(styleObj.properties[Constants.BRAND_NEUTRAL_COLOR_HOOK_NAME]);
  colors.additional = [];
  var additionalColorsRegex = Constants.ADDITIONAL_COLORS_REFERENCE_REGEX;
  var match = null;
  while ((match = additionalColorsRegex.exec(styleStr)) != null) {
      colors.additional.push(ThemeRepository._appendRGB(styleObj.properties[match[0]]));
  }
  return colors;
};
ThemeRepository.getTypographyStyle = function(styleStr) {
  var typography = {};
  if (gs.nil(styleStr)) {
      return typography;
  }
  var styleObj = JSON.parse(styleStr);
  var fontFamily = styleObj.properties[Constants.NOW_FONT_FAMILY_HOOK_NAME];
  if (fontFamily) {
      typography.value = fontFamily.split(Constants.COMMA)[0];
  }
  return typography;
};
ThemeRepository.getShapeStyle = function(styleStr) {
  var shape = {};
  if (gs.nil(styleStr)) {
      return shape;
  }
  var styleObj = JSON.parse(styleStr);
  shape.value = styleObj.properties[Constants.ACTIONABLE_BORDER_RADIUS_HOOK_NAME];
  return shape;
};
ThemeRepository.isHeaderLogo = function(m2mProperties) {
  if (gs.nil(m2mProperties)) {
      return false;
  }
  return JSON.parse(m2mProperties).position === Constants.IMAGE_LOCATION;
};
ThemeRepository.getLogosStyle = function(styleId) {
  var logos = [];
  var assetIds = [];
  var styleAssetM2M = new GlideRecordSecure(Constants.M2M_STYLE_ASSET_TABLE_NAME);
  styleAssetM2M.addQuery(Constants.STYLE_COLUMN_FIELD, styleId);
  styleAssetM2M.query();
  while (styleAssetM2M.next()) {
      var currLogo = {};
      currLogo.props = styleAssetM2M.getValue(Constants.PROPERTIES_COLUMN_FIELD);
      if (ThemeRepository.isHeaderLogo(currLogo.props)) {
          currLogo.m2mStyleAssetId = styleAssetM2M.getUniqueValue();
          currLogo.assetId = styleAssetM2M.getValue(Constants.ASSET_COLUMN_FIELD);
          logos.push(currLogo);
          assetIds.push(currLogo.assetId);
          break;
      }
  }
  var logosData = {};
  var attachment = new GlideRecordSecure(Constants.SYS_ATTACHEMENT_TABLE_NAME);
  attachment.addQuery(Constants.TABLE_ID_COLUMN_FIELD, assetIds);
  attachment.query();
  var gsAttachment = new GlideSysAttachment();
  while (attachment.next()) {
      logosData[attachment.getValue(Constants.TABLE_ID_COLUMN_FIELD)] = {
          file: gsAttachment.getContentBase64(attachment),
          fileName: attachment.getValue(Constants.FILE_NAME_COLUMN_FIELD),
          fileType: attachment.getValue(Constants.CONTENT_TYPE_COLUMN_FIELD),
          attachmentId: attachment.getUniqueValue()
      };
  }
  return logos.map(function(logo) {
      var logoData = logosData[logo.assetId] || {};
      logo.file = logoData.file;
      logo.fileName = logoData.fileName;
      logo.fileType = logoData.fileType;
      logo.attachmentId = logoData.attachmentId;
      return logo;
  });
};
ThemeRepository.getAllExperiences = function() {
  var experiences = [];
  var adminConfigIds = [];
  var experienceGR = new GlideRecordSecure(Constants.SYS_UX_PAGE_REGISTRY_TABLE_NAME);
  experienceGR.addActiveQuery();
  // pull the children of the unified navigation app shell
  experienceGR.addEncodedQuery(
      'parent_app=c86a62e2c7022010099a308dc7c26022^admin_panel_table=sys_ux_app_config'
  );
  experienceGR.query();
  while (experienceGR.next()) {
      var experience = {
          id: experienceGR.getUniqueValue(),
          title: experienceGR.getValue(Constants.TITLE_COLUMN_FIELD),
          basePath: experienceGR.getValue(Constants.PATH_COLUMN_FIELD),
          adminPanelID: experienceGR.getValue(Constants.ADMIN_PANEL_COLUMN_FIELD)
      };
      adminConfigIds.push(experience.adminPanelID);
      experiences.push(experience);
  }
  var adminConfigGR = new GlideRecordSecure(Constants.SYS_UX_APP_CONFIG_TABLE_NAME);
  adminConfigGR.addActiveQuery();
  adminConfigGR.addQuery(Constants.SYS_ID_COLUMN_FIELD, adminConfigIds);
  adminConfigGR.query();
  var configData = {};
  while (adminConfigGR.next()) {
      configData[adminConfigGR.getUniqueValue()] = adminConfigGR.getValue(Constants.LANDING_PATH_COLUMN_FIELD);
  }
  experiences.forEach(function(experience) {
      experience.uri = [Constants.NOW, experience.basePath, configData[experience.adminPanelID]]
          .join(Constants.FORWARD_SLASH);
      return experience;
  });
  return experiences.filter(function(experience) {
      var appRouteGR = new GlideRecordSecure(Constants.SYS_UX_APP_ROUTE_TABLE_NAME);
      appRouteGR.addQuery(Constants.APP_CONFIG_COLUMN_FIELD, experience.adminPanelID);
      appRouteGR.addQuery(Constants.ROUTE_TYPE_COLUMN_FIELD, configData[experience.adminPanelID]);
      appRouteGR.query();
      return appRouteGR.next();
  });
};
ThemeRepository.deleteTheme = function(deleteThemeInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE,
  };
  try {
      var themeId = deleteThemeInput.id;
      var themeGR = ThemeRepository.getTheme(themeId);
      if (gs.nil(themeGR) || ThemeRepository.isThemeReadOnly(themeId)) {
          logObject.message = gs.getMessage('You need to get permission to delete this theme. Contact your system administrator for permission.');
          return logObject;
      }
      var themeStyleIds = [];
      var imageryStyleId;
      var themeStylesGR = ThemeRepository.getThemeStyles(themeId);
      var themeStyleM2M = new GlideRecordSecure(Constants.M2M_THEME_STYLE_TABLE_NAME);
      themeStyleM2M.addQuery(Constants.THEME_COLUMN_FIELD, themeId);
      themeStyleM2M.query();
      while (themeStylesGR.next()) {
          var styleName = themeStylesGR.getValue(Constants.NAME_COLUMN_FIELD);
          if (styleName === Constants.IMAGERY_STYLE_TYPE)
              imageryStyleId = themeStylesGR.getUniqueValue();
          themeStyleIds.push(themeStylesGR.getUniqueValue());
      }
      var imageryAssetId = '';
      var styleAssetM2M = new GlideRecordSecure(Constants.M2M_STYLE_ASSET_TABLE_NAME);
      styleAssetM2M.addQuery(Constants.STYLE_COLUMN_FIELD, themeStyleIds);
      styleAssetM2M.query();
      while (styleAssetM2M.next()) {
          if (styleAssetM2M.getValue(Constants.STYLE_COLUMN_FIELD) === imageryStyleId)
              imageryAssetId = styleAssetM2M.getValue(Constants.ASSET_COLUMN_FIELD);
      }
      var customizedGR = ThemeRepository.getCustomizationGR(themeId);
      if (!customizedGR.deleteRecord()) {
          if (ThemeRepository.isScopeSame(customizedGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              logObject.message = gs.getMessage('You need to get permission to delete this theme. Contact your system administrator for permission.');
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(customizedGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      }
      if (imageryAssetId !== '') {
          ThemeRepository.deleteFile(Constants.SYS_UX_THEME_ASSET_TABLE_NAME, imageryAssetId);
          var assetGR = new GlideRecordSecure(Constants.SYS_UX_THEME_ASSET_TABLE_NAME);
          assetGR.addQuery(Constants.SYS_ID_COLUMN_FIELD, imageryAssetId);
          assetGR.query();
          assetGR.deleteMultiple();
      }
      themeStyleM2M.deleteMultiple();
      styleAssetM2M.deleteMultiple();
      themeStylesGR.deleteMultiple();
      themeGR.deleteRecord();
      return {
          value: themeId
      };
  } catch (e) {
      gs.error(
          Constants.THEME_BUILDER_PREFIX +
          'Error while deleting the theme: ' +
          e.toString()
      );
      logObject.message = gs.getMessage('There was an error when trying to delete the theme. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.createDuplicateTheme = function(createDuplicateThemeInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE,
  };
  try {
      var originalThemeId = createDuplicateThemeInput.id;
      var originalThemeGR = ThemeRepository.getTheme(originalThemeId);
      if (gs.nil(originalThemeGR) || ThemeRepository.isThemeReadOnly(originalThemeId)) {
          return logObject;
      }
      var newThemeName = ThemeRepository.getUniqueNameForDuplicateTheme(Constants.SYS_UX_THEME_TABLE_NAME, originalThemeGR.getValue(Constants.NAME_COLUMN_FIELD));
      var duplicateThemeGR = ThemeRepository.createGR(
          Constants.SYS_UX_THEME_TABLE_NAME, {
              name: newThemeName,
              description: originalThemeGR.getValue(Constants.DESCRIPTION_COLUMN_FIELD),
          }
      );
      if (gs.nil(duplicateThemeGR)) {
          logObject.message = gs.getMessage('You need to get permission to duplicate this theme. Contact your system administrator for permission.');
          return logObject;
      }
      var duplicateThemeId = duplicateThemeGR.getUniqueValue();
      var originalStylesGR = ThemeRepository.getThemeStyles(originalThemeId);
      var duplicateStylesMapper = {};
      var originalStyleIdsMapper = {};
      var variantIdMapper = {};
      while (originalStylesGR.next()) {
          var styleName = originalStylesGR.getValue(Constants.NAME_COLUMN_FIELD);
          originalStyleIdsMapper[styleName] =
              originalStylesGR.getUniqueValue();
          var styleId = (duplicateStylesMapper[styleName] =
              ThemeRepository.getUniqueValueAfterInsert(
                  Constants.SYS_UX_STYLE_TABLE_NAME, {
                      name: ThemeRepository.getUniqueNameForDuplicateVariant(originalStylesGR.getValue(Constants.NAME_COLUMN_FIELD), originalStylesGR.getValue(Constants.TYPE_COLUMN_FIELD)),
                      type: originalStylesGR.getValue(Constants.TYPE_COLUMN_FIELD),
                      style: originalStylesGR.getValue(Constants.STYLE_COLUMN_FIELD),
                  }
              ));
          ThemeRepository.getUniqueValueAfterInsert(
              Constants.M2M_THEME_STYLE_TABLE_NAME, {
                  theme: duplicateThemeId,
                  style: styleId,
              }
          );
          var type = originalStylesGR.getValue(Constants.TYPE_COLUMN_FIELD); 
          if (type === 'variant') {
              var oldStyleId = originalStylesGR.getUniqueValue();
              variantIdMapper[oldStyleId] = styleId;
          }
      }
      Constants.UPLOAD_FONTS.forEach(function(font) {
          ThemeRepository.getUniqueValueAfterInsert(
              Constants.M2M_STYLE_ASSET_TABLE_NAME, {
                  style: duplicateStylesMapper[Constants.TYPOGRAPHY_STYLE_TYPE],
                  asset: font.asset,
                  properties: font.properties,
              }
          );
      });
      var originalImageryId = originalStyleIdsMapper[Constants.IMAGERY_STYLE_TYPE];
      var logoStyles = ThemeRepository.getLogosStyle(originalImageryId);
      if (logoStyles && Array.isArray(logoStyles) && logoStyles.length > 0) {
          var logo = logoStyles[0];
          var assetGR = ThemeRepository.createGR(
              Constants.SYS_UX_THEME_ASSET_TABLE_NAME, {
                  name: logo.fileName || Constants.EMPTY_STR,
                  category: Constants.IMAGE_CATEGORY_VALUE,
              }
          );
          if (!gs.nil(logo.file)) {
              ThemeRepository.uploadFile(
                  assetGR,
                  logo.fileName,
                  logo.fileType,
                  logo.file
              );
          }
          ThemeRepository.createGR(Constants.M2M_STYLE_ASSET_TABLE_NAME, {
              properties: logo.props,
              style: duplicateStylesMapper[Constants.IMAGERY_STYLE_TYPE],
              asset: assetGR.getUniqueValue(),
          });
      }
      var customizedDuplicateGR =
          ThemeRepository.getCustomizationGR(originalThemeId);
      var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizedDuplicateGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
      var customizationStr = customizedDuplicateGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD);
      var groupName = customizationObj['groupName'];
      if (!gs.nil(groupName)) {
          var duplicatedGroupName = ThemeRepository.getUniqueNameForDuplicateGroup(groupName);
          customizationObj['groupName'] = duplicatedGroupName;
          customizationStr = ThemeRepository.transformCustomizationObjToStr(customizationObj);
          for (var oldVariantId in variantIdMapper) {
             customizationStr = customizationStr.replace(oldVariantId, variantIdMapper[oldVariantId]);
          }
      }
      ThemeRepository.createGR(
          Constants.SYS_UX_THEME_CUSTOMIZATION_TABLE_NAME, {
              name: customizedDuplicateGR.getValue(Constants.NAME_COLUMN_FIELD),
              theme: duplicateThemeId,
              customization: customizationStr,
          }
      );
      return duplicateThemeGR;
  } catch (e) {
      gs.error(
          Constants.THEME_BUILDER_PREFIX +
          'Error while duplicating the theme: ' +
          e.toString()
      );
      logObject.message = gs.getMessage('There was an error when trying to duplicate the theme. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.createVariant = function(createVariantInput) {
  try {
      var name = createVariantInput.name;
      var groupName = createVariantInput.groupName;
      var themeId = createVariantInput.themeId;
      var variantSysId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
          name: name,
          type: Constants.STYLE_VARIANT_TYPE,
          style: ThemeRepository.getInitialColors(),
      });
      ThemeRepository.getUniqueValueAfterInsert(Constants.M2M_THEME_STYLE_TABLE_NAME, {
          theme: themeId,
          style: variantSysId
      });
      var customizationGR = ThemeRepository.getCustomizationGR(themeId);
      var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
      var themeGr = ThemeRepository.getGR(Constants.SYS_UX_THEME_TABLE_NAME, 'sys_id=' + themeId);
      if (!gs.nil(customizationObj) && !gs.nil(groupName)) {
          customizationObj['groupName'] = groupName;
          customizationObj.variants[variantSysId] = {};
          customizationGR.setValue(Constants.CUSTOMIZATION_COLUMN_FIELD, ThemeRepository.transformCustomizationObjToStr(customizationObj));
          customizationGR.update();
      }
      return themeGr;
  } catch (e) {
      gs.error(
          Constants.THEME_BUILDER_PREFIX +
          'Error while duplicating the theme: ' +
          e.toString()
      );
  }
};
ThemeRepository.createTheme = function(createThemeInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var name = createThemeInput.name;
      if (!ThemeRepository.validateNameInput(name)) {
          logObject.message = gs.getMessage('There was an error when adding your theme name. Try adding it again.');
          return logObject;
      }
      var themeGR = ThemeRepository.createGR(Constants.SYS_UX_THEME_TABLE_NAME, {
          name: name,
          description: createThemeInput.description || Constants.EMPTY_STR
      });
      if (gs.nil(themeGR)) {
          logObject.message = gs.getMessage('You need to get permission to create this theme. Contact your system administrator for permission.');
          return logObject;
      }
      var themeId = themeGR.getUniqueValue();
      var initial = Constants.INITIAL;
      var colorsStyleId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
          name: Constants.COLORS_STYLE_TYPE,
          type: Constants.STYLE_CORE_TYPE,
          style: ThemeRepository.getInitialColors()
      });
      var shapeStyleId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
          name: Constants.SHAPE_STYLE_TYPE,
          type: Constants.STYLE_CORE_TYPE,
          style: JSON.stringify(initial.shape)
      });
      var imageStyleId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
          name: Constants.IMAGERY_STYLE_TYPE,
          type: Constants.STYLE_CORE_TYPE,
          style: JSON.stringify(initial.imagery)
      });
      var typographyStyleId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
          name: Constants.TYPOGRAPHY_STYLE_TYPE,
          type: Constants.STYLE_CORE_TYPE,
          style: JSON.stringify(initial.typography)
      });
      var mobileStyleId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
          name: Constants.MOBILE_STYLE_TYPE,
          type: Constants.STYLE_CORE_TYPE,
          style: JSON.stringify(initial.mobile)
      });
      [colorsStyleId, shapeStyleId, imageStyleId, typographyStyleId, mobileStyleId].forEach(function(styleId) {
          ThemeRepository.getUniqueValueAfterInsert(Constants.M2M_THEME_STYLE_TABLE_NAME, {
              theme: themeId,
              style: styleId
          });
      });
      Constants.UPLOAD_FONTS.forEach(function(font) {
          ThemeRepository.getUniqueValueAfterInsert(Constants.M2M_STYLE_ASSET_TABLE_NAME, {
              style: typographyStyleId,
              asset: font.asset,
              properties: font.properties
          });
      });
      ThemeRepository.createGR(Constants.SYS_UX_THEME_CUSTOMIZATION_TABLE_NAME, {
          name: name,
          theme: themeId
      });
      return themeGR;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while creating the theme: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to create your theme. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.updateTheme = function(updateThemeInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var name = updateThemeInput.name;
      var description = updateThemeInput.description;
      var themeId = updateThemeInput.id;
      if (!ThemeRepository.validateNameInput(name)) {
          logObject.message = gs.getMessage('There was an error when adding your theme name. Try adding it again.');
          return logObject;
      }
      var themeGR = ThemeRepository.getGR(Constants.SYS_UX_THEME_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, themeId]));
      var message = gs.getMessage('You need to get permission to update this theme. Contact your system administrator for permission.');
      if (gs.nil(themeGR)) {
          logObject.message = gmessage;
          return logObject;
      }
      themeGR.setValue(Constants.NAME_COLUMN_FIELD, name);
      themeGR.setValue(Constants.DESCRIPTION_COLUMN_FIELD, description);
      if (!themeGR.update()) {
          if (ThemeRepository.isScopeSame(themeGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              logObject.message = message;
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(themeGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      } else {
          return themeGR;
      }
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the theme: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to update your theme. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.updateThemeRecordForMobile = function(themeId) {
  try {
      if (themeId) {
          var grThemeStyle = new GlideRecordSecure('m2m_theme_style');
          grThemeStyle.addQuery('theme', themeId);
          grThemeStyle.query();
          var hasMobileStyle = false;
          var grStyle = new GlideRecordSecure('sys_ux_style');
          while (grThemeStyle.next()) {
              var styleId = grThemeStyle.getValue('style');
              grStyle.get(styleId);
              var styleObj = JSON.parse(grStyle.getValue('style'));
              if (styleObj.nativeMobile) {
                  hasMobileStyle = true;
                  break;
              }
          }
          if (!hasMobileStyle) {
              var mobileStyleId = ThemeRepository.getUniqueValueAfterInsert(Constants.SYS_UX_STYLE_TABLE_NAME, {
                  name: Constants.MOBILE_STYLE_TYPE,
                  type: Constants.STYLE_CORE_TYPE,
                  style: JSON.stringify(Constants.INITIAL.mobile)
              });
              ThemeRepository.getUniqueValueAfterInsert(Constants.M2M_THEME_STYLE_TABLE_NAME, {
                  theme: themeId,
                  style: mobileStyleId
              });
          }
      }
      return true;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the mobile theme: ' + e.toString());
      return false;
  }
};
ThemeRepository.getGeneratedColors = function(styleInput) {
  try {
      var styleObj = JSON.parse(styleInput);
      var props = GlideUxTheme.processBaseProperties(styleObj.base, styleObj.isDark, styleObj.colorGenerationVersion);
      return JSON.stringify(props);
  } catch (e) {
      return {};
  }
};
ThemeRepository.getCustomizationObj = function(themeId) {
  var customizationGR = ThemeRepository.getCustomizationGR(themeId);
  if (gs.nil(customizationGR)) {
      return {
          messageType: Constants.ERROR_LOG_TYPE,
          message: gs.getMessage('You need to get permission to view this customization. Contact your system administrator for permission.')
      }
  }
  var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
  var appliedTheme = ThemeRepository.getAppliedThemeCustomization(themeId);
  if (appliedTheme) {
      customizationObj['theme'] = [appliedTheme];
  }
  // Don't send feedback to frontend
  delete customizationObj.feedback;
  return {
      id: customizationGR.getUniqueValue(),
      value: JSON.stringify(customizationObj)
  };
};
ThemeRepository.getCustomization = function(themeId) {
  if (themeId === Constants.POLARIS_THEME_ID) return null;
  var customizationGR = ThemeRepository.getCustomizationGR(themeId);
  var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
  var appliedTheme = ThemeRepository.getAppliedThemeCustomization(themeId);
  if (appliedTheme) {
      customizationObj['theme'] = [appliedTheme];
  }
  // Don't send feedback to frontend
  delete customizationObj.feedback;
  return {
      id: customizationGR.getUniqueValue(),
      value: JSON.stringify(customizationObj)
  };
};
ThemeRepository.updateAdditionalBrandColors = function(updateAdditionalBrandColorsInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var styleId = updateAdditionalBrandColorsInput.id;
      var additional = updateAdditionalBrandColorsInput.additional;
      var themeStyleM2M = new GlideRecordSecure(Constants.M2M_THEME_STYLE_TABLE_NAME);
      themeStyleM2M.addQuery(Constants.STYLE_COLUMN_FIELD, styleId);
      themeStyleM2M.query();
      if (!ThemeRepository.validateAdditionalColorsInput(additional) || !themeStyleM2M.next()) {
          logObject.message = gs.getMessage('There was an error when adding your color. Try adding it again.');
          return logObject;
      }
      var styleGR = ThemeRepository.getGR(Constants.SYS_UX_STYLE_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, styleId]));
      var message = gs.getMessage('You need to get permission to update this color. Contact your system administrator for permission.');
      if (gs.nil(styleGR)) {
          logObject.message = message;
          return logObject;
      }
      var styleStr = styleGR.getValue(Constants.STYLE_COLUMN_FIELD);
      var styleObj = JSON.parse(styleStr);
      if (additional && Array.isArray(additional)) {
          var match = null;
          while ((match = Constants.ADDITIONAL_COLORS_REFERENCE_REGEX.exec(styleStr)) != null) {
              delete styleObj.properties[match[0]];
          }
          additional.forEach(function(color, index) {
              styleObj.properties[Constants.ADDITIONAL_COLORS_REFERENCE_PREFIX + index] = color;
          });
          styleGR.setValue(Constants.STYLE_COLUMN_FIELD, JSON.stringify(styleObj));
          if (!styleGR.update()) {
              if (ThemeRepository.isScopeSame(styleGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                      ThemeRepository.getScopeId())) {
                  logObject.message = message;
              } else {
                  logObject.message = ThemeRepository.getScopeErrorMessage(styleGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
              }
              return logObject;
          }
      }
      return styleGR;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the additional brand colors: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to update color. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.updateBrandColors = function(updateBrandColorsInput) {
  try {
      var primary = updateBrandColorsInput.primary;
      var secondary = updateBrandColorsInput.secondary;
      var neutral = updateBrandColorsInput.neutral;
      var additional = updateBrandColorsInput.additional;
      var propertyOverrides = updateBrandColorsInput.propertyOverrides;
      var styleId = updateBrandColorsInput.id;
      var themeId = updateBrandColorsInput.themeId;
      var isSecondaryColorUpdated = updateBrandColorsInput.isSecondaryColorUpdated;
      var isVariant = updateBrandColorsInput.isVariant;
      var logObject = {
          messageType: Constants.ERROR_LOG_TYPE
      };
      var themeStyleM2M = new GlideRecordSecure(Constants.M2M_THEME_STYLE_TABLE_NAME);
      themeStyleM2M.addQuery(Constants.STYLE_COLUMN_FIELD, styleId);
      themeStyleM2M.query();
      if (!ThemeRepository.validateColorsInput(primary, secondary, neutral) || !themeStyleM2M.next()) {
          logObject.message = gs.getMessage('There was an error when adding your color. Try adding it again.');
          return logObject;
      }
      var customizationGR = ThemeRepository.getCustomizationGR(themeId);
      var message = gs.getMessage('You need to get permission to update this color. Contact your system administrator for permission.');
      if (gs.nil(customizationGR)) {
          logObject.message = message;
          return logObject;
      }
      var styleGR = ThemeRepository.getGR(Constants.SYS_UX_STYLE_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, styleId]));
      if (gs.nil(styleGR)) {
          logObject.message = message;
          return logObject;
      }
      var styleStr = styleGR.getValue(Constants.STYLE_COLUMN_FIELD);
      var styleObj = JSON.parse(styleStr);
      if (primary) {
          ThemeRepository.updatePrimaryColorInJSONObj(styleObj, primary);
      }
      if (secondary) {
          ThemeRepository.updateSecondaryColorInJSONObj(styleObj, secondary);
      }
      if (neutral) {
          ThemeRepository.updateNeutralColorInJSONObj(styleObj, neutral);
      }
      if (additional && Array.isArray(additional)) {
          var match = null;
          while ((match = Constants.ADDITIONAL_COLORS_REFERENCE_REGEX.exec(styleStr)) != null) {
              delete styleObj.properties[match[0]];
          }
          additional.forEach(function(color, index) {
              styleObj.properties[Constants.ADDITIONAL_COLORS_REFERENCE_PREFIX + index] = color;
          });
      }
      var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
      var appliedTheme = ThemeRepository.getAppliedThemeCustomization(themeId);
      if (appliedTheme) {
          customizationObj['theme'] = [appliedTheme];
      }

      var customizedColors;
      if (isVariant) {
          customizedColors = customizationObj['variants'][styleId].colors;
      } else {
          customizedColors = customizationObj.colors;
      }

      if (customizedColors) {
          for (var color in customizedColors.overrides) {
              styleObj.base[color] = customizedColors.overrides[color];
          };
      }

      if (propertyOverrides && Array.isArray(propertyOverrides)) {
          propertyOverrides.forEach(function(propertyOverride) {
              styleObj.properties[propertyOverride.id] = propertyOverride.value;
          });
      }
      styleGR.setValue(Constants.STYLE_COLUMN_FIELD, JSON.stringify(styleObj));
      if (!styleGR.update()) {
          if (ThemeRepository.isScopeSame(styleGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              logObject.message = message;
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(styleGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      }
      // Also update contrast ratio violations
      if (isSecondaryColorUpdated) {
          if (isVariant && customizationObj.variants.hasOwnProperty([styleId])) {
              customizationObj.variants[styleId].colors.isSecondaryColorUpdated = isSecondaryColorUpdated;

          } else {
              if (!customizationObj.colors.isSecondaryColorUpdated) {
                  customizationObj.colors.isSecondaryColorUpdated = isSecondaryColorUpdated;

              }
          }
          customizationGR.setValue(Constants.CUSTOMIZATION_COLUMN_FIELD, ThemeRepository.transformCustomizationObjToStr(customizationObj));
          customizationGR.update();

      }
      return styleGR;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the brand colors: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to update color. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.updateStyle = function(styleId, properties, actionType) {
  var styleGR = ThemeRepository.getGR(Constants.SYS_UX_STYLE_TABLE_NAME,
      ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, styleId]));
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  var themeStyleM2M = new GlideRecordSecure(Constants.M2M_THEME_STYLE_TABLE_NAME);
  themeStyleM2M.addQuery(Constants.STYLE_COLUMN_FIELD, styleId);
  themeStyleM2M.query();
  var shapeMessage = gs.getMessage('You need to get permission to update this shape. Contact your system administrator for permission.');
  var typographyMessage = gs.getMessage('You need to get permission to update this typography. Contact your system administrator for permission.');
  if (gs.nil(styleGR) || !themeStyleM2M.next()) {
      switch (actionType) {
          case 'shape':
              logObject.message = shapeMessage;
              break;
          case 'typography':
              logObject.message = typographyMessage;
              break;
      }
      return logObject;
  }
  var styleStr = styleGR.getValue(Constants.STYLE_COLUMN_FIELD);
  var styleObj = JSON.parse(styleStr);
  if (properties && Array.isArray(properties) && properties.length > 0) {
      properties.forEach(function(property) {
          styleObj.properties[property.id] = property.value;
      });
      styleGR.setValue(Constants.STYLE_COLUMN_FIELD, JSON.stringify(styleObj));
      if (!styleGR.update()) {
          if (ThemeRepository.isScopeSame(styleGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              switch (actionType) {
                  case 'shape':
                      logObject.message = shapeMessage;
                      break;
                  case 'typography':
                      logObject.message = typographyMessage;
                      break;
              }
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(styleGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      }
  }
  return styleGR;
};
ThemeRepository.updateShape = function(updateShapeInput) {
  try {
      return ThemeRepository.updateStyle(updateShapeInput.id, updateShapeInput.properties, 'shape');
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the shape: ' + e.toString());
      return {
          messageType: Constants.ERROR_LOG_TYPE,
          message: gs.getMessage('There was an error when trying to update the shape. Try it again or contact your system administrator for more help.')
      };
  }
};
ThemeRepository.updateTypography = function(updateTypographyInput) {
  try {
      return ThemeRepository.updateStyle(updateTypographyInput.id, updateTypographyInput.properties, 'typography');
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the typography: ' + e.toString());
      return {
          messageType: Constants.ERROR_LOG_TYPE,
          message: gs.getMessage('There was an error when trying to update the typography. Try it again or contact your system administrator for more help.')
      };
  }
};
ThemeRepository.createLogo = function(createLogoInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var styleId = createLogoInput.styleId;
      var file = createLogoInput.file;
      var fileName = createLogoInput.fileName;
      var fileType = createLogoInput.fileType;
      var logoProperties = JSON.stringify({
          position: Constants.IMAGE_LOCATION
      }, null, 2);
      var fileInfo = ThemeRepository.getFileNameAndExtension(fileName);
      if (gs.nil(fileInfo)) {
          logObject.message = gs.getMessage('There was an error when adding your logo. Try adding it again.');
          return logObject;
      }
      var styleGR = ThemeRepository.getGR(Constants.SYS_UX_STYLE_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, styleId]));
      var message = gs.getMessage('You need to get permission to create this logo. Contact your system administrator for permission.');
      if (gs.nil(styleGR)) {
          logObject.message = message;
          return logObject;
      }
      var assetGR = null;
      var createM2MRecord = true;
      var m2mStyleAsset = ThemeRepository.getGR(Constants.M2M_STYLE_ASSET_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.STYLE_QUERY_KEY, styleId]));
      if (m2mStyleAsset) {
          // If logo existed already.
          var assetId = m2mStyleAsset.getValue(Constants.ASSET_COLUMN_FIELD);
          assetGR = ThemeRepository.getGR(Constants.SYS_UX_THEME_ASSET_TABLE_NAME,
              ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, assetId]));
          if (gs.nil(assetGR)) {
              logObject.message = message;
              return logObject;
          }
          assetGR.setValue(Constants.NAME_COLUMN_FIELD, fileInfo.fileName);
          if (!assetGR.update()) {
              if (ThemeRepository.isScopeSame(assetGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                      ThemeRepository.getScopeId())) {
                  logObject.message = message;
              } else {
                  logObject.message = ThemeRepository.getScopeErrorMessage(assetGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
              }
              return logObject;
          }
          ThemeRepository.deleteFile(Constants.SYS_UX_THEME_ASSET_TABLE_NAME, assetId);
          createM2MRecord = false;
      } else {
          assetGR = ThemeRepository.createGR(Constants.SYS_UX_THEME_ASSET_TABLE_NAME, {
              name: fileInfo.fileName,
              category: Constants.IMAGE_CATEGORY_VALUE
          });
          if (gs.nil(assetGR)) {
              logObject.message = message;
              return logObject;
          }
      }
      ThemeRepository.uploadFile(assetGR, fileName, fileType, file);
      if (createM2MRecord) {
          ThemeRepository.createGR(Constants.M2M_STYLE_ASSET_TABLE_NAME, {
              properties: logoProperties,
              style: styleGR.getUniqueValue(),
              asset: assetGR.getUniqueValue()
          });
      }
      return styleGR;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error creating the logo: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to create your logo. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.updateLogo = function(updateLogoInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var assetId = updateLogoInput.assetId;
      var file = updateLogoInput.file;
      var fileName = updateLogoInput.fileName;
      var fileType = updateLogoInput.fileType;
      var fileInfo = ThemeRepository.getFileNameAndExtension(fileName);
      if (gs.nil(fileInfo)) {
          logObject.message = gs.getMessage('There was an error when adding your logo. Try adding it again.');
          return logObject;
      }
      var assetGR = ThemeRepository.getGR(Constants.SYS_UX_THEME_ASSET_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, assetId]));
      var message = gs.getMessage('You need to get permission to update this logo. Contact your system administrator for permission.');
      if (gs.nil(assetGR)) {
          logObject.message = message;
          return logObject;
      }
      assetGR.setValue(Constants.NAME_COLUMN_FIELD, fileInfo.fileName);
      if (!assetGR.update()) {
          if (ThemeRepository.isScopeSame(assetGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              logObject.message = message;
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(assetGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      }
      ThemeRepository.deleteFile(Constants.SYS_UX_THEME_ASSET_TABLE_NAME, assetId);
      return {
          value: ThemeRepository.uploadFile(assetGR, fileName, fileType, file)
      };
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error updating the logo: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to update your logo. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.removeLogo = function(removeLogoInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var m2mStyleAssetId = removeLogoInput.m2mStyleAssetId;
      var m2mStyleAssetGR = ThemeRepository.getGR(Constants.M2M_STYLE_ASSET_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, m2mStyleAssetId]));
      var message = gs.getMessage('You need to get permission to remove this logo. Contact your system administrator for permission.');
      if (gs.nil(m2mStyleAssetGR)) {
          logObject.message = message;
          return logObject;
      }
      var assetId = m2mStyleAssetGR.getValue(Constants.ASSET_COLUMN_FIELD);
      var assetGR = ThemeRepository.getGR(Constants.SYS_UX_THEME_ASSET_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, assetId]));
      if (gs.nil(assetGR)) {
          logObject.message = message;
          return logObject;
      }
      if (!(m2mStyleAssetGR.deleteRecord() && ThemeRepository.deleteFile(Constants.SYS_UX_THEME_ASSET_TABLE_NAME, assetId) &&
              assetGR.deleteRecord())) {
          if (ThemeRepository.isScopeSame(assetGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              logObject.message = gs.getMessage('It looks like someone else already did that. Try refreshing your page to see an updated view.');
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(assetGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      }
      return {
          value: true
      };
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error removing the logo: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to remove the logo. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.updateColorOverride = function(updateColorOverrideInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE
  };
  try {
      var styleId = updateColorOverrideInput.id;
      var themeId = updateColorOverrideInput.themeId;
      var override = updateColorOverrideInput.override;
      var propertyOverrides = updateColorOverrideInput.propertyOverrides;
      var isVariant = updateColorOverrideInput.isVariant;
      if (!ThemeRepository.validateRGB(override.value)) {
          logObject.message = gs.getMessage('There was an error when adding your color. Try adding it again.');
          return logObject;
      }
      var customizationGR = ThemeRepository.getCustomizationGR(themeId);
      var message = gs.getMessage('You need to get permission to update this color. Contact your system administrator for permission.');
      if (gs.nil(customizationGR)) {
          logObject.message = message;
          return logObject;
      }
      var styleGR = ThemeRepository.getGR(Constants.SYS_UX_STYLE_TABLE_NAME,
          ThemeRepository.getQueryAfterAddingDomainToQueryArray([Constants.SYS_ID_QUERY_KEY, styleId]));
      if (gs.nil(styleGR)) {
          logObject.message = message;
          return logObject;
      }
      var styleStr = styleGR.getValue(Constants.STYLE_COLUMN_FIELD);
      var styleObj = JSON.parse(styleStr);
      styleObj.base[override.id] = override.value;
      if (propertyOverrides && Array.isArray(propertyOverrides)) {
          propertyOverrides.forEach(function(propertyOverride) {
              styleObj.properties[propertyOverride.id] = propertyOverride.value;
          });
      }
      styleGR.setValue(Constants.STYLE_COLUMN_FIELD, JSON.stringify(styleObj));
      if (!styleGR.update()) {
          if (ThemeRepository.isScopeSame(styleGR.getValue(Constants.SYS_SCOPE_COLUMN_FIELD),
                  ThemeRepository.getScopeId())) {
              logObject.message = message;
          } else {
              logObject.message = ThemeRepository.getScopeErrorMessage(styleGR.getDisplayValue(Constants.SYS_SCOPE_COLUMN_FIELD));
          }
          return logObject;
      }
      var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
      var appliedTheme = ThemeRepository.getAppliedThemeCustomization(themeId);
      if (appliedTheme) {
          customizationObj['theme'] = [appliedTheme];
      }
      if (isVariant) {
          if (!customizationObj.variants)
              customizationObj.variants = {};
          if (!customizationObj.variants[styleId]) {
              customizationObj.variants[styleId] = {
                  colors: {
                      overrides: {}
                  }
              };
          }
          customizationObj.variants[styleId].colors.overrides[override.id] = override.value;
      } else {
          customizationObj.colors.overrides[override.id] = override.value;
      }

      customizationGR.setValue(Constants.CUSTOMIZATION_COLUMN_FIELD, ThemeRepository.transformCustomizationObjToStr(customizationObj));
      customizationGR.update();
      return styleGR;
  } catch (e) {
      gs.error(Constants.THEME_BUILDER_PREFIX + 'Error while updating the color overrides: ' + e.toString());
      logObject.message = gs.getMessage('There was an error when trying to update the colors. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.addFeedback = function(feedback) {
  var TRUE = true;
  if (gs.nil(feedback)) {
      return TRUE;
  }
  var customizationGR = new GlideRecordSecure(Constants.SYS_UX_THEME_CUSTOMIZATION_TABLE_NAME);
  customizationGR.setLimit(1);
  customizationGR.addActiveQuery();
  customizationGR.addQuery(Constants.SYS_ID_COLUMN_FIELD, '9745147a53a31110d7bcddeeff7b1231');
  customizationGR.query();
  if (customizationGR.next()) {
      var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
      var count = Object.keys(customizationObj.feedback).length;
      customizationObj.feedback[count + Constants.EMPTY_STR] = feedback;
      customizationGR.setValue(Constants.CUSTOMIZATION_COLUMN_FIELD, ThemeRepository.transformCustomizationObjToStr(customizationObj));
      customizationGR.update();
  }
  return TRUE;
};
ThemeRepository.getThemeResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.THEME_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getCustomizationResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.CUSTOMIZATION_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getColorsStyleResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.COLORS_STYLE_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getShapeStyleResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.SHAPE_STYLE_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getTypographyStyleResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.TYPOGRAPHY_STYLE_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getImageryStyleResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.IMAGERY_STYLE_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getBooleanResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.BOOLEAN_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.getStringResultType = function(resultObject) {
  return gs.nil(resultObject.messageType) ? Constants.STRING_GRAPHQL_TYPE : Constants.LOGGER_GRAPHQL_TYPE;
};
ThemeRepository.isThemeReadOnly = function(themeId) {
  return ThemeRepository.getReadOnlyThemeIds().indexOf(themeId) >= 0;
};
ThemeRepository.getReadOnlyThemeIds = function() {
  return [Constants.POLARIS_THEME_ID, Constants.USWDS_THEME_ID];
};
ThemeRepository.deleteVariant = function(deleteVariantInput) {
  var logObject = {
      messageType: Constants.ERROR_LOG_TYPE,
  };
  try {
      var styleId = deleteVariantInput.id;
      var themeId = deleteVariantInput.themeId;
      var themeGR = ThemeRepository.getTheme(themeId);
      if (gs.nil(themeGR) || ThemeRepository.isThemeReadOnly(themeId)) {
          logObject.message = gs.getMessage('You need to get permission to delete this theme. Contact your system administrator for permission.');
          return logObject;
      }
      var customizationGR = ThemeRepository.getCustomizationGR(themeId);
      if (customizationGR) {
          var customizationObj = ThemeRepository.transformCustomizationStrToObject(customizationGR.getValue(Constants.CUSTOMIZATION_COLUMN_FIELD));
          if (customizationObj.variants) {
              delete customizationObj.variants[styleId];

          }
          var customizationStr = ThemeRepository.transformCustomizationObjToStr(customizationObj);
          customizationGR.setValue(Constants.CUSTOMIZATION_COLUMN_FIELD, customizationStr);
          customizationGR.update();
      }
      var themeStyleM2M = new GlideRecordSecure(Constants.M2M_THEME_STYLE_TABLE_NAME);
      themeStyleM2M.addQuery(Constants.THEME_COLUMN_FIELD, themeId);
      themeStyleM2M.addQuery(Constants.STYLE_COLUMN_FIELD, styleId);
      themeStyleM2M.query();
      if (themeStyleM2M.next()) themeStyleM2M.deleteMultiple();
      var styleGr = new GlideRecordSecure(Constants.SYS_UX_STYLE_TABLE_NAME);
      styleGr.get(styleId);
      if (styleGr.next()) styleGr.deleteRecord();
      return themeGR;
  } catch (e) {
      gs.error(
          Constants.THEME_BUILDER_PREFIX +
          'Error while deleting the variant: ' +
          e.toString()
      );
      logObject.message = gs.getMessage('There was an error when trying to delete the variant. Try it again or contact your system administrator for more help.');
      return logObject;
  }
};
ThemeRepository.transformColorsToArray = function(sourceColors, destinationColors) {

  if (sourceColors.isSecondaryColorUpdated) {
      destinationColors.push(ThemeRepository.getEntityObject(Constants.IS_SECONDARY_COLOR_UPDATED, true, Constants.SECONDARY_COLOR_UPDATED));
  }
  if (sourceColors.customizedNames) {
      Object.keys(sourceColors.customizedNames).forEach(function(id) {
          destinationColors.push(ThemeRepository.getEntityObject(id, sourceColors.customizedNames[id], Constants.CUSTOMIZED_NAME));
      });
  }
  if (sourceColors.contrastRatioViolations) {
      Object.keys(sourceColors.contrastRatioViolations).forEach(function(id) {
          destinationColors.push(ThemeRepository.getEntityObject(id, sourceColors.contrastRatioViolations[id], Constants.CONTRAST_RATIO_VIOLATED));
      });
  }
  if (sourceColors.overrides) {
      Object.keys(sourceColors.overrides).forEach(function(id) {
          destinationColors.push(ThemeRepository.getEntityObject(id, sourceColors.overrides[id], Constants.COLOR_HOOK_OVERRIDDEN));
      });
  }
};
ThemeRepository.prototype = {
  type: 'ThemeRepository'
};