fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/app_store_build_number.rb

@@ -0,0 +1,255 @@
+require 'ostruct'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      LATEST_BUILD_NUMBER = :LATEST_BUILD_NUMBER
+      LATEST_VERSION = :LATEST_VERSION
+    end
+
+    class AppStoreBuildNumberAction < Action
+      def self.run(params)
+        build_v, build_nr = get_build_version_and_number(params)
+
+        Actions.lane_context[SharedValues::LATEST_BUILD_NUMBER] = build_nr
+        Actions.lane_context[SharedValues::LATEST_VERSION] = build_v
+
+        return build_nr
+      end
+
+      def self.get_build_version_and_number(params)
+        require 'spaceship'
+
+        result = get_build_info(params)
+        build_nr = result.build_nr
+
+        # Convert build_nr to int (for legacy use) if no "." in string
+        if build_nr.kind_of?(String) && !build_nr.include?(".")
+          build_nr = build_nr.to_i
+        end
+
+        return result.build_v, build_nr
+      end
+
+      def self.get_build_info(params)
+        # Prompts select team if multiple teams and none specified
+        if (api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path]))
+          UI.message("Creating authorization token for App Store Connect API")
+          Spaceship::ConnectAPI.token = api_token
+        elsif !Spaceship::ConnectAPI.token.nil?
+          UI.message("Using existing authorization token for App Store Connect API")
+        else
+          # Username is now optional since addition of App Store Connect API Key
+          # Force asking for username to prompt user if not already set
+          params.fetch(:username, force_ask: true)
+
+          UI.message("Login to App Store Connect (#{params[:username]})")
+          Spaceship::ConnectAPI.login(params[:username], use_portal: false, use_tunes: true, tunes_team_id: params[:team_id], team_name: params[:team_name])
+          UI.message("Login successful")
+        end
+
+        platform = Spaceship::ConnectAPI::Platform.map(params[:platform])
+
+        app = Spaceship::ConnectAPI::App.find(params[:app_identifier])
+        UI.user_error!("Could not find an app on App Store Connect with app_identifier: #{params[:app_identifier]}") unless app
+        if params[:live]
+          UI.message("Fetching the latest build number for live-version")
+          live_version = app.get_live_app_store_version(platform: platform)
+
+          UI.user_error!("Could not find a live-version of #{params[:app_identifier]} on App Store Connect") unless live_version
+          build_nr = live_version.build.version
+
+          UI.message("Latest upload for live-version #{live_version.version_string} is build: #{build_nr}")
+
+          return OpenStruct.new({ build_nr: build_nr, build_v: live_version.version_string })
+        else
+          version_number = params[:version]
+          platform = params[:platform]
+
+          # Create filter for get_builds with optional version number
+          filter = { app: app.id }
+          if version_number
+            filter["preReleaseVersion.version"] = version_number
+            version_number_message = "version #{version_number}"
+          else
+            version_number_message = "any version"
+          end
+
+          if platform
+            filter["preReleaseVersion.platform"] = Spaceship::ConnectAPI::Platform.map(platform)
+            platform_message = "#{platform} platform"
+          else
+            platform_message = "any platform"
+          end
+
+          UI.message("Fetching the latest build number for #{version_number_message}")
+
+          # Get latest build for optional version number and return build number if found
+          build = Spaceship::ConnectAPI.get_builds(filter: filter, sort: "-uploadedDate", includes: "preReleaseVersion", limit: 1).first
+          if build
+            build_nr = build.version
+            UI.message("Latest upload for version #{build.app_version} on #{platform_message} is build: #{build_nr}")
+            return OpenStruct.new({ build_nr: build_nr, build_v: build.app_version })
+          end
+
+          # Let user know that build couldn't be found
+          UI.important("Could not find a build for #{version_number_message} on #{platform_message} on App Store Connect")
+
+          if params[:initial_build_number].nil?
+            UI.user_error!("Could not find a build on App Store Connect - and 'initial_build_number' option is not set")
+          else
+            build_nr = params[:initial_build_number]
+            UI.message("Using initial build number of #{build_nr}")
+            return OpenStruct.new({ build_nr: build_nr, build_v: version_number })
+          end
+        end
+      end
+
+      def self.order_versions(versions)
+        versions.map(&:to_s).sort_by { |v| Gem::Version.new(v) }
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Returns the current build_number of either live or edit version"
+      end
+
+      def self.available_options
+        user = CredentialsManager::AppfileConfig.try_fetch_value(:itunes_connect_id)
+        user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+        [
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_names: ["APPSTORE_BUILD_NUMBER_API_KEY_PATH", "APP_STORE_CONNECT_API_KEY_PATH"],
+                                       description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_names: ["APPSTORE_BUILD_NUMBER_API_KEY", "APP_STORE_CONNECT_API_KEY"],
+                                       description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)",
+                                       type: Hash,
+                                       default_value: Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::APP_STORE_CONNECT_API_KEY],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       sensitive: true,
+                                       conflicting_options: [:api_key_path]),
+          FastlaneCore::ConfigItem.new(key: :initial_build_number,
+                                       env_name: "INITIAL_BUILD_NUMBER",
+                                       description: "sets the build number to given value if no build is in current train",
+                                       skip_type_validation: true), # as we also allow integers, which we convert to strings anyway
+          FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                       short_option: "-a",
+                                       env_name: "FASTLANE_APP_IDENTIFIER",
+                                       description: "The bundle identifier of your app",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier),
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       short_option: "-u",
+                                       env_name: "ITUNESCONNECT_USER",
+                                       description: "Your Apple ID Username",
+                                       optional: true,
+                                       default_value: user,
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       short_option: "-k",
+                                       env_name: "APPSTORE_BUILD_NUMBER_LIVE_TEAM_ID",
+                                       description: "The ID of your App Store Connect team if you're in multiple teams",
+                                       optional: true,
+                                       skip_type_validation: true, # as we also allow integers, which we convert to strings anyway
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_id),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_ITC_TEAM_ID"] = value.to_s
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :live,
+                                       short_option: "-l",
+                                       env_name: "APPSTORE_BUILD_NUMBER_LIVE",
+                                       description: "Query the live version (ready-for-sale)",
+                                       optional: true,
+                                       type: Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "LATEST_VERSION",
+                                       description: "The version number whose latest build number we want",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       short_option: "-j",
+                                       env_name: "APPSTORE_PLATFORM",
+                                       description: "The platform to use (optional)",
+                                       optional: true,
+                                       default_value: "ios",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The platform can only be ios, appletvos, or osx") unless %('ios', 'appletvos', 'osx').include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :team_name,
+                                       short_option: "-e",
+                                       env_name: "LATEST_TESTFLIGHT_BUILD_NUMBER_TEAM_NAME",
+                                       description: "The name of your App Store Connect team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:itc_team_name),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_ITC_TEAM_NAME"] = value.to_s
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['LATEST_BUILD_NUMBER', 'The latest build number of either live or testflight version'],
+          ['LATEST_VERSION', 'The version of the latest build number']
+        ]
+      end
+
+      def self.details
+        [
+          "Returns the current build number of either the live or testflight version - it is useful for getting the build_number of the current or ready-for-sale app version, and it also works on non-live testflight version.",
+          "If you need to handle more build-trains please see `latest_testflight_build_number`."
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'app_store_build_number',
+          'app_store_build_number(
+            app_identifier: "app.identifier",
+            username: "user@host.com"
+          )',
+          'app_store_build_number(
+            live: false,
+            app_identifier: "app.identifier",
+            version: "1.2.9"
+          )',
+          'api_key = app_store_connect_api_key(
+            key_id: "MyKeyID12345",
+            issuer_id: "00000000-0000-0000-0000-000000000000",
+            key_filepath: "./AuthKey.p8"
+          )
+          build_num = app_store_build_number(
+            api_key: api_key
+          )'
+        ]
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/app_store_connect_api_key.rb

