fastlane 1.111.0 → 2.0.1

data/spaceship/lib/spaceship/tunes/app_version_common.rb

@@ -0,0 +1,33 @@
+module Spaceship
+  module Tunes
+    # internal to spaceship
+    # Represents the common structure between application['versionSets'] and app_version['platform']
+    class AppVersionCommon
+      class << self
+        def find_version_id(platform, is_live)
+          version = platform[(is_live ? 'deliverableVersion' : 'inFlightVersion')]
+          return nil unless version
+          version['id']
+        end
+
+        def find_platform(versions, search_platform: nil)
+          # We only support platforms that exist ATM
+          platform = versions.detect do |p|
+            ['ios', 'osx', 'appletvos'].include? p['platformString']
+          end
+
+          raise "Could not find platform 'ios', 'osx' or 'appletvos'" unless platform
+
+          # If your app has versions for both iOS and tvOS we will default to returning the iOS version for now.
+          # This is intentional as we need to do more work to support apps that have hybrid versions.
+          if versions.length > 1 && search_platform.nil?
+            platform = versions.detect { |p| p['platformString'] == "ios" }
+          elsif !search_platform.nil?
+            platform = versions.detect { |p| p['platformString'] == search_platform }
+          end
+          platform
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/app_version_generated_promocodes.rb

@@ -0,0 +1,35 @@
+module Spaceship
+  module Tunes
+    # Represents the information about the generation of promocodes
+    class AppVersionGeneratedPromocodes < TunesBase
+      # @return
+      attr_reader :effective_date
+      attr_reader :expiration_date
+      attr_reader :username
+      # the AppVersionPromocodes this relates to
+      attr_reader :version
+      # Array of String
+      attr_reader :codes
+
+      attr_mapping({
+        'effectiveDate' => :effective_date,
+        'expirationDate' => :expiration_date,
+        'username' => :username
+      })
+
+      class << self
+        # Create a new object based on a hash.
+        # This is used to create a new object based on the server response.
+        def factory(attrs)
+          obj = self.new(attrs)
+          return obj
+        end
+      end
+
+      def setup
+        @version = Tunes::AppVersionPromocodes.factory(raw_data['version'])
+        @codes = raw_data['codes']
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/app_version_history.rb

@@ -0,0 +1,59 @@
+module Spaceship
+  module Tunes
+    # Represents a read only version of an iTunes Connect Versions State History
+    class AppVersionHistory < TunesBase
+      # @return (Spaceship::Tunes::Application) A reference to the application
+      #   this version is for
+      attr_accessor :application
+
+      # @return (String) The version in string format (e.g. "1.0")
+      attr_reader :version_string
+
+      # @return (String) The platform value of this version.
+      attr_reader :version_id
+
+      # @return ([Spaceship::Tunes::AppVersionStatesHistory]) the array of version states
+      attr_reader :items
+
+      attr_mapping({
+        'versionString' => :version_string,
+        'versionId' => :version_id,
+        'items' => :items
+      })
+
+      class << self
+        # Create a new object based on a hash.
+        # This is used to create a new object based on the server response.
+        def factory(attrs)
+          obj = self.new(attrs)
+          return obj
+        end
+      end
+
+      # Returns an array of all builds that can be sent to review
+      def items
+        @items ||= fetch_items
+      end
+
+      # Private methods
+      def setup
+        # Properly parse the AppStatus
+        items = raw_data['items']
+        @items = map_items(items) if items
+      end
+
+      private
+
+      def map_items(items)
+        items.map do |attrs|
+          Tunes::AppVersionStatesHistory.factory(attrs)
+        end
+      end
+
+      def fetch_items
+        items = client.version_states_history(application.apple_id, application.platform, version_id)['items']
+        map_items(items)
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/app_version_promocodes.rb

