xat_support 1.29.3

data/lib/zendesk_apps_support/product.rb

@@ -0,0 +1,15 @@
+module ZendeskAppsSupport
+  module Product
+    # The product code below match the values in the database, do not change them!
+    PRODUCTS_AVAILABLE = [
+      {
+        code: 1,
+        name: 'support',
+      },
+      {
+        code: 2,
+        name: 'chat',
+      }
+    ].freeze
+  end
+end

data/lib/zendesk_apps_support/sass_functions.rb

@@ -0,0 +1,20 @@
+require 'sass'
+
+module Sass::Script::Functions
+  module AppAssetUrl
+    def app_asset_url(name)
+      assert_type name, :String
+      result = %{url("#{app_asset_url_helper(name)}")}
+      Sass::Script::String.new(result)
+    end
+
+    private
+
+    def app_asset_url_helper(name)
+      url_builder = options[:app_asset_url_builder]
+      url_builder.app_asset_url(name.value)
+    end
+  end
+
+  include AppAssetUrl
+end

data/lib/zendesk_apps_support/stylesheet_compiler.rb

@@ -0,0 +1,23 @@
+require 'sass'
+
+module ZendeskAppsSupport
+  class StylesheetCompiler
+    def initialize(source, app_id, url_prefix)
+      @source, @app_id, @url_prefix = source, app_id, url_prefix
+    end
+
+    def compile
+      Sass::Engine.new(wrapped_source, syntax: :scss, app_asset_url_builder: self).render
+    end
+
+    def app_asset_url(name)
+      "#{@url_prefix}#{name}"
+    end
+
+    private
+
+    def wrapped_source
+      ".app-#{@app_id} {#{@source}}"
+    end
+  end
+end

data/lib/zendesk_apps_support/validations/banner.rb

@@ -0,0 +1,33 @@
+require 'image_size'
+
+module ZendeskAppsSupport
+  module Validations
+    module Banner
+      BANNER_WIDTH = 830
+      BANNER_HEIGHT = 200
+
+      class <<self
+        def call(package)
+          File.open(package.path_to('assets/banner.png'), 'rb') do |fh|
+            begin
+              image = ImageSize.new(fh)
+
+              unless image.format == :png
+                return [ValidationError.new('banner.invalid_format')]
+              end
+
+              unless (image.width == BANNER_WIDTH && image.height == BANNER_HEIGHT) ||
+                     (image.width == 2 * BANNER_WIDTH && image.height == 2 * BANNER_HEIGHT)
+                return [ValidationError.new('banner.invalid_size', required_banner_width: BANNER_WIDTH,
+                                                                   required_banner_height: BANNER_HEIGHT)]
+              end
+            rescue
+              return [ValidationError.new('banner.invalid_format')]
+            end
+          end
+          []
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/validations/manifest.rb

