fastlane 2.147.0 → 2.150.0.rc1

data/deliver/lib/deliver/submit_for_review.rb

@@ -1,128 +1,169 @@
 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 = options[:app]
-      select_build(options)
-
-      UI.message("Submitting the app for review...")
-      submission = app.create_submission(platform: options[:platform])
-
-      # Set app submission information
-      # Default Values
-      submission.content_rights_contains_third_party_content = false
-      submission.content_rights_has_rights = true
-      submission.add_id_info_uses_idfa = false
-
-      # User Values
-      if options[:submission_information]
-        options[:submission_information].each do |key, value|
-          UI.message("Setting '#{key}' to '#{value}'...")
-          submission.send("#{key}=", value)
-        end
+      legacy_app = options[:app]
+      app_id = legacy_app.apple_id
+      app = Spaceship::ConnectAPI::App.get(app_id: app_id)
+
+      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
 
-      # Finalize app submission
-      submission.complete!
+      build = select_build(options, app, version, platform)
+
+      update_export_compliance(options, app, build)
+      update_idfa(options, app, version)
+      update_submission_information(options, app)
+
+      version.create_app_store_version_submission
 
       UI.success("Successfully submitted the app for review!")
     end
 
-    private def select_build(options)
-      app = options[:app]
-      app_version = options[:app_version]
-      v = app.edit_version(platform: options[:platform])
-
+    private 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 = v.candidate_builds.detect { |a| a.build_version == 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(app, app_version)
+        build = wait_for_build_processing_to_be_complete(app: app, platform: platform, options: options)
       end
-      UI.message("Selecting build #{app_version} (#{build.build_version})...")
+      UI.message("Selecting build #{build.app_version} (#{build.version})...")
 
-      v.select_build(build)
-      v.save!
+      version.select_build(build_id: build.id)
 
       UI.success("Successfully selected build")
-    end
 
-    def wait_for_build(app, app_version)
-      UI.user_error!("Could not find app with app identifier") unless app
+      return build
+    end
 
-      start = Time.now
-      build = nil
+    def update_export_compliance(options, app, build)
+      submission_information = options[:submission_information] || {}
+      uses_encryption = submission_information[:export_compliance_uses_encryption]
 
-      use_latest_version = app_version.nil?
+      UI.verbose("Updating build for export compliance status of '#{uses_encryption}'")
+      if build.uses_non_exempt_encryption.nil?
+        build = build.update(attributes: {
+          usesNonExemptEncryption: uses_encryption
+        })
+      end
+      UI.verbose("Updated build for export compliance status of '#{build.uses_non_exempt_encryption}'")
+    end
 
-      loop do
-        # Sometimes candidate_builds don't appear immediately after submission
-        # Wait for candidate_builds to appear on App Store Connect
-        # Issue https://github.com/fastlane/fastlane/issues/10411
-        if use_latest_version
-          candidate_builds = app.latest_version.candidate_builds
-        else
-          candidate_builds = app.tunes_all_builds_for_train(train: app_version)
+    def update_idfa(options, app, version)
+      submission_information = options[:submission_information] || {}
+      return unless submission_information.include?(:add_id_info_uses_idfa)
+
+      uses_idfa = submission_information[:add_id_info_uses_idfa]
+      idfa_declaration = begin
+                           version.fetch_idfa_declaration
+                         rescue
+                           nil
+                         end
+
+      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}'")
+
+      if uses_idfa == false
+        if idfa_declaration
+          UI.verbose("Deleting IDFA delcaration")
+          idfa_declaration.delete!
+          UI.verbose("Deleted IDFA delcaration")
         end
-        if (candidate_builds || []).count == 0
-          UI.message("Waiting for candidate builds to appear...")
-          if (Time.now - start) > (60 * 5)
-            UI.user_error!("Could not find any available candidate builds on App Store Connect to submit")
-          else
-            sleep(30)
-            next
-          end
+      else
+        attributes = {}
+        if submission_information.include?(:add_id_info_limits_tracking)
+          attributes[:honorsLimitedAdTracking] = submission_information[:add_id_info_limits_tracking]
         end
 