@@ -0,0 +1,34 @@
+module Spaceship
+  module Tunes
+    # Represents the information about remaining number of promo codes for an app version
+    class AppVersionPromocodes < TunesBase
+      # @return
+      attr_reader :app_id
+      attr_reader :app_name
+      attr_reader :version
+      attr_reader :platform
+      attr_reader :number_of_codes
+      attr_reader :maximum_number_of_codes
+      attr_reader :contract_file_name
+
+      attr_mapping({
+        'id' => :app_id,
+        'appName' => :app_name,
+        'version' => :version,
+        'platform' => :platform,
+        'numberOfCodes' => :number_of_codes,
+        'maximumNumberOfCodes' => :maximum_number_of_codes,
+        'contractFileName' => :contract_file_name
+      })
+
+      class << self
+        # Create a new object based on a hash.
+        # This is used to create a new object based on the server response.
+        def factory(attrs)
+          obj = self.new(attrs)
+          return obj
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/app_version_ref.rb

@@ -0,0 +1,19 @@
+module Spaceship
+  module Tunes
+    class AppVersionRef < TunesBase
+      attr_accessor :sso_token_for_image
+      attr_accessor :sso_token_for_video
+
+      attr_mapping(
+        'ssoTokenForImage' => :sso_token_for_image,
+        'ssoTokenForVideo' => :sso_token_for_video
+      )
+
+      class << self
+        def factory(attrs)
+          self.new(attrs)
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/app_version_states_history.rb

@@ -0,0 +1,34 @@
+module Spaceship
+  module Tunes
+    # Represents a read only version of an iTunes Connect Versions State History
+    class AppVersionStatesHistory < TunesBase
+      # @return (String) the state
+      attr_reader :state_key
+
+      # @return (String) The name of the user who made the change
+      attr_reader :user_name
+
+      # @return (String) the email of the user or nil
+      attr_reader :user_email
+
+      # @return (Integer) the date of the state
+      attr_reader :date
+
+      attr_mapping({
+        'stateKey' => :state_key,
+        'userName' => :user_name,
+        'userEmail' => :user_email,
+        'date' => :date
+      })
+
+      class << self
+        # Create a new object based on a hash.
+        # This is used to create a new object based on the server response.
+        def factory(attrs)
+          obj = self.new(attrs)
+          return obj
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/application.rb