@@ -0,0 +1,214 @@
+require 'json'
+require 'uri'
+
+module ZendeskAppsSupport
+  module Validations
+    module Manifest
+      REQUIRED_MANIFEST_FIELDS = %w( author defaultLocale ).freeze
+      OAUTH_REQUIRED_FIELDS    = %w( client_id client_secret authorize_uri access_token_uri ).freeze
+      TYPES_AVAILABLE          = %w( text password checkbox url number multiline hidden ).freeze
+
+      class <<self
+        def call(package)
+          return [ValidationError.new(:missing_manifest)] unless package.has_file?('manifest.json')
+
+          manifest = package.manifest_json
+
+          errors = []
+          errors << missing_keys_error(manifest)
+          errors << default_locale_error(manifest, package)
+          errors << oauth_error(manifest)
+          errors << parameters_error(manifest)
+          errors << invalid_hidden_parameter_error(manifest)
+          errors << invalid_type_error(manifest)
+          errors << name_as_parameter_name_error(manifest)
+
+          if manifest['requirementsOnly']
+            errors << ban_location(manifest)
+            errors << ban_framework_version(manifest)
+          else
+            errors << missing_location_error(package)
+            errors << invalid_location_error(package)
+            errors << duplicate_location_error(manifest)
+            errors << missing_framework_version(manifest)
+            errors << invalid_version_error(manifest, package)
+          end
+
+          errors.flatten.compact
+        rescue JSON::ParserError => e
+          return [ValidationError.new(:manifest_not_json, errors: e)]
+        end
+
+        private
+
+        def ban_location(manifest)
+          ValidationError.new(:no_location_required) unless manifest['location'].nil?
+        end
+
+        def ban_framework_version(manifest)
+          ValidationError.new(:no_framework_version_required) unless manifest['frameworkVersion'].nil?
+        end
+
+        def oauth_error(manifest)
+          return unless manifest['oauth']
+
+          missing = OAUTH_REQUIRED_FIELDS.select do |key|
+            manifest['oauth'][key].nil? || manifest['oauth'][key].empty?
+          end
+
+          if missing.any?
+            ValidationError.new('oauth_keys.missing', missing_keys: missing.join(', '), count: missing.length)
+          end
+        end
+
+        def parameters_error(manifest)
+          return unless manifest['parameters']
+
+          unless manifest['parameters'].is_a?(Array)
+            return ValidationError.new(:parameters_not_an_array)
+          end
+
+          para_names = manifest['parameters'].collect { |para| para['name'] }
+          duplicate_parameters = para_names.select { |name| para_names.count(name) > 1 }.uniq
+          unless duplicate_parameters.empty?
+            return ValidationError.new(:duplicate_parameters, duplicate_parameters: duplicate_parameters)
+          end
+        end
+
+        def missing_keys_error(manifest)
+          missing = REQUIRED_MANIFEST_FIELDS.select do |key|
+            manifest[key].nil?
+          end
+
+          missing_keys_validation_error(missing) if missing.any?
+        end
+
+        def default_locale_error(manifest, package)
+          default_locale = manifest['defaultLocale']
+          unless default_locale.nil?
+            if default_locale !~ Translations::VALID_LOCALE
+              ValidationError.new(:invalid_default_locale, defaultLocale: default_locale)
+            elsif package.translation_files.detect { |file| file.relative_path == "translations/#{default_locale}.json" }.nil?
+              ValidationError.new(:missing_translation_file, defaultLocale: default_locale)
+            end
+          end
+        end
+
+        def missing_location_error(package)
+          missing_keys_validation_error(['location']) unless package.has_location?
+        end
+
+        def invalid_location_error(package)
+          errors = []
+          manifest_locations = package.locations
+          manifest_locations.find do |host, locations|
+            error = if !Location.hosts.include?(host)
+              ValidationError.new(:invalid_host, host_name: host)
+            elsif (invalid_locations = locations.keys - Location.names_for(host)).any?
+              ValidationError.new(:invalid_location,
+                                  invalid_locations: invalid_locations.join(', '),
+                                  host_name: host,
+                                  count: invalid_locations.length)
+            end
+
+            # abort early for invalid host or location name
+            if error
+              errors << error
+              break
+            end
+
+            locations.values.each do |path|
+              errors << invalid_location_uri_error(package, path)
+            end
+          end
+          errors
+        end
+
+        def invalid_location_uri_error(package, path)
+          return nil if path == Package::LEGACY_URI_STUB
+          validation_error = ValidationError.new(:invalid_location_uri, uri: path)
+          uri = URI.parse(path)
+          unless uri.absolute? ? valid_absolute_uri?(uri) : valid_relative_uri?(package, uri)
+            validation_error
+          end
+        rescue URI::InvalidURIError => e
+          validation_error
+        end
+
+        def valid_absolute_uri?(uri)
+          uri.scheme == 'https' || uri.host == 'localhost'
+        end
+
+        def valid_relative_uri?(package, uri)
+          uri.path.start_with?('assets/') && package.has_file?(uri.path)
+        end
+
+        def duplicate_location_error(manifest)
+          locations           = *manifest['location']
+          duplicate_locations = *locations.select { |location| locations.count(location) > 1 }.uniq
+
+          unless duplicate_locations.empty?
+            ValidationError.new(:duplicate_location, duplicate_locations: duplicate_locations.join(', '), count: duplicate_locations.length)
+          end
+        end
+
+        def missing_framework_version(manifest)
+          missing_keys_validation_error(['frameworkVersion']) if manifest['frameworkVersion'].nil?
+        end
+
+        def invalid_version_error(manifest, package)
+          valid_to_serve = AppVersion::TO_BE_SERVED
+          target_version = manifest['frameworkVersion']
+
+          if target_version == AppVersion::DEPRECATED
+            package.warnings << I18n.t('txt.apps.admin.warning.app_build.deprecated_version')
+          end
+
+          unless valid_to_serve.include?(target_version)
+            return ValidationError.new(:invalid_version, target_version: target_version, available_versions: valid_to_serve.join(', '))
+          end
+        end
+
+        def name_as_parameter_name_error(manifest)
+          if manifest['parameters'].is_a?(Array)
+            if manifest['parameters'].any? { |p| p['name'] == 'name' }
+              ValidationError.new(:name_as_parameter_name)
+            end
+          end
+        end
+
+        def invalid_hidden_parameter_error(manifest)
+          invalid_params = []
+
+          if manifest.key?('parameters')
+            invalid_params = manifest['parameters'].select { |p| p['type'] == 'hidden' && p['required'] }.map { |p| p['name'] }
+          end
+
+          if invalid_params.any?
+            ValidationError.new(:invalid_hidden_parameter, invalid_params: invalid_params.join(', '), count: invalid_params.length)
+          end
+        end
+
+        def invalid_type_error(manifest)
+          return unless manifest['parameters'].is_a?(Array)
+
+          invalid_types = []
+
+          manifest['parameters'].each do |parameter|
+            parameter_type = parameter.fetch('type', '')
+
+            invalid_types << parameter_type unless TYPES_AVAILABLE.include?(parameter_type)
+          end
+
+          if invalid_types.any?
+            ValidationError.new(:invalid_type_parameter, invalid_types: invalid_types.join(', '), count: invalid_types.length)
+          end
+        end
+
+        def missing_keys_validation_error(missing_keys)
+          ValidationError.new('manifest_keys.missing', missing_keys: missing_keys.join(', '), count: missing_keys.length)
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/validations/marketplace.rb