-        latest_build = find_build(candidate_builds)
-
-        # if the app version isn't present in the hash (could happen if we are waiting for submission, but didn't provide
-        # it explicitly and no ipa was passed to grab it from), then fall back to the best guess, which is the train_version
-        # of the most recently uploaded build
-        app_version ||= latest_build.train_version
-
-        # Sometimes latest build will disappear and a different build would get selected
-        # Only set build if no latest build found or if same build versions as previously fetched build
-        # Issue: https://github.com/fastlane/fastlane/issues/10945
-        if build.nil? || (latest_build && latest_build.build_version == build.build_version && latest_build.train_version == app_version)
-          build = latest_build
+        if submission_information.include?(:add_id_info_serves_ads)
+          attributes[:servesAds] = submission_information[:add_id_info_serves_ads]
         end
 
-        return build if build && build.processing == false
+        if submission_information.include?(:add_id_info_tracks_install)
+          attributes[:attributesAppInstallationToPreviousAd] = submission_information[:add_id_info_tracks_install]
+        end
 
-        if build
-          UI.message("Waiting App Store Connect processing for build #{app_version} (#{build.build_version})... this might take a while...")
-        else
-          UI.message("Waiting App Store Connect processing for build... this might take a while...")
+        if submission_information.include?(:add_id_info_tracks_action)
+          attributes[:attributesActionWithPreviousAd] = submission_information[:add_id_info_tracks_action]
         end
 
-        if (Time.now - start) > (60 * 5)
-          UI.message("")
-          UI.message("You can tweet: \"App Store Connect #iosprocessingtime #{((Time.now - start) / 60).round} minutes\"")
+        if idfa_declaration
+          UI.verbose("Updating IDFA delcaration")
+          idfa_declaration.update(attributes: attributes)
+          UI.verbose("Updated IDFA delcaration")
+        else
+          UI.verbose("Creating IDFA delcaration")
+          version.create_idfa_declaration(attributes: attributes)
+          UI.verbose("Created IDFA delcaration")
         end
-        sleep(30)
       end
-      nil
+
+      UI.success("Successfully updated IDFA delcarations")
     end
 
-    def find_build(candidate_builds)
-      if (candidate_builds || []).count == 0
-        UI.user_error!("Could not find any available candidate builds on App Store Connect to submit")
+    def update_submission_information(options, app)
+      submission_information = options[:submission_information] || {}
+      if submission_information.include?(:content_rights_contains_third_party_content)
+        value = if submission_information[:content_rights_contains_third_party_content]
+                  Spaceship::ConnectAPI::App::ContentRightsDeclaration::USES_THIRD_PARTY_CONTENT
+                else
+                  Spaceship::ConnectAPI::App::ContentRightsDeclaration::DOES_NOT_USE_THIRD_PARTY_CONTENT
+                end
+
+        UI.success("Updating contents rights declaration on App Store Connect")
+        app.update(attributes: {
+          contentRightsDeclaration: value
+        })
       end
+    end
 
-      build = candidate_builds.first
-      candidate_builds.each do |b|
-        if b.upload_date > build.upload_date
-          build = b
-        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
+      )
+
+      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
 
-      return build
+      return latest_build
     end
   end
 end

data/deliver/lib/deliver/upload_metadata.rb

@@ -2,40 +2,38 @@ require_relative 'module'
 
 module Deliver
   # upload description, rating, etc.
+  # rubocop:disable Metrics/ClassLength
   class UploadMetadata
     # All the localised values attached to the version