@@ -0,0 +1,437 @@
+module Spaceship
+  module Tunes
+    class Application < TunesBase
+      # @return (String) The App identifier of this app, provided by iTunes Connect
+      # @example
+      #   "1013943394"
+      attr_accessor :apple_id
+
+      # @return (String) The name you provided for this app (in the default language)
+      # @example
+      #   "Spaceship App"
+      attr_accessor :name
+
+      # @return (String) The Vendor ID provided by iTunes Connect
+      # @example
+      #   "1435592086"
+      attr_accessor :vendor_id
+
+      # @return (String) The bundle_id (app identifier) of your app
+      # @example
+      #   "com.krausefx.app"
+      attr_accessor :bundle_id
+
+      # @return (String) Last modified
+      attr_accessor :last_modified
+
+      # @return (Integer) The number of issues provided by iTunes Connect
+      attr_accessor :issues_count
+
+      # @return (String) The URL to a low resolution app icon of this app (340x340px). Might be nil
+      # @example
+      #   "https://is1-ssl.mzstatic.com/image/thumb/Purple7/v4/cd/a3/e2/cda3e2ac-4034-c6af-ee0c-3e4d9a0bafaa/pr_source.png/340x340bb-80.png"
+      # @example
+      #   nil
+      attr_accessor :app_icon_preview_url
+
+      # @return (Array) An array of all versions sets
+      attr_accessor :version_sets
+
+      attr_mapping(
+        'adamId' => :apple_id,
+        'name' => :name,
+        'vendorId' => :vendor_id,
+        'bundleId' => :bundle_id,
+        'lastModifiedDate' => :last_modified,
+        'issuesCount' => :issues_count,
+        'iconUrl' => :app_icon_preview_url
+      )
+
+      class << self
+        # Create a new object based on a hash.
+        # This is used to create a new object based on the server response.
+        def factory(attrs)
+          return self.new(attrs)
+        end
+
+        # @return (Array) Returns all apps available for this account
+        def all
+          client.applications.map { |application| self.factory(application) }
+        end
+
+        # @return (Spaceship::Tunes::Application) Returns the application matching the parameter
+        #   as either the App ID or the bundle identifier
+        def find(identifier, mac: false)
+          all.find do |app|
+            (app.apple_id == identifier.to_s || app.bundle_id == identifier) &&
+              app.version_sets.any? { |v| v.platform == (mac ? "osx" : "ios") }
+          end
+        end
+
+        # Creates a new application on iTunes Connect
+        # @param name (String): The name of your app as it will appear on the App Store.
+        #   This can't be longer than 255 characters.
+        # @param primary_language (String): If localized app information isn't available in an
+        #   App Store territory, the information from your primary language will be used instead.
+        # @param version (String): The version number is shown on the App Store and should
+        #   match the one you used in Xcode.
+        # @param sku (String): A unique ID for your app that is not visible on the App Store.
+        # @param bundle_id (String): The bundle ID must match the one you used in Xcode. It
+        #   can't be changed after you submit your first build.
+        # @param company_name (String): The company name or developer name to display on the App Store for your apps.
+        # It cannot be changed after you create your first app.
+        # @param platform (String): Platform one of (ios,osx)
+        #  should it be an ios or an osx app
+
+        def create!(name: nil, primary_language: nil, version: nil, sku: nil, bundle_id: nil, bundle_id_suffix: nil, company_name: nil, platform: nil)
+          client.create_application!(name: name,
+                         primary_language: primary_language,
+                                  version: version,
+                                      sku: sku,
+                                bundle_id: bundle_id,
+                                bundle_id_suffix: bundle_id_suffix,
+                                company_name: company_name,
+                                    platform: platform)
+        end
+      end
+
+      #####################################################
+      # @!group Getting information
+      #####################################################
+
+      def version_set_for_platform(platform)
+        version_sets.each do |version_set|
+          return version_set if version_set.platform == platform
+        end
+        nil
+      end
+
+      # @return (Spaceship::AppVersion) Receive the version that is currently live on the
+      #  App Store. You can't modify all values there, so be careful.
+      def live_version(platform: nil)
+        Spaceship::AppVersion.find(self, self.apple_id, true, platform: platform)
+      end
+
+      # @return (Spaceship::AppVersion) Receive the version that can fully be edited
+      def edit_version(platform: nil)
+        Spaceship::AppVersion.find(self, self.apple_id, false, platform: platform)
+      end
+
+      # @return (Spaceship::AppVersion) This will return the `edit_version` if available
+      #   and fallback to the `live_version`. Use this to just access the latest data
+      def latest_version(platform: nil)
+        edit_version(platform: platform) || live_version(platform: platform)
+      end
+
+      # @return (String) An URL to this specific resource. You can enter this URL into your browser
+      def url
+        "https://itunesconnect.apple.com/WebObjects/iTunesConnect.woa/ra/ng/app/#{self.apple_id}"
+      end
+
+      # @return (Hash) Contains the reason for rejection.
+      #  if everything is alright, the result will be
+      #  `{"sectionErrorKeys"=>[], "sectionInfoKeys"=>[], "sectionWarningKeys"=>[], "replyConstraints"=>{"minLength"=>1, "maxLength"=>4000}, "appNotes"=>{"threads"=>[]}, "betaNotes"=>{"threads"=>[]}, "appMessages"=>{"threads"=>[]}}`
+      def resolution_center
+        client.get_resolution_center(apple_id, platform)
+      end
+
+      def ratings
+        attrs = client.get_rating_summary(apple_id, platform)
+        attrs[:application] = self
+        Tunes::AppRatings.factory(attrs)
+      end
+
+      def platforms
+        platforms = []
+        version_sets.each do |version_set|
+          platforms << version_set.platform
+        end
+        platforms
+      end
+
+      def type
+        if self.version_sets.nil?
+          raise 'The application has no version sets and Spaceship does not know what to do here.'
+        end
+
+        if self.version_sets.length == 1
+          version_sets[0].platform
+        end
+        platform = Spaceship::Tunes::AppVersionCommon.find_platform(raw_data['versionSets'])
+        platform['type']
+      end
+
+      # kept for backward compatibility
+      # tries to guess the platform of the currently submitted apps
+      # note that as ITC now supports multiple app types, this might break
+      # if your app supports more than one
+      def platform
+        if self.version_sets.nil?
+          raise 'The application has no version sets and Spaceship does not know what to do here.'
+        end
+
+        if self.version_sets.length == 1
+          version_sets[0].platform
+        elsif self.platforms == %w(ios appletvos)
+          'ios'
+        end
+        Spaceship::Tunes::AppVersionCommon.find_platform(raw_data['versionSets'])['platformString']
+      end
+
+      def details
+        attrs = client.app_details(apple_id)
+        attrs[:application] = self
+        Tunes::AppDetails.factory(attrs)
+      end
+
+      def versions_history
+        ensure_not_a_bundle
+        versions = client.versions_history(apple_id, platform)
+        versions.map do |attrs|
+          attrs[:application] = self
+          Tunes::AppVersionHistory.factory(attrs)
+        end
+      end
+
+      #####################################################
+      # @!group Modifying
+      #####################################################
+
+      # Create a new version of your app
+      # Since we have stored the outdated raw_data, we need to refresh this object
+      # otherwise `edit_version` will return nil
+      def create_version!(version_number, platform: nil)
+        if edit_version(platform: platform)
+          raise "Cannot create a new version for this app as there already is an `edit_version` available"
+        end
+
+        client.create_version!(apple_id, version_number, platform.nil? ? 'ios' : platform)
+
+        # Future: implemented -reload method
+      end
+
+      # Will make sure the current edit_version matches the given version number
+      # This will either create a new version or change the version number
+      # from an existing version
+      # @return (Bool) Was something changed?
+      def ensure_version!(version_number, platform: nil)
+        if (e = edit_version(platform: platform))
+          if e.version.to_s != version_number.to_s
+            # Update an existing version
+            e.version = version_number
+            e.save!
+            return true
+          end
+          return false
+        else
+          create_version!(version_number, platform: platform)
+          return true
+        end
+      end
+
+      # set the price tier. This method doesn't require `save` to be called
+      def update_price_tier!(price_tier)
+        client.update_price_tier!(self.apple_id, price_tier)
+      end
+
+      # The current price tier
+      def price_tier
+        client.price_tier(self.apple_id)
+      end
+
+      #####################################################
+      # @!group Builds
+      #####################################################
+
+      # TestFlight: A reference to all the build trains
+      # @return [Hash] a hash, the version number and platform being the key
+      def build_trains(platform: nil)
+        Tunes::BuildTrain.all(self, self.apple_id, platform: platform)
+      end
+
+      # The numbers of all build trains that were uploaded
+      # @return [Array] An array of train version numbers
+      def all_build_train_numbers(platform: nil)
+        client.all_build_trains(app_id: self.apple_id, platform: platform).fetch("trains").collect do |current|
+          current["versionString"]
+        end
+      end
+
+      # Receive the build details for a specific build
+      # useful if the app is not listed in the TestFlight build list
+      # which might happen if you don't use TestFlight
+      # This is used to receive dSYM files from Apple
+      def all_builds_for_train(train: nil, platform: nil)
+        client.all_builds_for_train(app_id: self.apple_id, train: train, platform: platform).fetch("items", []).collect do |attrs|
+          attrs[:apple_id] = self.apple_id
+          Tunes::Build.factory(attrs)
+        end
+      end
+
+      # @return [Array]A list of binaries which are in the invalid state
+      def all_invalid_builds(platform: nil)
+        builds = []
+
+        self.build_trains(platform: platform).values.each do |train|
+          builds.concat(train.invalid_builds)
+        end
+
+        return builds
+      end
+
+      # @return [Array] This will return an array of *all* processing builds
+      #   this include pre-processing or standard processing
+      def all_processing_builds(platform: nil)
+        builds = []
+
+        self.build_trains(platform: platform).each do |version_number, train|
+          builds.concat(train.processing_builds)
+        end
+
+        return builds
+      end
+
+      # Get all builds that are already processed for all build trains
+      # You can either use the return value (array) or pass a block
+      def builds(platform: nil)
+        all_builds = []
+        self.build_trains(platform: platform).each do |version_number, train|
+          train.builds.each do |build|
+            yield(build) if block_given?
+            all_builds << build unless block_given?
+          end
+        end
+        all_builds
+      end
+
+      #####################################################
+      # @!group Submit for Review
+      #####################################################
+
+      def create_submission
+        version = self.latest_version
+        if version.nil?
+          raise "Could not find a valid version to submit for review"
+        end
+
+        Spaceship::AppSubmission.create(self, version)
+      end
+
+      # Cancels all ongoing TestFlight beta submission for this application
+      def cancel_all_testflight_submissions!
+        self.builds do |build|
+          begin
+            build.cancel_beta_review!
+          rescue
+            # We really don't care about any errors here
+          end
+        end
+        true
+      end
+
+      #####################################################
+      # @!group release
+      #####################################################
+
+      def release!
+        version = self.edit_version
+        if version.nil?
+          raise "Could not find a valid version to release"
+        end
+        version.release!
+      end
+
+      #####################################################
+      # @!group General
+      #####################################################
+      def setup
+        super
+        @version_sets = (self.raw_data['versionSets'] || []).map do |attrs|
+          attrs[:application] = self
+          Tunes::VersionSet.factory(attrs)
+        end
+      end
+
+      #####################################################
+      # @!group Testers
+      #####################################################
+
+      # Add all testers (internal and external) to the current app list
+      def add_all_testers!
+        Tunes::Tester.external.add_all_to_app!(self.apple_id)
+        Tunes::Tester.internal.add_all_to_app!(self.apple_id)
+      end
+
+      # @return (Array) Returns all external testers available for this app
+      def external_testers
+        Tunes::Tester.external.all_by_app(self.apple_id)
+      end
+
+      # @return (Array) Returns all internal testers available for this app
+      def internal_testers
+        Tunes::Tester.internal.all_by_app(self.apple_id)
+      end
+
+      # @return (Spaceship::Tunes::Tester.external) Returns the external tester matching the parameter
+      #   as either the Tester id or email
+      # @param identifier (String) (required): Value used to filter the tester
+      def find_external_tester(identifier)
+        Tunes::Tester.external.find_by_app(self.apple_id, identifier)
+      end
+
+      # @return (Spaceship::Tunes::Tester.internal) Returns the internal tester matching the parameter
+      #   as either the Tester id or email
+      # @param identifier (String) (required): Value used to filter the tester
+      def find_internal_tester(identifier)
+        Tunes::Tester.internal.find_by_app(self.apple_id, identifier)
+      end
+
+      # Add external tester to the current app list, if it doesn't exist will be created
+      # @param email (String) (required): The email of the tester
+      # @param first_name (String) (optional): The first name of the tester (Ignored if user already exist)
+      # @param last_name (String) (optional): The last name of the tester (Ignored if user already exist)
+      def add_external_tester!(email: nil, first_name: nil, last_name: nil)
+        raise "Tester is already on #{self.name} betatesters" if find_external_tester(email)
+
+        tester = Tunes::Tester.external.find(email) || Tunes::Tester.external.create!(email: email,
+                                                                                 first_name: first_name,
+                                                                                  last_name: last_name)
+        tester.add_to_app!(self.apple_id)
+      end
+
+      # Remove external tester from the current app list that matching the parameter
+      #   as either the Tester id or email
+      # @param identifier (String) (required): Value used to filter the tester
+      def remove_external_tester!(identifier)
+        tester = find_external_tester(identifier)
+
+        raise "Tester is not on #{self.name} betatesters" unless tester
+
+        tester.remove_from_app!(self.apple_id)
+      end
+
+      #####################################################
+      # @!group Promo codes
+      #####################################################
+      def promocodes
+        data = client.app_promocodes(app_id: self.apple_id)
+        data.map do |attrs|
+          Tunes::AppVersionPromocodes.factory(attrs)
+        end
+      end
+
+      def promocodes_history
+        data = client.app_promocodes_history(app_id: self.apple_id)
+        data.map do |attrs|
+          Tunes::AppVersionGeneratedPromocodes.factory(attrs)
+        end
+      end
+
+      # private to module
+      def ensure_not_a_bundle
+        # we only support applications
+        raise "We do not support BUNDLE types right now" if self.type == 'BUNDLE'
+      end
+    end
+  end
+end