@@ -0,0 +1,20 @@
+module ZendeskAppsSupport
+  module Validations
+    module Marketplace
+      class << self
+        def call(package)
+          [no_symlinks(package.root)].compact
+        end
+
+        private
+
+        def no_symlinks(path)
+          if Dir["#{path}/**/{*,.*}"].any? { |f| File.symlink?(f) }
+            return ValidationError.new(:symlink_in_zip)
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/validations/requirements.rb

@@ -0,0 +1,105 @@
+require 'json'
+require 'json/stream'
+
+module ZendeskAppsSupport
+  module Validations
+    module Requirements
+      MAX_REQUIREMENTS = 5000
+
+      class <<self
+        def call(package)
+          requirements_file = package.files.find { |f| f.relative_path == 'requirements.json' }
+
+          return [ValidationError.new(:missing_requirements)] unless requirements_file
+
+          requirements_stream = requirements_file.read
+          duplicates = non_unique_type_keys(requirements_stream)
+          unless duplicates.empty?
+            return [ValidationError.new(:duplicate_requirements, duplicate_keys: duplicates.join(', '), count: duplicates.length)]
+          end
+
+          requirements = JSON.load(requirements_stream)
+          [].tap do |errors|
+            errors << invalid_requirements_types(requirements)
+            errors << excessive_requirements(requirements)
+            errors << invalid_channel_integrations(requirements)
+            errors << invalid_user_fields(requirements)
+            errors << missing_required_fields(requirements)
+            errors.flatten!
+            errors.compact!
+          end
+        rescue JSON::ParserError => e
+          return [ValidationError.new(:requirements_not_json, errors: e)]
+        end
+
+        private
+
+        def missing_required_fields(requirements)
+          [].tap do |errors|
+            requirements.each do |requirement_type, requirement|
+              next if requirement_type == 'channel_integrations'
+              requirement.each do |identifier, fields|
+                next if fields.include? 'title'
+                errors << ValidationError.new(:missing_required_fields, field: 'title', identifier: identifier)
+              end
+            end
+          end
+        end
+
+        def excessive_requirements(requirements)
+          requirement_count = requirements.values.map(&:values).flatten.size
+          if requirement_count > MAX_REQUIREMENTS
+            ValidationError.new(:excessive_requirements, max: MAX_REQUIREMENTS, count: requirement_count)
+          end
+        end
+
+        def invalid_user_fields(requirements)
+          user_fields = requirements['user_fields']
+          return unless user_fields
+          [].tap do |errors|
+            user_fields.each do |identifier, fields|
+              next if fields.include? 'key'
+              errors << ValidationError.new(:missing_required_fields, field: 'key', identifier: identifier)
+            end
+          end
+        end
+
+        def invalid_channel_integrations(requirements)
+          channel_integrations = requirements['channel_integrations']
+          return unless channel_integrations
+          [].tap do |errors|
+            if channel_integrations.size > 1
+              errors << ValidationError.new(:multiple_channel_integrations, count: channel_integrations.size)
+            end
+            channel_integrations.each do |identifier, fields|
+              unless fields.include? 'manifest_url'
+                errors << ValidationError.new(:missing_required_fields, field: 'manifest_url', identifier: identifier)
+              end
+            end
+          end
+        end
+
+        def invalid_requirements_types(requirements)
+          invalid_types = requirements.keys - ZendeskAppsSupport::AppRequirement::TYPES
+
+          unless invalid_types.empty?
+            ValidationError.new(:invalid_requirements_types, invalid_types: invalid_types.join(', '), count: invalid_types.length)
+          end
+        end
+
+        def non_unique_type_keys(requirements)
+          keys = []
+          duplicates = []
+          parser = JSON::Stream::Parser.new do
+            start_object { keys.push({}) }
+            end_object { keys.pop }
+            key { |k| duplicates.push(k) if keys.last.include? k; keys.last[k] = nil }
+          end
+          parser << requirements
+
+          duplicates
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_apps_support/validations/source.rb

