fastlane_pricing_fix 2.212.1

data/spaceship/lib/spaceship/tunes/build_train.rb

@@ -0,0 +1,181 @@
+require_relative 'tunes_base'
+require_relative 'errors'
+require_relative 'build'
+
+module Spaceship
+  module Tunes
+    # Represents a build train of builds from App Store Connect
+    # A build train is all builds for a given version number with different build numbers
+    class BuildTrain < TunesBase
+      # @return (Spaceship::Tunes::Application) A reference to the application this train is for
+      attr_accessor :application
+
+      # @return (Spaceship::Tunes::VersionSet) A reference to the version set
+      #   this train is for
+      attr_accessor :version_set
+
+      # @return (Array) An array of all builds that are inside this train (Spaceship::Tunes::Build)
+      attr_reader :builds
+
+      # @return (String) The version number of this train
+      attr_reader :version_string
+
+      # @return (String) Platform (e.g. "ios")
+      attr_reader :platform
+
+      # @return (Bool) Is external beta testing enabled for this train? Only one train can have enabled testing.
+      attr_reader :external_testing_enabled
+
+      # @return (Bool) Is internal beta testing enabled for this train? Only one train can have enabled testing.
+      attr_reader :internal_testing_enabled
+
+      # @return (Array) An array of all processing builds that are inside this train (Spaceship::Tunes::Build)
+      # Does not include invalid builds.
+      #  I never got this to work to properly try and debug this
+      attr_reader :processing_builds
+
+      # @return (Array) An array of all invalid builds that are inside this train
+      attr_reader :invalid_builds
+
+      attr_mapping(
+        'application' => 'application',
+        'versionString' => :version_string,
+        'platform' => :platform,
+        'externalTesting.value' => :external_testing_enabled,
+        'internalTesting.value' => :internal_testing_enabled
+      )
+
+      class << self
+        # @param application (Spaceship::Tunes::Application) The app this train is for
+        # @param app_id (String) The unique Apple ID of this app
+        def all(application, app_id, platform: nil)
+          trains = []
+          trains += client.build_trains(app_id, 'internal', platform: platform)['trains']
+          trains += client.build_trains(app_id, 'external', platform: platform)['trains']
+
+          result = {}
+          trains.each do |attrs|
+            attrs[:application] = application
+            current = self.factory(attrs)
+            if (!platform.nil? && current.platform == platform) || platform.nil?
+              result[current.version_string] = current
+            end
+          end
+          result
+        end
+      end
+
+      # Setup all the builds and processing builds
+      def setup
+        super
+
+        @builds = (self.raw_data['builds'] || []).collect do |attrs|
+          attrs[:build_train] = self
+          Tunes::Build.factory(attrs)
+        end
+
+        @invalid_builds = @builds.select do |build|
+          build.processing_state == 'processingFailed' || build.processing_state == 'invalidBinary'
+        end
+
+        # This step may not be necessary anymore - it seems as if every processing build will be caught by the
+        # @builds.each below, but not every processing build makes it to buildsInProcessing, so this is redundant
+        @processing_builds = (self.raw_data['buildsInProcessing'] || []).collect do |attrs|
+          attrs[:build_train] = self
+          Tunes::Build.factory(attrs)
+        end
+
+        # since buildsInProcessing appears empty, fallback to also including processing state from @builds
+        @builds.each do |build|
+          # What combination of attributes constitutes which state is pretty complicated. The table below summarizes
+          # what I've observed, but there's no reason to believe there aren't more states I just haven't seen yet.
+          # The column headers are qualitative states of a given build, and the first column is the observed attributes
+          # of that build.
+          # NOTE: Some of the builds in the build_trains.json fixture do not follow these rules. I don't know if that is
+          # because those examples are older, and the iTC API has changed, or if their format is still a possibility.
+          # The second part of the OR clause in the line below exists so that those suspicious examples continue to be
+          # accepted for unit tests.
+          # +---------------------+-------------------+-------------------+-----------------+--------------------+---------+
+          # |                     | just after upload | normal processing | invalid binary  | processing failed  | success |
+          # +---------------------+-------------------+-------------------+-----------------+--------------------+---------+
+          # |  build.processing = | true              | true              | true            | true               | false   |
+          # |       build.valid = | false             | true              | false           | true               | true    |
+          # | .processing_state = | "processing"      | "processing"      | "invalidBinary" | "processingFailed" | nil     |
+          # +---------------------+-------------------+-------------------+-----------------+--------------------+---------+
+          if build.processing_state == 'processing' || (build.processing && build.processing_state != 'invalidBinary' && build.processing_state != 'processingFailed')
+            @processing_builds << build
+          end
+        end
+
+        self.version_set = self.application.version_set_for_platform(self.platform)
+      end
+
+      # @return (Spaceship::Tunes::Build) The latest build for this train, sorted by upload time.
+      def latest_build
+        @builds.max_by(&:upload_date)
+      end
+
+      # @param (testing_type) internal or external
+      def update_testing_status!(new_value, testing_type, build = nil)
+        build ||= latest_build if testing_type == 'external'
+        platform = build ? build.platform : self.application.platform
+        testing_key = "#{testing_type}Testing"
+
+        data = client.build_trains(self.application.apple_id, testing_type, platform: platform)
+
+        # Delete the irrelevant trains and update the relevant one to enable testing
+        data['trains'].delete_if do |train|
+          if train['versionString'] != version_string
+            true
+          else
+            train[testing_key]['value'] = new_value
+
+            # also update the builds
+            train['builds'].delete_if do |b|
+              if b[testing_key].nil?
+                true
+              elsif build && b["buildVersion"] == build.build_version
+                b[testing_key]['value'] = new_value
+                false
+              elsif b[testing_key]['value'] == true
+                b[testing_key]['value'] = false
+                false
+              else
+                true
+              end
+            end
+
+            false
+          end
+        end
+
+        begin
+          result = client.update_build_trains!(application.apple_id, testing_type, data)
+        rescue Spaceship::Tunes::Error => ex
+          if ex.to_s.include?("You must provide an answer for this question")
+            # This is a very common error message that's raised by TestFlight
+            # We want to show a nicer error message with instructions on how
+            # to resolve the underlying issue
+            # https://github.com/fastlane/fastlane/issues/1873
+            # https://github.com/fastlane/fastlane/issues/4002
+            error_message = [""] # to have a nice new-line in the beginning
+            error_message << "TestFlight requires you to provide the answer to the encryption question"
+            error_message << "to provide the reply, please add the following to your Info.plist file"
+            error_message << ""
+            error_message << "<key>ITSAppUsesNonExemptEncryption</key><false/>"
+            error_message << ""
+            error_message << "Afterwards re-build your app and try again"
+            error_message << "App Store Connect reported: '#{ex}'"
+            raise error_message.join("\n")
+          else
+            raise ex
+          end
+        end
+        self.internal_testing_enabled = new_value if testing_type == 'internal'
+        self.external_testing_enabled = new_value if testing_type == 'external'
+
+        result
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/developer_response.rb

