fastlane_pricing_fix 2.212.1

data/deliver/lib/deliver/submit_for_review.rb

@@ -0,0 +1,236 @@
+require_relative 'module'
+
+require 'fastlane_core/build_watcher'
+require 'fastlane_core/ipa_file_analyser'
+require 'fastlane_core/pkg_file_analyser'
+
+module Deliver
+  class SubmitForReview
+    def submit!(options)
+      app = Deliver.cache[:app]
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      version = app.get_edit_app_store_version(platform: platform)
+
+      unless version
+        UI.user_error!("Cannot submit for review - could not find an editable version for '#{platform}'")
+        return
+      end
+
+      build = select_build(options, app, version, platform)
+
+      update_export_compliance(options, app, build)
+      update_idfa(options, app, version)
+      update_submission_information(options, app)
+
+      create_review_submission(options, app, version, platform)
+      UI.success("Successfully submitted the app for review!")
+    end
+
+    private
+
+    def create_review_submission(options, app, version, platform)
+      # Can't submit a review if there is already a review in progress
+      if app.get_in_progress_review_submission(platform: platform)
+        UI.user_error!("Cannot submit for review - A review submission is already in progress")
+      end
+
+      # There can only be one open submission per platform per app
+      # There might be a submission already created so we need to check
+      # 1. Create the submission if its not already created
+      # 2. Error if submission already contains some items for review (because we don't know what they are)
+      submission = app.get_ready_review_submission(platform: platform, includes: "items")
+      if submission.nil?
+        submission = app.create_review_submission(platform: platform)
+      elsif !submission.items.empty?
+        UI.user_error!("Cannot submit for review - A review submission already exists with items not managed by fastlane. Please cancel or remove items from submission for the App Store Connect website")
+      end
+
+      submission.add_app_store_version_to_review_items(app_store_version_id: version.id)
+      submission.submit_for_review
+    end
+
+    def select_build(options, app, version, platform)
+      if options[:build_number] && options[:build_number] != "latest"
+        UI.message("Selecting existing build-number: #{options[:build_number]}")
+
+        build = Spaceship::ConnectAPI::Build.all(
+          app_id: app.id,
+          version: options[:app_version],
+          build_number: options[:build_number],
+          platform: platform
+        ).first
+
+        unless build
+          UI.user_error!("Build number: #{options[:build_number]} does not exist")
+        end
+      else
+        UI.message("Selecting the latest build...")
+        build = wait_for_build_processing_to_be_complete(app: app, platform: platform, options: options)
+      end
+      UI.message("Selecting build #{build.app_version} (#{build.version})...")
+
+      version.select_build(build_id: build.id)
+
+      UI.success("Successfully selected build")
+
+      return build
+    end
+
+    def update_export_compliance(options, app, build)
+      submission_information = options[:submission_information] || {}
+      submission_information = submission_information.transform_keys(&:to_sym)
+
+      uses_encryption = submission_information[:export_compliance_uses_encryption]
+
+      if build.uses_non_exempt_encryption.nil?
+        UI.verbose("Updating build for export compliance status of '#{uses_encryption}'")
+
+        if uses_encryption.to_s.empty?
+          message = [
+            "Export compliance is required to submit",
+            "Add information to the :submission_information option...",
+            "  Docs: http://docs.fastlane.tools/actions/deliver/#compliance-and-idfa-settings",
+            "  Example: submission_information: { export_compliance_uses_encryption: false }",
+            "  Example CLI:",
+            "    --submission_information \"{\\\"export_compliance_uses_encryption\\\": false}\"",
+            "This can also be set in your Info.plist with key 'ITSAppUsesNonExemptEncryption'"
+          ].join("\n")
+          UI.user_error!(message)
+        end
+
+        build = build.update(attributes: {
+          usesNonExemptEncryption: uses_encryption
+        })
+
+        UI.verbose("Successfully updated build for export compliance status of '#{build.uses_non_exempt_encryption}' on App Store Connect")
+      end
+    end
+
+    def update_idfa(options, app, version)
+      submission_information = options[:submission_information] || {}
+      submission_information = submission_information.transform_keys(&:to_sym)
+
+      uses_idfa = submission_information[:add_id_info_uses_idfa]
+
+      idfa_declaration = begin
+                           version.fetch_idfa_declaration
+                         rescue
+                           nil
+                         end
+
+      updated_idfa = false
+
+      # Set IDFA on version
+      unless uses_idfa.nil?
+        UI.verbose("Updating app store version for IDFA status of '#{uses_idfa}'")
+        version = version.update(attributes: {
+          usesIdfa: uses_idfa
+        })
+        UI.verbose("Updated app store version for IDFA status of '#{version.uses_idfa}'")
+        updated_idfa = true
+      end
+
+      # Error if uses_idfa not set
+      if version.uses_idfa.nil?
+        message = [
+          "Use of Advertising Identifier (IDFA) is required to submit",
+          "Add information to the :submission_information option...",
+          "  Docs: http://docs.fastlane.tools/actions/deliver/#compliance-and-idfa-settings",
+          "  Example: submission_information: { add_id_info_uses_idfa: false }",
+          "  Example: submission_information: {",
+          "    add_id_info_uses_idfa: true,",
+          "    add_id_info_serves_ads: false,",
+          "    add_id_info_tracks_install: true,",
+          "    add_id_info_tracks_action: true,",
+          "    add_id_info_limits_tracking: true",
+          "  }",
+          "  Example CLI:",
+          "    --submission_information \"{\\\"add_id_info_uses_idfa\\\": false}\""
+        ].join("\n")
+        UI.user_error!(message)
+      end
+
+      # Create, update, or delete IDFA declaration
+      if uses_idfa == false
+        if idfa_declaration
+          UI.verbose("Deleting IDFA declaration")
+          idfa_declaration.delete!
+          updated_idfa = true
+          UI.verbose("Deleted IDFA declaration")
+        end
+      elsif uses_idfa == true
+        attributes = {
+          honorsLimitedAdTracking: !!submission_information[:add_id_info_limits_tracking],
+          servesAds: !!submission_information[:add_id_info_serves_ads],
+          attributesAppInstallationToPreviousAd: !!submission_information[:add_id_info_tracks_install],
+          attributesActionWithPreviousAd: !!submission_information[:add_id_info_tracks_action]
+        }
+
+        if idfa_declaration
+          UI.verbose("Updating IDFA declaration")
+          idfa_declaration.update(attributes: attributes)
+          UI.verbose("Updated IDFA declaration")
+        else
+          UI.verbose("Creating IDFA declaration")
+          version.create_idfa_declaration(attributes: attributes)
+          UI.verbose("Created IDFA declaration")
+        end
+
+        updated_idfa = true
+      end
+
+      UI.success("Successfully updated IDFA declarations on App Store Connect") if updated_idfa
+    end
+
+    def update_submission_information(options, app)
+      submission_information = options[:submission_information] || {}
+      submission_information = submission_information.transform_keys(&:to_sym)
+
+      content_rights = submission_information[:content_rights_contains_third_party_content]
+
+      unless content_rights.nil?
+        value = if content_rights
+                  Spaceship::ConnectAPI::App::ContentRightsDeclaration::USES_THIRD_PARTY_CONTENT
+                else
+                  Spaceship::ConnectAPI::App::ContentRightsDeclaration::DOES_NOT_USE_THIRD_PARTY_CONTENT
+                end
+
+        UI.verbose("Updating contents rights declaration on App Store Connect")
+        app.update(attributes: {
+          contentRightsDeclaration: value
+        })
+        UI.success("Successfully updated contents rights declaration on App Store Connect")
+      end
+    end
+
+    def wait_for_build_processing_to_be_complete(app: nil, platform: nil, options: nil)
+      app_version = options[:app_version]
+
+      app_version ||= FastlaneCore::IpaFileAnalyser.fetch_app_version(options[:ipa]) if options[:ipa]
+      app_version ||= FastlaneCore::PkgFileAnalyser.fetch_app_version(options[:pkg]) if options[:pkg]
+
+      app_build ||= FastlaneCore::IpaFileAnalyser.fetch_app_build(options[:ipa]) if options[:ipa]
+      app_build ||= FastlaneCore::PkgFileAnalyser.fetch_app_build(options[:pkg]) if options[:pkg]
+
+      latest_build = FastlaneCore::BuildWatcher.wait_for_build_processing_to_be_complete(
+        app_id: app.id,
+        platform: platform,
+        app_version: app_version,
+        build_version: app_build,
+        poll_interval: 15,
+        return_when_build_appears: false,
+        return_spaceship_testflight_build: false,
+        select_latest: true
+      )
+
+      if !app_version.nil? && !app_build.nil?
+        unless latest_build.app_version == app_version && latest_build.version == app_build
+          UI.important("Uploaded app #{app_version} - #{app_build}, but received build #{latest_build.app_version} - #{latest_build.version}.")
+        end
+      end
+
+      return latest_build
+    end
+  end
+end