-    LOCALISED_VERSION_VALUES = [:description, :keywords, :release_notes, :support_url, :marketing_url, :promotional_text]
+    LOCALISED_VERSION_VALUES = {
+      description: "description",
+      keywords: "keywords",
+      release_notes: "whatsNew",
+      support_url: "supportUrl",
+      marketing_url: "marketingUrl",
+      promotional_text: "promotionalText"
+    }
 
     # Everything attached to the version but not being localised
-    NON_LOCALISED_VERSION_VALUES = [:copyright]
+    NON_LOCALISED_VERSION_VALUES = {
+      copyright: "copyright"
+    }
 
     # Localised app details values
-    LOCALISED_APP_VALUES = [:name, :subtitle, :privacy_url, :apple_tv_privacy_policy]
+    LOCALISED_APP_VALUES = {
+      name: "name",
+      subtitle: "subtitle",
+      privacy_url: "privacyPolicyUrl",
+      apple_tv_privacy_policy: "privacyPolicyText"
+    }
 
     # Non localized app details values
     NON_LOCALISED_APP_VALUES = [:primary_category, :secondary_category,
                                 :primary_first_sub_category, :primary_second_sub_category,
                                 :secondary_first_sub_category, :secondary_second_sub_category]
 
-    # Trade Representative Contact Information values
-    TRADE_REPRESENTATIVE_CONTACT_INFORMATION_VALUES = {
-        trade_representative_trade_name: :trade_name,
-        trade_representative_first_name: :first_name,
-        trade_representative_last_name: :last_name,
-        trade_representative_address_line_1: :address_line1,
-        trade_representative_address_line_2: :address_line2,
-        trade_representative_address_line_3: :address_line3,
-        trade_representative_city_name: :city_name,
-        trade_representative_state: :state,
-        trade_representative_country: :country,
-        trade_representative_postal_code: :postal_code,
-        trade_representative_phone_number: :phone_number,
-        trade_representative_email: :email_address,
-        trade_representative_is_displayed_on_app_store: :is_displayed_on_app_store
-    }
-
     # Review information values