@@ -0,0 +1,23 @@
+require_relative 'tunes_base'
+
+module Spaceship
+  module Tunes
+    class DeveloperResponse < TunesBase
+      attr_reader :id
+      attr_reader :response
+      attr_reader :last_modified
+      attr_reader :hidden
+      attr_reader :state
+      attr_accessor :application
+      attr_accessor :review_id
+
+      attr_mapping({
+        'responseId' => :id,
+        'response' => :response,
+        'lastModified' => :last_modified,
+        'isHidden' => :hidden,
+        'pendingState' => :state
+      })
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/device_type.rb

@@ -0,0 +1,17 @@
+require_relative "display_family"
+
+module Spaceship
+  module Tunes
+    # identifiers of devices that App Store Connect accepts screenshots for
+    class DeviceType
+      def self.types
+        warn("Spaceship::Tunes::DeviceType has been deprecated, use Spaceship::Tunes::DisplayFamily instead. (https://github.com/fastlane/fastlane/pull/14574).")
+        return DisplayFamily.all.map(&:name)
+      end
+
+      def self.exists?(type)
+        types.include?(type)
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/display_family.rb

@@ -0,0 +1,84 @@
+require_relative "../module"
+
+module Spaceship
+  module Tunes
+    # A definition of different styled displays used by devices
+    # that App Store Connect supports storing screenshots.
+    # Display styles often only vary based on screen resolution
+    # however other aspects of a displays physical appearance are
+    # also factored (i.e if the home indicator is provided via
+    # a hardware button or a software interface).
+    class DisplayFamily
+      # The display family name from the App Store Connect API that
+      # is used when uploading or listing screenshots. This value is
+      # then assigned to the
+      # Spaceship::Tunes::AppScreenshot#device_type attribute.
+      attr_accessor :name
+
+      # The user friendly name of this definition.
+      #
+      # Source: Media Manager in App Store Connect.
+      attr_accessor :friendly_name
+
+      # The user friendly category for this definition (i.e iPhone,
+      # Apple TV or Desktop).
+      attr_accessor :friendly_category_name
+
+      # An array of supported screen resolutions (in pixels) that are
+      # supported for the associated device.
+      #
+      # Source: https://help.apple.com/app-store-connect/#/devd274dd925
+      attr_accessor :screenshot_resolutions
+
+      # An internal identifier for the same device definition used
+      # in the DUClient.
+      #
+      # Source: You can find this by uploading an image in App Store
+      # Connect using your browser and then look for the
+      # X-Apple-Upload-Validation-RuleSets value in the uploads
+      # request headers.
+      attr_accessor :picture_type
+
+      # Similar to `picture_type`, but for iMessage screenshots.
+      attr_accessor :messages_picture_type
+
+      # Identifies if the device definition supports iMessage screenshots.
+      def messages_supported?
+        true unless messages_picture_type.nil?
+      end
+
+      # Finds a DisplayFamily definition.
+      #
+      # @param name (Symbol|String) The name of the display family being searched for.
+      # @return DisplayFamily object matching the given name.
+      def self.find(name)
+        name = name.to_sym if name.kind_of?(String)
+        lookup[name]
+      end
+
+      # All DisplayFamily types currently supported by App Store Connect.
+      def self.all
+        lookup.values
+      end
+
+      private_class_method
+
+      def self.lookup
+        return @lookup if defined?(@lookup)
+        display_families = JSON.parse(File.read(File.join(Spaceship::ROOT, "lib", "assets", "displayFamilies.json")))
+        @lookup ||= display_families.map { |data| [data["name"].to_sym, DisplayFamily.new(data)] }.to_h
+      end
+
+      private
+
+      def initialize(data)
+        @name = data["name"]
+        @friendly_name = data["friendly_name"]
+        @friendly_category_name = data["friendly_category_name"]
+        @screenshot_resolutions = data["screenshot_resolutions"]
+        @picture_type = data["picture_type"]
+        @messages_picture_type = data["messages_picture_type"]
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/errors.rb