@@ -0,0 +1,95 @@
+require 'eslintrb'
+
+module ZendeskAppsSupport
+  module Validations
+    module Source
+      LINTER_OPTIONS = {
+        rules: {
+          # enforcing options:
+          'semi' => 2,
+          'no-extra-semi' => 2,
+          'no-caller' => 2,
+          'no-undef' => 2,
+
+          # relaxing options:
+          'no-unused-expressions' => 2,
+          'no-redeclare' => 2,
+          'no-eq-null' => 0,
+          'comma-dangle' => 0,
+          'dot-notation' => 0
+        },
+        env: {
+          'browser' => true,
+          'commonjs' => true
+        },
+        parserOptions: {
+          'ecmaVersion': 6,
+          'sourceType': 'module'
+        },
+        # predefined globals:
+        globals: Hash[
+          %w(_ Base64 services helpers moment)
+        .map { |x| [x, false] }]
+      }.freeze
+
+      ENFORCED_LINTER_OPTIONS = {
+        rules: {
+          # enforcing options:
+          'no-caller' => 2
+        },
+        env: {
+          'browser' => true,
+          'commonjs' => true
+        },
+        # predefined globals:
+        globals: Hash[
+          %w(_ Base64 services helpers moment)
+        .map { |x| [x, false] }]
+      }.freeze
+
+      class <<self
+        def call(package)
+          files = package.js_files
+          app   = files.find { |file| file.relative_path == 'app.js' }
+          eslint_config_path = "#{package.root}/.eslintrc.json"
+          has_eslint_config = File.exists?(eslint_config_path)
+          options = has_eslint_config ? JSON.parse(File.read(eslint_config_path)) : LINTER_OPTIONS
+
+          if package_needs_app_js?(package)
+            return [ ValidationError.new(:missing_source) ] unless app
+          else
+            return (package_has_code?(package) ? [ ValidationError.new(:no_code_for_ifo_notemplate) ] : [])
+          end
+
+          errors = eslint_errors(files, options)
+          errors << eslint_errors(files, ENFORCED_LINTER_OPTIONS) if errors.empty? && has_eslint_config
+          return app ? errors.flatten! : [ValidationError.new(:missing_source)]
+        end
+
+        private
+
+        def package_has_code?(package)
+          !(package.js_files.empty? && package.template_files.empty? && package.app_css.empty?)
+        end
+
+        def package_needs_app_js?(package)
+          return false if package.manifest_json['requirementsOnly']
+          return false if package.iframe_only?
+          true
+        end
+
+        def eslint_error(file, options)
+          errors = Eslintrb.lint(file.read, options)
+          [ESLintValidationError.new(file.relative_path, errors)] if errors.any?
+        end
+
+        def eslint_errors(files, options)
+          files.each_with_object([]) do |file, errors|
+            error = eslint_error(file, options)
+            errors << error unless error.nil?
+          end
+        end
+      end
+    end
+  end
+end