@@ -0,0 +1,148 @@
+require 'base64'
+require 'spaceship'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      APP_STORE_CONNECT_API_KEY = :APP_STORE_CONNECT_API_KEY
+    end
+
+    class AppStoreConnectApiKeyAction < Action
+      def self.run(options)
+        key_id = options[:key_id]
+        issuer_id = options[:issuer_id]
+        key_content = options[:key_content]
+        is_key_content_base64 = options[:is_key_content_base64]
+        key_filepath = options[:key_filepath]
+        duration = options[:duration]
+        in_house = options[:in_house]
+
+        if key_content.nil? && key_filepath.nil?
+          UI.user_error!(":key_content or :key_filepath is required")
+        end
+
+        # New lines don't get read properly when coming from an ENV
+        # Replacing them literal version with a new line
+        key_content = key_content.gsub('\n', "\n") if key_content
+
+        # This hash matches the named arguments on
+        # the Spaceship::ConnectAPI::Token.create method
+        key = {
+          key_id: key_id,
+          issuer_id: issuer_id,
+          key: key_content || File.binread(File.expand_path(key_filepath)),
+          is_key_content_base64: is_key_content_base64,
+          duration: duration,
+          in_house: in_house
+        }
+
+        Actions.lane_context.set_sensitive(SharedValues::APP_STORE_CONNECT_API_KEY, key)
+
+        # Creates Spaceship API Key session
+        # User does not need to pass the token into any actions because of this
+        Spaceship::ConnectAPI.token = Spaceship::ConnectAPI::Token.create(**key) if options[:set_spaceship_token]
+
+        return key
+      end
+
+      def self.description
+        "Load the App Store Connect API token to use in other fastlane tools and actions"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :key_id,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_KEY_ID",
+                                       description: "The key ID"),
+          FastlaneCore::ConfigItem.new(key: :issuer_id,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_ISSUER_ID",
+                                       description: "The issuer ID"),
+          FastlaneCore::ConfigItem.new(key: :key_filepath,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_KEY_FILEPATH",
+                                       description: "The path to the key p8 file",
+                                       optional: true,
+                                       conflicting_options: [:key_content],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find key p8 file at path '#{value}'") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :key_content,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_KEY",
+                                       description: "The content of the key p8 file",
+                                       sensitive: true,
+                                       optional: true,
+                                       conflicting_options: [:filepath]),
+          FastlaneCore::ConfigItem.new(key: :is_key_content_base64,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_IS_KEY_CONTENT_BASE64",
+                                       description: "Whether :key_content is Base64 encoded or not",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :duration,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_DURATION",
+                                       description: "The token session duration",
+                                       optional: true,
+                                       default_value: Spaceship::ConnectAPI::Token::DEFAULT_TOKEN_DURATION,
+                                       type: Integer,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The duration can't be more than 1200 (20 minutes) and the value entered was '#{value}'") unless value <= 1200
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :in_house,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_IN_HOUSE",
+                                       description: "Is App Store or Enterprise (in house) team? App Store Connect API cannot determine this on its own (yet)",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :set_spaceship_token,
+                                       env_name: "APP_STORE_CONNECT_API_KEY_SET_SPACESHIP_TOKEN",
+                                       description: "Authorizes all Spaceship::ConnectAPI requests by automatically setting Spaceship::ConnectAPI.token",
+                                       type: Boolean,
+                                       default_value: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['APP_STORE_CONNECT_API_KEY', 'The App Store Connect API key information used for authorization requests. This hash can be passed directly into the :api_key options on other tools or into Spaceship::ConnectAPI::Token.create method']
+        ]
+      end
+
+      def self.author
+        ["joshdholtz"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :tvos].include?(platform)
+      end
+
+      def self.details
+        [
+          "Load the App Store Connect API token to use in other fastlane tools and actions"
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'app_store_connect_api_key(
+            key_id: "D83848D23",
+            issuer_id: "227b0bbf-ada8-458c-9d62-3d8022b7d07f",
+            key_filepath: "D83848D23.p8"
+          )',
+          'app_store_connect_api_key(
+            key_id: "D83848D23",
+            issuer_id: "227b0bbf-ada8-458c-9d62-3d8022b7d07f",
+            key_filepath: "D83848D23.p8",
+            duration: 200,
+            in_house: true
+          )',
+          'app_store_connect_api_key(
+            key_id: "D83848D23",
+            issuer_id: "227b0bbf-ada8-458c-9d62-3d8022b7d07f",
+            key_content: "-----BEGIN EC PRIVATE KEY-----\nfewfawefawfe\n-----END EC PRIVATE KEY-----"
+          )'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/appaloosa.rb