-    REVIEW_INFORMATION_VALUES = {
+    REVIEW_INFORMATION_VALUES_LEGACY = {
       review_first_name: :first_name,
       review_last_name: :last_name,
       review_phone_number: :phone_number,
@@ -44,6 +42,15 @@ module Deliver
       review_demo_password: :demo_password,
       review_notes: :notes
     }
+    REVIEW_INFORMATION_VALUES = {
+      first_name: "contactFirstName",
+      last_name: "contactLastName",
+      phone_number: "contactPhone",
+      email_address: "contactEmail",
+      demo_user: "demoAccountName",
+      demo_password: "demoAccountPassword",
+      notes: "notes"
+    }
 
     # Localized app details values, that are editable in live state
     LOCALISED_LIVE_VALUES = [:description, :release_notes, :support_url, :marketing_url, :promotional_text, :privacy_url]
@@ -66,35 +73,46 @@ module Deliver
     # Make sure to call `load_from_filesystem` before calling upload
     def upload(options)
       return if options[:skip_metadata]
-      # it is not possible to create new languages, because
-      # :keywords is not write-able on published versions
-      # therefore skip it.
-      verify_available_languages!(options) unless options[:edit_live]
 
-      app = options[:app]
+      legacy_app = options[:app]
+      app_id = legacy_app.apple_id
+      app = Spaceship::ConnectAPI::App.get(app_id: app_id)
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+
+      app_store_version_localizations = verify_available_version_languages!(options, app) unless options[:edit_live]
+      app_info_localizations = verify_available_info_languages!(options, app) unless options[:edit_live]
 
-      details = app.details
       if options[:edit_live]
         # not all values are editable when using live_version
-        v = app.live_version(platform: options[:platform])
+        version = app.get_live_app_store_version(platform: platform)
         localised_options = LOCALISED_LIVE_VALUES
         non_localised_options = NON_LOCALISED_LIVE_VALUES
 
         if v.nil?
           UI.message("Couldn't find live version, editing the current version on App Store Connect instead")
-          v = app.edit_version(platform: options[:platform])
+          version = app.get_edit_app_store_version(platform: platform)
           # we don't want to update the localised_options and non_localised_options
           # as we also check for `options[:edit_live]` at other areas in the code
           # by not touching those 2 variables, deliver is more consistent with what the option says
           # in the documentation
+        else
+          UI.message("Found live version")
         end
       else
-        v = app.edit_version(platform: options[:platform])
-        localised_options = (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES)
-        non_localised_options = (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES)
+        version = app.get_edit_app_store_version(platform: platform)
+        localised_options = (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys)
+        non_localised_options = NON_LOCALISED_VERSION_VALUES.keys
       end
 
-      individual = options[:individual_metadata_items] || []
+      # Needed for to filter out release notes from being sent up
+      is_first_version = app.get_live_app_store_version(platform: platform).nil?
+
+      UI.important("Will begin uploading metadata for '#{version.version_string}' on App Store Connect")
+
+      localized_version_attributes_by_locale = {}
+      localized_info_attributes_by_locale = {}
+
       localised_options.each do |key|
         current = options[key]
         next unless current
@@ -104,70 +122,139 @@ module Deliver
           next
         end
 
+        if key == :release_notes && is_first_version
+          UI.error("Skipping 'release_notes'... this is the first version of the app")
+          next
+        end
+
         current.each do |language, value|
           next unless value.to_s.length > 0
           strip_value = value.to_s.strip
-          if individual.include?(key.to_s)
-            upload_individual_item(app, v, language, key, strip_value)
-          else
-            v.send(key)[language] = strip_value if LOCALISED_VERSION_VALUES.include?(key)
-            details.send(key)[language] = strip_value if LOCALISED_APP_VALUES.include?(key)
+
+          if LOCALISED_VERSION_VALUES.include?(key) && !strip_value.empty?
+            attribute_name = LOCALISED_VERSION_VALUES[key]
+
+            localized_version_attributes_by_locale[language] ||= {}
+            localized_version_attributes_by_locale[language][attribute_name] = strip_value
           end
+
+          next unless LOCALISED_APP_VALUES.include?(key) && !strip_value.empty?
+          attribute_name = LOCALISED_APP_VALUES[key]
+
+          localized_info_attributes_by_locale[language] ||= {}
+          localized_info_attributes_by_locale[language][attribute_name] = strip_value
         end
       end
 
+      non_localized_version_attributes = {}
       non_localised_options.each do |key|
-        current = options[key].to_s.strip
-        next unless current.to_s.length > 0
-        v.send("#{key}=", current) if NON_LOCALISED_VERSION_VALUES.include?(key)
-        details.send("#{key}=", current) if NON_LOCALISED_APP_VALUES.include?(key)
+        strip_value = options[key].to_s.strip
+        next unless strip_value.to_s.length > 0
+
+        if NON_LOCALISED_VERSION_VALUES.include?(key) && !strip_value.empty?
+          attribute_name = NON_LOCALISED_VERSION_VALUES[key]
+          non_localized_version_attributes[attribute_name] = strip_value
+        end
       end
 
-      v.release_on_approval = options[:automatic_release]
-      v.auto_release_date = options[:auto_release_date] unless options[:auto_release_date].nil?
-      v.toggle_phased_release(enabled: !!options[:phased_release]) unless options[:phased_release].nil?
+      release_type = if options[:auto_release_date]
+                       non_localized_version_attributes['earliestReleaseDate'] = options[:auto_release_date]
+                       Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::SCHEDULED
+                     elsif options[:automatic_release]
+                       Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::AFTER_APPROVAL
+                     else
+                       Spaceship::ConnectAPI::AppStoreVersion::ReleaseType::MANUAL
+                     end
+      non_localized_version_attributes['releaseType'] = release_type
+
+      # Update app store version localizations
+      app_store_version_localizations.each do |app_store_version_localization|
+        attributes = localized_version_attributes_by_locale[app_store_version_localization.locale]
+        if attributes
+          UI.message("Uploading metadata to App Store Connect for localized version '#{app_store_version_localization.locale}'")
+          app_store_version_localization.update(attributes: attributes)
+        end
+      end
 
-      set_trade_representative_contact_information(v, options)
-      set_review_information(v, options)
-      set_app_rating(v, options)
-      v.ratings_reset = options[:reset_ratings] unless options[:reset_ratings].nil?
+      # Update app info localizations
+      app_info_localizations.each do |app_info_localization|
+        attributes = localized_info_attributes_by_locale[app_info_localization.locale]
+        if attributes
+          UI.message("Uploading metadata to App Store Connect for localized info '#{app_info_localization.locale}'")
+          app_info_localization.update(attributes: attributes)
+        end
+      end
 
-      set_review_attachment_file(v, options)
+      # Update app store version
+      UI.message("Uploading metadata to App Store Connect for version")
+      version.update(attributes: non_localized_version_attributes)
+
+      # Update categories
+      app_info = app.fetch_edit_app_info
+      if app_info
+        app_info.update_categories(
+          primary_category_id: Spaceship::ConnectAPI::AppCategory.map_category_from_itc(
+            options[:primary_category].to_s.strip
+          ),
+          secondary_category_id: Spaceship::ConnectAPI::AppCategory.map_category_from_itc(
+            options[:secondary_category].to_s.strip
+          ),
+          primary_subcategory_one_id: Spaceship::ConnectAPI::AppCategory.map_subcategory_from_itc(
+            options[:primary_first_sub_category].to_s.strip
+          ),
+          primary_subcategory_two_id: Spaceship::ConnectAPI::AppCategory.map_subcategory_from_itc(
+            options[:primary_second_sub_category].to_s.strip
+          ),
+          secondary_subcategory_one_id: Spaceship::ConnectAPI::AppCategory.map_subcategory_from_itc(
+            options[:secondary_first_sub_category].to_s.strip
+          ),
+          secondary_subcategory_two_id: Spaceship::ConnectAPI::AppCategory.map_subcategory_from_itc(
+            options[:secondary_second_sub_category].to_s.strip
+          )
+        )
+      end
 
-      Helper.show_loading_indicator("Uploading metadata to App Store Connect")
-      v.save!
-      Helper.hide_loading_indicator
-      begin
-        details.save!
-        UI.success("Successfully uploaded set of metadata to App Store Connect")
-      rescue Spaceship::TunesClient::ITunesConnectError => e
-        # This makes sure that we log invalid app names as user errors
-        # If another string needs to be checked here we should
-        # figure out a more generic way to handle these cases.
-        if e.message.include?('App Name cannot be longer than 50 characters') || e.message.include?('The app name you entered is already being used')
-          UI.error("Error in app name.  Try using 'individual_metadata_items' to identify the problem language.")
-          UI.user_error!(e.message)
-        else
-          raise e
+      # Update phased release
+      unless options[:phased_release].nil?
+        phased_release = begin
+                           version.fetch_app_store_version_phased_release
+                         rescue
+                           nil
+                         end # returns no data error so need to rescue
+        if !!options[:phased_release]
+          unless phased_release
+            UI.message("Creating phased release on App Store Connect")
+            version.create_app_store_version_phased_release(attributes: {
+              phasedReleaseState: Spaceship::ConnectAPI::AppStoreVersionPhasedRelease::PhasedReleaseState::INACTIVE
+            })
+          end
+        elsif phased_release
+          UI.message("Removing phased release on App Store Connect")
+          phased_release.delete!
         end
       end
-    end
 
-    # Uploads metadata individually by language to help identify exactly which items have issues
-    def upload_individual_item(app, version, language, key, value)
-      details = app.details
-      version.send(key)[language] = value if LOCALISED_VERSION_VALUES.include?(key)
-      details.send(key)[language] = value if LOCALISED_APP_VALUES.include?(key)
-      Helper.show_loading_indicator("Uploading #{language} #{key} to App Store Connect")
-      version.save!
-      Helper.hide_loading_indicator
-      begin
-        details.save!
-        UI.success("Successfully uploaded #{language} #{key} to App Store Connect")
-      rescue Spaceship::TunesClient::ITunesConnectError => e
-        UI.error("Error in #{language} #{key}: \n#{value}")
-        UI.error(e.message) # Don't use user_error to allow all values to get checked
+      # Update rating reset
+      unless options[:reset_ratings].nil?
+        reset_rating_request = begin
+                                 version.fetch_reset_ratings_request
+                               rescue
+                                 nil
+                               end # returns no data error so need to rescue
+        if !!options[:reset_ratings]
+          unless reset_rating_request
+            UI.message("Creating reset ratings request on App Store Connect")
+            version.create_reset_ratings_request
+          end
+        elsif reset_rating_request
+          UI.message("Removing reset ratings request on App Store Connect")
+          reset_rating_request.delete!
+        end
       end
+
+      set_review_information(version, options)
+      set_review_attachment_file(version, options)
+      set_app_rating(version, options)
     end
 
     # rubocop:enable Metrics/PerceivedComplexity
@@ -181,7 +268,7 @@ module Deliver
       enabled_languages = detect_languages(options)
 
       # Get all languages used in existing settings
-      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+      (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys).each do |key|
         current = options[key]
         next unless current && current.kind_of?(Hash)
         current.each do |language, value|
@@ -200,7 +287,7 @@ module Deliver
       return unless enabled_languages.include?("default")
       UI.message("Detected languages: " + enabled_languages.to_s)
 
-      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+      (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys).each do |key|
         current = options[key]
         next unless current && current.kind_of?(Hash)
 
@@ -222,7 +309,7 @@ module Deliver
       enabled_languages = options[:languages] || []
 
       # Get all languages used in existing settings
-      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+      (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys).each do |key|
         current = options[key]
         next unless current && current.kind_of?(Hash)
         current.each do |language, value|
@@ -245,41 +332,73 @@ module Deliver
         .uniq
     end
 
-    # Makes sure all languages we need are actually created
-    def verify_available_languages!(options)
-      return if options[:skip_metadata]
+    # Finding languages to enable
+    def verify_available_info_languages!(options, app)
+      app_info = app.fetch_edit_app_info
 
-      # Collect all languages we need
-      # We only care about languages from user provided values
-      # as the other languages are on iTC already anyway
-      v = options[:app].edit_version(platform: options[:platform])
-      UI.user_error!("Could not find a version to edit for app '#{options[:app].name}', the app metadata is read-only currently") unless v
+      unless app_info
+        UI.user_error!("Cannot update languages - could not find an editable info")
+        return
+      end
 
-      enabled_languages = options[:languages] || []
-      LOCALISED_VERSION_VALUES.each do |key|
-        current = options[key]
-        next unless current && current.kind_of?(Hash)
-        current.each do |language, value|
-          language = language.to_s
-          enabled_languages << language unless enabled_languages.include?(language)
+      localizations = app_info.get_app_info_localizations
+
+      languages = options[:languages] || []
+      locales_to_enable = languages - localizations.map(&:locale)
+
+      if locales_to_enable.count > 0
+        lng_text = "language"
+        lng_text += "s" if locales_to_enable.count != 1
+        Helper.show_loading_indicator("Activating info #{lng_text} #{locales_to_enable.join(', ')}...")
+
+        locales_to_enable.each do |locale|
+          app_info.create_app_info_localization(attributes: {
+            locale: locale
+          })
         end
+
+        Helper.hide_loading_indicator
+
+        # Refresh version localizations
+        localizations = app_info.get_app_info_localizations
       end
 
-      # Reject "default" language from getting enabled
-      # because "default" is not an iTC language
-      enabled_languages = enabled_languages.reject do |lang|
-        lang == "default"
-      end.uniq
+      return localizations
+    end
 
-      if enabled_languages.count > 0
-        v.create_languages(enabled_languages)
+    # Finding languages to enable
+    def verify_available_version_languages!(options, app)
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      version = app.get_edit_app_store_version(platform: platform)
+
+      unless version
+        UI.user_error!("Cannot update languages - could not find an editable version for '#{platform}'")
+        return
+      end
+
+      localizations = version.get_app_store_version_localizations
+
+      languages = options[:languages] || []
+      locales_to_enable = languages - localizations.map(&:locale)
+
+      if locales_to_enable.count > 0
         lng_text = "language"
-        lng_text += "s" if enabled_languages.count != 1
-        Helper.show_loading_indicator("Activating #{lng_text} #{enabled_languages.join(', ')}...")
-        v.save!
+        lng_text += "s" if locales_to_enable.count != 1
+        Helper.show_loading_indicator("Activating version #{lng_text} #{locales_to_enable.join(', ')}...")
+
+        locales_to_enable.each do |locale|
+          version.create_app_store_version_localization(attributes: {
+            locale: locale
+          })
+        end
+
         Helper.hide_loading_indicator
+
+        # Refresh version localizations
+        localizations = version.get_app_store_version_localizations
       end
-      true
+
+      return localizations
     end
 
     # Loads the metadata files and stores them into the options object
@@ -290,7 +409,7 @@ module Deliver
       ignore_validation = options[:ignore_language_directory_validation]
       Loader.language_folders(options[:metadata_path], ignore_validation).each do |lang_folder|
         language = File.basename(lang_folder)
-        (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+        (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys).each do |key|
           path = File.join(lang_folder, "#{key}.txt")
           next unless File.exist?(path)
 
@@ -301,7 +420,7 @@ module Deliver
       end
 
       # Load non localised data
-      (NON_LOCALISED_VERSION_VALUES + NON_LOCALISED_APP_VALUES).each do |key|
+      (NON_LOCALISED_VERSION_VALUES.keys + NON_LOCALISED_APP_VALUES).each do |key|
         path = File.join(options[:metadata_path], "#{key}.txt")
         next unless File.exist?(path)
 
@@ -309,20 +428,9 @@ module Deliver
         options[key] ||= File.read(path)
       end
 
-      # Load trade representative contact information
-      options[:trade_representative_contact_information] ||= {}
-      TRADE_REPRESENTATIVE_CONTACT_INFORMATION_VALUES.values.each do |option_name|
-        path = File.join(options[:metadata_path], TRADE_REPRESENTATIVE_CONTACT_INFORMATION_DIR, "#{option_name}.txt")
-        next unless File.exist?(path)
-        next if options[:trade_representative_contact_information][option_name].to_s.length > 0
-
-        UI.message("Loading '#{path}'...")
-        options[:trade_representative_contact_information][option_name] ||= File.read(path)
-      end
-
       # Load review information
       options[:app_review_information] ||= {}
-      REVIEW_INFORMATION_VALUES.values.each do |option_name|
+      REVIEW_INFORMATION_VALUES.keys.each do |option_name|
         path = File.join(options[:metadata_path], REVIEW_INFORMATION_DIR, "#{option_name}.txt")
         next unless File.exist?(path)
         next if options[:app_review_information][option_name].to_s.length > 0
@@ -336,7 +444,7 @@ module Deliver
 
     # Normalizes languages keys from symbols to strings
     def normalize_language_keys(options)
-      (LOCALISED_VERSION_VALUES + LOCALISED_APP_VALUES).each do |key|
+      (LOCALISED_VERSION_VALUES.keys + LOCALISED_APP_VALUES.keys).each do |key|
         current = options[key]
         next unless current && current.kind_of?(Hash)
 
@@ -348,33 +456,55 @@ module Deliver
       options
     end
 
-    def set_trade_representative_contact_information(v, options)
-      return unless options[:trade_representative_contact_information]
-      info = options[:trade_representative_contact_information]
-      UI.user_error!("`trade_representative_contact_information` must be a hash", show_github_issues: true) unless info.kind_of?(Hash)
-
-      TRADE_REPRESENTATIVE_CONTACT_INFORMATION_VALUES.each do |key, option_name|
-        v.send("#{key}=", info[option_name].to_s.chomp) if info[option_name]
-      end
-    end
-
-    def set_review_information(v, options)
+    def set_review_information(version, options)
       return unless options[:app_review_information]
       info = options[:app_review_information]
       UI.user_error!("`app_review_information` must be a hash", show_github_issues: true) unless info.kind_of?(Hash)
 
-      REVIEW_INFORMATION_VALUES.each do |key, option_name|
-        v.send("#{key}=", info[option_name].to_s.chomp) if info[option_name]
+      attributes = {}
+      REVIEW_INFORMATION_VALUES.each do |key, attribute_name|
+        strip_value = info[key].to_s.strip
+        attributes[attribute_name] = strip_value unless strip_value.empty?
+      end
+
+      if !attributes["demoAccountName"].to_s.empty? && !attributes["demoAccountPassword"].to_s.empty?
+        attributes["demoAccountRequired"] = true
+      else
+        attributes["demoAccountRequired"] = false
+      end
+
+      UI.message("Uploading app review information to App Store Connect")
+      app_store_review_detail = begin
+                                  version.fetch_app_store_review_detail
+                                rescue
+                                  nil
+                                end # errors if doesn't exist
+      if app_store_review_detail
+        app_store_review_detail.update(attributes: attributes)
+      else
+        version.create_app_store_review_detail(attributes: attributes)
       end
-      v.review_user_needed = (v.review_demo_user.to_s.chomp + v.review_demo_password.to_s.chomp).length > 0
     end
 
-    def set_review_attachment_file(v, options)
-      return unless options[:app_review_attachment_file]
-      v.upload_review_attachment!(options[:app_review_attachment_file])
+    def set_review_attachment_file(version, options)
+      app_store_review_detail = version.fetch_app_store_review_detail
+      app_review_attachments = app_store_review_detail.fetch_app_review_attachments
+
+      if options[:app_review_attachment_file]
+        app_review_attachments.each do |app_review_attachment|
+          UI.message("Removing previous review attachment file from App Store Connect")
+          app_review_attachment.delete!
+        end
+
+        UI.message("Uploading review attachment file to App Store Connect")
+        app_store_review_detail.upload_attachment(path: options[:app_review_attachment_file])
+      else
+        app_review_attachments.each(&:delete!)
+        UI.message("Removing review attachment file to App Store Connect") unless app_review_attachments.empty?
+      end
     end
 
-    def set_app_rating(v, options)
+    def set_app_rating(version, options)
       return unless options[:app_rating_config_path]
 
       require 'json'
@@ -385,7 +515,18 @@ module Deliver
         UI.user_error!("Error parsing JSON file at path '#{options[:app_rating_config_path]}'")
       end
       UI.message("Setting the app's age rating...")
-      v.update_rating(json)
+
+      # Maping from legacy ITC values to App Store Connect Values
+      attributes = {}
+      json.each do |k, v|
+        new_key = Spaceship::ConnectAPI::AgeRatingDeclaration.map_key_from_itc(k)
+        new_value = Spaceship::ConnectAPI::AgeRatingDeclaration.map_value_from_itc(new_key, v)
+        attributes[new_key] = new_value
+      end
+
+      age_rating_delcaration = version.fetch_age_rating_declaration
+      age_rating_delcaration.update(attributes: attributes)
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end