data/deliver/lib/deliver/sync_screenshots.rb

@@ -0,0 +1,200 @@
+require 'fastlane_core'
+require 'digest/md5'
+require 'naturally'
+
+require_relative 'app_screenshot'
+require_relative 'app_screenshot_iterator'
+require_relative 'loader'
+require_relative 'screenshot_comparable'
+
+module Deliver
+  class SyncScreenshots
+    DeleteScreenshotJob = Struct.new(:app_screenshot, :locale)
+    UploadScreenshotJob = Struct.new(:app_screenshot_set, :path)
+
+    class UploadResult
+      attr_reader :asset_delivery_state_counts, :failing_screenshots
+
+      def initialize(asset_delivery_state_counts:, failing_screenshots:)
+        @asset_delivery_state_counts = asset_delivery_state_counts
+        @failing_screenshots = failing_screenshots
+      end
+
+      def processing?
+        @asset_delivery_state_counts.fetch('UPLOAD_COMPLETE', 0) > 0
+      end
+
+      def screenshot_count
+        @asset_delivery_state_counts.fetch('COMPLETE', 0)
+      end
+    end
+
+    def initialize(app:, platform:)
+      @app = app
+      @platform = platform
+    end
+
+    def sync_from_path(screenshots_path)
+      # load local screenshots
+      screenshots = Deliver::Loader.load_app_screenshots(screenshots_path, true)
+      sync(screenshots)
+    end
+
+    def sync(screenshots)
+      UI.important('This is currently a beta feature in fastlane. This may cause some errors on your environment.')
+
+      unless FastlaneCore::Feature.enabled?('FASTLANE_ENABLE_BETA_DELIVER_SYNC_SCREENSHOTS')
+        UI.user_error!('Please set a value to "FASTLANE_ENABLE_BETA_DELIVER_SYNC_SCREENSHOTS" environment variable ' \
+                       'if you acknowleage the risk and try this out.')
+      end
+
+      UI.important("Will begin uploading snapshots for '#{version.version_string}' on App Store Connect")
+
+      # enable localizations that will be used
+      screenshots_per_language = screenshots.group_by(&:language)
+      enable_localizations(screenshots_per_language.keys)
+
+      # create iterator
+      localizations = fetch_localizations
+      iterator = Deliver::AppScreenshotIterator.new(localizations)
+
+      # sync local screenshots with remote settings by deleting and uploading
+      UI.message("Starting with the upload of screenshots...")
+      replace_screenshots(iterator, screenshots)
+
+      # ensure screenshots within screenshot sets are sorted in right order
+      sort_screenshots(iterator)
+
+      UI.important('Screenshots are synced successfully!')
+    end
+
+    def enable_localizations(locales)
+      localizations = fetch_localizations
+      locales_to_enable = locales - localizations.map(&:locale)
+      Helper.show_loading_indicator("Activating localizations for #{locales_to_enable.join(', ')}...")
+      locales_to_enable.each do |locale|
+        version.create_app_store_version_localization(attributes: { locale: locale })
+      end
+      Helper.hide_loading_indicator
+    end
+
+    def replace_screenshots(iterator, screenshots, retries = 3)
+      # delete and upload screenshots to get App Store Connect in sync
+      do_replace_screenshots(iterator, screenshots, create_delete_worker, create_upload_worker)
+
+      # wait for screenshots to be processed on App Store Connect end and
+      # ensure the number of uploaded screenshots matches the one in local
+      result = wait_for_complete(iterator)
+      return if !result.processing? && result.screenshot_count == screenshots.count
+
+      if retries.zero?
+        UI.crash!("Retried uploading screenshots #{retries} but there are still failures of processing screenshots." \
+                  "Check App Store Connect console to work out which screenshots processed unsuccessfully.")
+      end
+
+      # retry with deleting failing screenshots
+      result.failing_screenshots.each(&:delete!)
+      replace_screenshots(iterator, screenshots, retries - 1)
+    end
+
+    # This is a testable method that focuses on figuring out what to update
+    def do_replace_screenshots(iterator, screenshots, delete_worker, upload_worker)
+      remote_screenshots = iterator.each_app_screenshot.map do |localization, app_screenshot_set, app_screenshot|
+        ScreenshotComparable.create_from_remote(app_screenshot: app_screenshot, locale: localization.locale)
+      end
+
+      local_screenshots = iterator.each_local_screenshot(screenshots.group_by(&:language)).map do |localization, app_screenshot_set, screenshot, index|
+        if index >= 10
+          UI.user_error!("Found #{localization.locale} has more than 10 screenshots for #{app_screenshot_set.screenshot_display_type}. "\
+                         "Make sure containts only necessary screenshots.")
+        end
+        ScreenshotComparable.create_from_local(screenshot: screenshot, app_screenshot_set: app_screenshot_set)
+      end
+
+      # Thanks to `Array#-` API and `ScreenshotComparable`, working out diffs between local screenshot directory and App Store Connect
+      # is as easy as you can see below. The former one finds what is missing in local and the latter one is visa versa.
+      screenshots_to_delete = remote_screenshots - local_screenshots
+      screenshots_to_upload = local_screenshots - remote_screenshots
+
+      delete_jobs = screenshots_to_delete.map { |x| DeleteScreenshotJob.new(x.context[:app_screenshot], x.context[:locale]) }
+      delete_worker.batch_enqueue(delete_jobs)
+      delete_worker.start
+
+      upload_jobs = screenshots_to_upload.map { |x| UploadScreenshotJob.new(x.context[:app_screenshot_set], x.context[:screenshot].path) }
+      upload_worker.batch_enqueue(upload_jobs)
+      upload_worker.start
+    end
+
+    def wait_for_complete(iterator)
+      retry_count = 0
+      Helper.show_loading_indicator("Waiting for all the screenshots processed...")
+      loop do
+        failing_screenshots = []
+        state_counts = iterator.each_app_screenshot.map { |_, _, app_screenshot| app_screenshot }.each_with_object({}) do |app_screenshot, hash|
+          state = app_screenshot.asset_delivery_state['state']
+          hash[state] ||= 0
+          hash[state] += 1
+          failing_screenshots << app_screenshot if app_screenshot.error?
+        end
+
+        result = UploadResult.new(asset_delivery_state_counts: state_counts, failing_screenshots: failing_screenshots)
+        return result unless result.processing?
+
+        # sleep with exponential backoff
+        interval = 5 + (2**retry_count)
+        UI.message("There are still incomplete screenshots. Will check the states again in #{interval} secs - #{state_counts}")
+        sleep(interval)
+        retry_count += 1
+      end
+    ensure
+      Helper.hide_loading_indicator
+    end
+
+    def sort_screenshots(iterator)
+      Helper.show_loading_indicator("Sorting screenshots uploaded...")
+      sort_worker = create_sort_worker
+      sort_worker.batch_enqueue(iterator.each_app_screenshot_set.to_a.map { |_, set| set })
+      sort_worker.start
+      Helper.hide_loading_indicator
+    end
+
+    private
+
+    def version
+      @version ||= @app.get_edit_app_store_version(platform: @platform)
+    end
+
+    def fetch_localizations
+      version.get_app_store_version_localizations
+    end
+
+    def create_upload_worker
+      FastlaneCore::QueueWorker.new do |job|
+        UI.verbose("Uploading '#{job.path}'...")
+        start_time = Time.now
+        job.app_screenshot_set.upload_screenshot(path: job.path, wait_for_processing: false)
+        UI.message("Uploaded '#{job.path}'... (#{Time.now - start_time} secs)")
+      end
+    end
+
+    def create_delete_worker
+      FastlaneCore::QueueWorker.new do |job|
+        target = "id=#{job.app_screenshot.id} #{job.locale} #{job.app_screenshot.file_name}"
+        UI.verbose("Deleting '#{target}'")
+        start_time = Time.now
+        job.app_screenshot.delete!
+        UI.message("Deleted '#{target}' -  (#{Time.now - start_time} secs)")
+      end
+    end
+
+    def create_sort_worker
+      FastlaneCore::QueueWorker.new do |app_screenshot_set|
+        original_ids = app_screenshot_set.app_screenshots.map(&:id)
+        sorted_ids = Naturally.sort(app_screenshot_set.app_screenshots, by: :file_name).map(&:id)
+        if original_ids != sorted_ids
+          app_screenshot_set.reorder_screenshots(app_screenshot_ids: sorted_ids)
+        end
+      end
+    end
+  end
+end