fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/adb_devices.rb

@@ -0,0 +1,71 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class AdbDevicesAction < Action
+      def self.run(params)
+        adb = Helper::AdbHelper.new(adb_path: params[:adb_path])
+        result = adb.load_all_devices
+        return result
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Get an array of Connected android device serials"
+      end
+
+      def self.details
+        "Fetches device list via adb, e.g. run an adb command on all connected devices."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :adb_path,
+                                       env_name: "FL_ADB_PATH",
+                                       description: "The path to your `adb` binary (can be left blank if the ANDROID_SDK_ROOT environment variable is set)",
+                                       is_string: true,
+                                       optional: true,
+                                       default_value: "adb")
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.example_code
+        [
+          'adb_devices.each do |device|
+            model = adb(command: "shell getprop ro.product.model",
+                        serial: device.serial).strip
+
+            puts "Model #{model} is connected"
+          end'
+        ]
+      end
+
+      def self.sample_return_value
+        []
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.return_value
+        "Returns an array of all currently connected android devices"
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/add_extra_platforms.rb

@@ -0,0 +1,45 @@
+module Fastlane
+  module Actions
+    class AddExtraPlatformsAction < Action
+      def self.run(params)
+        UI.verbose("Before injecting extra platforms: #{Fastlane::SupportedPlatforms.all}")
+        Fastlane::SupportedPlatforms.extra = params[:platforms]
+        UI.verbose("After injecting extra platforms (#{params[:platforms]})...: #{Fastlane::SupportedPlatforms.all}")
+      end
+
+      def self.description
+        "Modify the default list of supported platforms"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platforms,
+                                       optional: false,
+                                       type: Array,
+                                       default_value: "",
+                                       description: "The optional extra platforms to support")
+        ]
+      end
+
+      def self.authors
+        ["lacostej"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'add_extra_platforms(
+            platforms: [:windows, :neogeo]
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/add_git_tag.rb

@@ -0,0 +1,122 @@
+module Fastlane
+  module Actions
+    # Adds a git tag to the current commit
+    class AddGitTagAction < Action
+      def self.run(options)
+        # lane name in lane_context could be nil because you can just call $fastlane add_git_tag which has no context
+        lane_name = Actions.lane_context[Actions::SharedValues::LANE_NAME].to_s.delete(' ') # no spaces allowed
+
+        tag = options[:tag] || "#{options[:grouping]}/#{lane_name}/#{options[:prefix]}#{options[:build_number]}#{options[:postfix]}"
+        message = options[:message] || "#{tag} (fastlane)"
+
+        cmd = ['git tag']
+
+        cmd << ["-am #{message.shellescape}"]
+        cmd << '--force' if options[:force]
+        cmd << '-s' if options[:sign]
+        cmd << tag.shellescape
+        cmd << options[:commit].to_s if options[:commit]
+
+        UI.message("Adding git tag '#{tag}' 🎯.")
+        Actions.sh(cmd.join(' '))
+      end
+
+      def self.description
+        "This will add an annotated git tag to the current branch"
+      end
+
+      def self.details
+        list = <<-LIST.markdown_list
+          `grouping` is just to keep your tags organised under one 'folder', defaults to 'builds'
+          `lane` is the name of the current fastlane lane
+          `prefix` is anything you want to stick in front of the version number, e.g. 'v'
+          `postfix` is anything you want to stick at the end of the version number, e.g. '-RC1'
+          `build_number` is the build number, which defaults to the value emitted by the `increment_build_number` action
+        LIST
+
+        [
+          "This will automatically tag your build with the following format: `<grouping>/<lane>/<prefix><build_number>`, where:".markdown_preserve_newlines,
+          list,
+          "For example, for build 1234 in the 'appstore' lane, it will tag the commit with `builds/appstore/1234`."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :tag,
+                                       env_name: "FL_GIT_TAG_TAG",
+                                       description: "Define your own tag text. This will replace all other parameters",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :grouping,
+                                       env_name: "FL_GIT_TAG_GROUPING",
+                                       description: "Is used to keep your tags organised under one 'folder'",
+                                       default_value: 'builds'),
+          FastlaneCore::ConfigItem.new(key: :prefix,
+                                       env_name: "FL_GIT_TAG_PREFIX",
+                                       description: "Anything you want to put in front of the version number (e.g. 'v')",
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :postfix,
+                                       env_name: "FL_GIT_TAG_POSTFIX",
+                                       description: "Anything you want to put at the end of the version number (e.g. '-RC1')",
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :build_number,
+                                       env_name: "FL_GIT_TAG_BUILD_NUMBER",
+                                       description: "The build number. Defaults to the result of increment_build_number if you\'re using it",
+                                       default_value: Actions.lane_context[Actions::SharedValues::BUILD_NUMBER],
+                                       default_value_dynamic: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_GIT_TAG_MESSAGE",
+                                       description: "The tag message. Defaults to the tag's name",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :commit,
+                                       env_name: "FL_GIT_TAG_COMMIT",
+                                       description: "The commit or object where the tag will be set. Defaults to the current HEAD",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_GIT_TAG_FORCE",
+                                       description: "Force adding the tag",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :sign,
+                                       env_name: "FL_GIT_TAG_SIGN",
+                                       description: "Make a GPG-signed tag, using the default e-mail address's key",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false)
+        ]
+      end
+
+      def self.example_code
+        [
+          'add_git_tag # simple tag with default values',
+          'add_git_tag(
+            grouping: "fastlane-builds",
+            prefix: "v",
+            postfix: "-RC1",
+            build_number: 123
+          )',
+          '# Alternatively, you can specify your own tag. Note that if you do specify a tag, all other arguments are ignored.
+          add_git_tag(
+            tag: "my_custom_tag"
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      def self.authors
+        ["lmirosevic", "maschall"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      LATEST_BUILD_NUMBER = :LATEST_BUILD_NUMBER
+    end
+
+    class AppStoreBuildNumberAction < Action
+      def self.run(params)
+        require 'spaceship'
+
+        build_nr = get_build_number(params)
+
+        # 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
+
+        Actions.lane_context[SharedValues::LATEST_BUILD_NUMBER] = build_nr
+      end
+
+      def self.get_build_number(params)
+        UI.message("Login to App Store Connect (#{params[:username]})")
+        Spaceship::Tunes.login(params[:username])
+        Spaceship::Tunes.select_team(team_id: params[:team_id], team_name: params[:team_name])
+        UI.message("Login successful")
+
+        app = Spaceship::Tunes::Application.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")
+          UI.user_error!("Could not find a live-version of #{params[:app_identifier]} on iTC") unless app.live_version
+          build_nr = app.live_version.current_build_number
+
+          UI.message("Latest upload for live-version #{app.live_version.version} is build: #{build_nr}")
+
+          return build_nr
+        else
+          version_number = params[:version]
+
+          # Create filter for get_builds with optional version number
+          filter = { app: app.apple_id }
+          if version_number
+            filter["preReleaseVersion.version"] = version_number
+            version_number_message = "version #{version_number}"
+          else
+            version_number_message = "any version"
+          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: "-version", includes: "preReleaseVersion", limit: 1).first
+          if build
+            build_nr = build.version
+            UI.message("Latest upload for version #{build.app_version} is build: #{build_nr}")
+            return build_nr
+          end
+
+          # Let user know that build couldn't be found
+          UI.important("Could not find a build for #{version_number_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 build_nr
+          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: :initial_build_number,
+                                       env_name: "INITIAL_BUILD_NUMBER",
+                                       description: "sets the build number to given value if no build is in current train",
+                                       is_string: false),
+          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",
+                                       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,
+                                       is_string: false, # 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,
+                                       is_string: false,
+                                       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,
+                                       is_string: 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']
+        ]
+      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"
+          )'
+        ]
+      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/appaloosa.rb

@@ -0,0 +1,266 @@
+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])
+      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)
+        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,
+                       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)
+        ]
+      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