@@ -0,0 +1,17 @@
+require_relative '../errors'
+
+module Spaceship
+  module Tunes
+    # ITunesConnectError is only thrown when App Store Connect raises an exception
+    class Error < BasicPreferredInfoError
+    end
+
+    # raised if the server failed to save temporarily
+    class TemporaryError < Spaceship::Tunes::Error
+    end
+
+    # raised if the server failed to save, and it might be caused by an invisible server error
+    class PotentialServerError < Spaceship::Tunes::Error
+    end
+  end
+end

data/spaceship/lib/spaceship/tunes/iap.rb

@@ -0,0 +1,168 @@
+require 'spaceship/tunes/errors'
+require 'spaceship/tunes/iap_list'
+require 'spaceship/tunes/iap_detail'
+require 'spaceship/tunes/iap_status'
+require 'spaceship/tunes/iap_type'
+require 'spaceship/tunes/iap_family_list'
+require 'spaceship/tunes/iap_families'
+require 'spaceship/tunes/iap_family_details'
+require 'spaceship/tunes/iap_families'
+require 'spaceship/tunes/iap_subscription_pricing_tier'
+
+module Spaceship
+  module Tunes
+    class IAP < TunesBase
+      # @return (Spaceship::Tunes::Application) A reference to the application
+      attr_accessor :application
+
+      # @return (Spaceship::Tunes::IAPFamilies) A reference to the familie list
+      def families
+        attrs = {}
+        attrs[:application] = self.application
+        Tunes::IAPFamilies.new(attrs)
+      end
+
+      # Creates a new In-App-Purchese on App Store Connect
+      # if the In-App-Purchase already exists an exception is raised. Spaceship::TunesClient::ITunesConnectError
+      # @param type (String): The Type of the in-app-purchase (Spaceship::Tunes::IAPType::CONSUMABLE,Spaceship::Tunes::IAPType::NON_CONSUMABLE,Spaceship::Tunes::IAPType::RECURRING,Spaceship::Tunes::IAPType::NON_RENEW_SUBSCRIPTION)
+      # @param versions (Hash): a Hash of the languages
+      # @example: {
+      #   'de-DE': {
+      #     name: "Name shown in AppStore",
+      #     description: "Description of the In app Purchase"
+      #
+      #   }
+      # }
+      # @param reference_name (String): iTC Reference Name
+      # @param product_id (String): A unique ID for your in-app-purchase
+      # @param bundle_id (String): The bundle ID must match the one you used in Xcode. It
+      # @param cleared_for_sale (Boolean): Is this In-App-Purchase Cleared for Sale
+      # @param review_notes (String): Review Notes
+      # @param review_screenshot (String): Path to the screenshot (should be 640x940 PNG)
+      # @param pricing_intervals (Hash): a Hash of the languages
+      # @example:
+      #  [
+      #    {
+      #      country: "WW",
+      #      begin_date: nil,
+      #      end_date: nil,
+      #      tier: 1
+      #    }
+      #  ]
+      # @param family_id (String) Only used on RECURRING purchases, assigns the In-App-Purchase to a specific familie
+      # @param subscription_free_trial (String) Free Trial duration (1w,1m,3m....)
+      # @param subscription_duration (String) 1w,1m.....
+      # @param subscription_price_target (Hash) Only used on RECURRING purchases, used to set the
+      # price of all the countries to be roughly the same as the price calculated from the price
+      # tier and currency given as input.
+      # @example:
+      #  {
+      #    currency: "EUR",
+      #    tier: 2
+      #  }
+      def create!(type: "consumable",
+                  versions: nil,
+                  reference_name: nil,
+                  product_id: nil,
+                  cleared_for_sale: true,
+                  merch_screenshot: nil,
+                  review_notes: nil,
+                  review_screenshot: nil,
+                  pricing_intervals: nil,
+                  family_id: nil,
+                  subscription_free_trial: nil,
+                  subscription_duration: nil,
+                  subscription_price_target: nil)
+        client.create_iap!(app_id: self.application.apple_id,
+                           type: type,
+                           versions: versions,
+                           reference_name: reference_name,
+                           product_id: product_id,
+                           cleared_for_sale: cleared_for_sale,
+                           merch_screenshot: merch_screenshot,
+                           review_notes: review_notes,
+                           review_screenshot: review_screenshot,
+                           pricing_intervals: pricing_intervals,
+                           family_id: family_id,
+                           subscription_duration: subscription_duration,
+                           subscription_free_trial: subscription_free_trial)
+
+        # Update pricing for a recurring subscription.
+        if type == Spaceship::Tunes::IAPType::RECURRING &&
+           (pricing_intervals || subscription_price_target)
+          # There are cases where the product that was just created is not immediately found,
+          # and in order to update its pricing the purchase_id is needed. Therefore polling is done
+          # for 4 times until it is found. If it's not found after 6 tries, a PotentialServerError
+          # exception is raised.
+          product = find_product_with_retries(product_id, 6)
+          raw_pricing_intervals =
+            client.transform_to_raw_pricing_intervals(application.apple_id,
+                                                      product.purchase_id, pricing_intervals,
+                                                      subscription_price_target)
+          client.update_recurring_iap_pricing!(app_id: self.application.apple_id,
+                                               purchase_id: product.purchase_id,
+                                               pricing_intervals: raw_pricing_intervals)
+        end
+      end
+
+      # return all available In-App-Purchase's of current app
+      # this is not paged inside iTC-API so if you have a lot if IAP's (2k+)
+      # it might take some time to load, same as it takes when you load the list via App Store Connect
+      def all(include_deleted: false)
+        r = client.iaps(app_id: self.application.apple_id)
+        return_iaps = []
+        r.each do |product|
+          attrs = product
+          attrs[:application] = self.application
+          loaded_iap = Tunes::IAPList.factory(attrs)
+          next if loaded_iap.status == "deleted" && !include_deleted
+          return_iaps << loaded_iap
+        end
+        return_iaps
+      end
+
+      # find a specific product
+      # @param product_id (String) Product Id
+      def find(product_id)
+        all.each do |product|
+          if product.product_id == product_id
+            return product
+          end
+        end
+        return nil
+      end
+
+      # generate app-specific shared secret (or regenerate if exists)
+      def generate_shared_secret
+        client.generate_shared_secret(app_id: self.application.apple_id)
+      end
+
+      # retrieve app-specific shared secret
+      # @param create (Boolean) Create new shared secret if does not exist
+      def get_shared_secret(create: false)
+        secret = client.get_shared_secret(app_id: self.application.apple_id)
+        if create && secret.nil?
+          secret = generate_shared_secret
+        end
+        secret
+      end
+
+      private
+
+      def find_product_with_retries(product_id, max_tries)
+        try_number = 0
+        product = nil
+        until product
+          if try_number > max_tries
+            raise PotentialServerError.new, "Failed to find the product with id=#{product_id}. "\
+            "This can be caused either by a server error or due to the removal of the product."
+          end
+          product = find(product_id)
+          try_number += 1
+        end
+
+        product
+      end
+    end
+  end
+end