@@ -0,0 +1,271 @@
+module Fastlane
+  module Actions
+    class AppaloosaAction < Action
+      APPALOOSA_SERVER = 'https://www.appaloosa-store.com/api/v2'.freeze
+      def self.run(params)
+        api_key = params[:api_token]
+        store_id = params[:store_id]
+        binary = params[:binary]
+        remove_extra_screenshots_file(params[:screenshots])
+        binary_url = get_binary_link(binary, api_key, store_id, params[:group_ids])
+        return if binary_url.nil?
+        screenshots_url = get_screenshots_links(api_key, store_id, params[:screenshots], params[:locale], params[:device])
+        upload_on_appaloosa(api_key, store_id, binary_url, screenshots_url, params[:group_ids], params[:description], params[:changelog])
+      end
+
+      def self.get_binary_link(binary, api_key, store_id, group_ids)
+        key_s3 = upload_on_s3(binary, api_key, store_id, group_ids)
+        return if key_s3.nil?
+        get_s3_url(api_key, store_id, key_s3)
+      end
+
+      def self.upload_on_s3(file, api_key, store_id, group_ids = '')
+        file_name = file.split('/').last
+        uri = URI("#{APPALOOSA_SERVER}/upload_services/presign_form")
+        params = { file: file_name, store_id: store_id, group_ids: group_ids, api_key: api_key }
+        uri.query = URI.encode_www_form(params)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        presign_form_response = http.request(Net::HTTP::Get.new(uri.request_uri))
+        json_res = JSON.parse(presign_form_response.body)
+        return if error_detected(json_res['errors'])
+        s3_sign = json_res['s3_sign']
+        path = json_res['path']
+        uri = URI.parse(Base64.decode64(s3_sign))
+        File.open(file, 'rb') do |f|
+          http = Net::HTTP.new(uri.host)
+          put = Net::HTTP::Put.new(uri.request_uri)
+          put.body = f.read
+          put['content-type'] = ''
+          http.request(put)
+        end
+        path
+      end
+
+      def self.get_s3_url(api_key, store_id, path)
+        uri = URI("#{APPALOOSA_SERVER}/#{store_id}/upload_services/url_for_download")
+        params = { store_id: store_id, api_key: api_key, key: path }
+        uri.query = URI.encode_www_form(params)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        url_for_download_response = http.request(Net::HTTP::Get.new(uri.request_uri))
+        if invalid_response?(url_for_download_response)
+          UI.user_error!("ERROR: A problem occurred with your API token and your store id. Please try again.")
+        end
+        json_res = JSON.parse(url_for_download_response.body)
+        return if error_detected(json_res['errors'])
+        json_res['binary_url']
+      end
+
+      def self.remove_extra_screenshots_file(screenshots_env)
+        extra_file = "#{screenshots_env}/screenshots.html"
+        File.unlink(extra_file) if File.exist?(extra_file)
+      end
+
+      def self.upload_screenshots(screenshots, api_key, store_id)
+        return if screenshots.nil?
+        list = []
+        list << screenshots.map do |screen|
+          upload_on_s3(screen, api_key, store_id)
+        end
+      end
+
+      def self.get_uploaded_links(uploaded_screenshots, api_key, store_id)
+        return if uploaded_screenshots.nil?
+        urls = []
+        urls << uploaded_screenshots.flatten.map do |url|
+          get_s3_url(api_key, store_id, url)
+        end
+      end
+
+      def self.get_screenshots_links(api_key, store_id, screenshots_path, locale, device)
+        screenshots = get_screenshots(screenshots_path, locale, device)
+        return if screenshots.nil?
+        uploaded = upload_screenshots(screenshots, api_key, store_id)
+        links = get_uploaded_links(uploaded, api_key, store_id)
+        links.kind_of?(Array) ? links.flatten : nil
+      end
+
+      def self.get_screenshots(screenshots_path, locale, device)
+        get_env_value('screenshots').nil? ? locale = '' : locale.concat('/')
+        device.nil? ? device = '' : device.concat('-')
+        screenshots_path.strip.empty? ? nil : screenshots_list(screenshots_path, locale, device)
+      end
+
+      def self.screenshots_list(path, locale, device)
+        return warning_detected("screenshots folder not found") unless Dir.exist?("#{path}/#{locale}")
+        list = Dir.entries("#{path}/#{locale}") - ['.', '..']
+        list.map do |screen|
+          next if screen.match(device).nil?
+          "#{path}/#{locale}#{screen}" unless Dir.exist?("#{path}/#{locale}#{screen}")
+        end.compact
+      end
+
+      def self.upload_on_appaloosa(api_key, store_id, binary_path, screenshots, group_ids, description, changelog)
+        screenshots = all_screenshots_links(screenshots)
+        uri = URI("#{APPALOOSA_SERVER}/#{store_id}/mobile_application_updates/upload")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        req = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
+        req.body = { store_id: store_id,
+                     api_key: api_key,
+                     mobile_application_update: {
+                       description: description,
+                       changelog: changelog,
+                       binary_path: binary_path,
+                       screenshot1: screenshots[0],
+                       screenshot2: screenshots[1],
+                       screenshot3: screenshots[2],
+                       screenshot4: screenshots[3],
+                       screenshot5: screenshots[4],
+                       group_ids: group_ids,
+                       provider: 'fastlane'
+                     } }.to_json
+        uoa_response = http.request(req)
+        json_res = JSON.parse(uoa_response.body)
+        if json_res['errors']
+          UI.error("App: #{json_res['errors']}")
+        else
+          UI.success("Binary processing: Check your app': #{json_res['link']}")
+        end
+      end
+
+      def self.all_screenshots_links(screenshots)
+        if screenshots.nil?
+          screens = %w(screenshot1 screenshot2 screenshot3 screenshot4 screenshot5)
+          screenshots = screens.map do |_k, _v|
+            ''
+          end
+        else
+          missings = 5 - screenshots.count
+          (1..missings).map do |_i|
+            screenshots << ''
+          end
+        end
+        screenshots
+      end
+
+      def self.get_env_value(option)
+        available_options.map do |opt|
+          opt if opt.key == option.to_sym
+        end.compact[0].default_value
+      end
+
+      def self.error_detected(errors)
+        if errors
+          UI.user_error!("ERROR: #{errors}")
+        else
+          false
+        end
+      end
+
+      def self.warning_detected(warning)
+        UI.important("WARNING: #{warning}")
+        nil
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        'Upload your app to [Appaloosa Store](https://www.appaloosa-store.com/)'
+      end
+
+      def self.details
+        [
+          "Appaloosa is a private mobile application store. This action offers a quick deployment on the platform.",
+          "You can create an account, push to your existing account, or manage your user groups.",
+          "We accept iOS and Android applications."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :binary,
+                                       env_name: 'FL_APPALOOSA_BINARY',
+                                       description: 'Binary path. Optional for ipa if you use the `ipa` or `xcodebuild` action',
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find ipa || apk file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: 'FL_APPALOOSA_API_TOKEN',
+                                       sensitive: true,
+                                       description: "Your API token"),
+          FastlaneCore::ConfigItem.new(key: :store_id,
+                                       env_name: 'FL_APPALOOSA_STORE_ID',
+                                       description: "Your Store id"),
+          FastlaneCore::ConfigItem.new(key: :group_ids,
+                                       env_name: 'FL_APPALOOSA_GROUPS',
+                                       description: 'Your app is limited to special users? Give us the group ids',
+                                       default_value: '',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :screenshots,
+                                       env_name: 'FL_APPALOOSA_SCREENSHOTS',
+                                       description: 'Add some screenshots application to your store or hit [enter]',
+                                       default_value: Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH],
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :locale,
+                                       env_name: 'FL_APPALOOSA_LOCALE',
+                                       description: 'Select the folder locale for your screenshots',
+                                       default_value: 'en-US',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :device,
+                                       env_name: 'FL_APPALOOSA_DEVICE',
+                                       description: 'Select the device format for your screenshots',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :description,
+                                       env_name: 'FL_APPALOOSA_DESCRIPTION',
+                                       description: 'Your app description',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :changelog,
+                                       env_name: 'FL_APPALOOSA_CHANGELOG',
+                                       description: 'Your app changelog',
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ['Appaloosa']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :android].include?(platform)
+      end
+
+      def self.invalid_response?(url_for_download_response)
+        url_for_download_response.kind_of?(Net::HTTPNotFound) ||
+          url_for_download_response.kind_of?(Net::HTTPForbidden)
+      end
+
+      def self.example_code
+        [
+          "appaloosa(
+            # Path tor your IPA or APK
+            binary: '/path/to/binary.ipa',
+            # You can find your store’s id at the bottom of the “Settings” page of your store
+            store_id: 'your_store_id',
+            # You can find your api_token at the bottom of the “Settings” page of your store
+            api_token: 'your_api_key',
+            # User group_ids visibility, if it's not specified we'll publish the app for all users in your store'
+            group_ids: '112, 232, 387',
+            # You can use fastlane/snapshot or specify your own screenshots folder.
+            # If you use snapshot please specify a local and a device to upload your screenshots from.
+            # When multiple values are specified in the Snapfile, we default to 'en-US'
+            locale: 'en-US',
+            # By default, the screenshots from the last device will be used
+            device: 'iPhone6',
+            # Screenshots' filenames should start with device's name like 'iphone6-s1.png' if device specified
+            screenshots: '/path/to_your/screenshots'
+          )"
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end