fastlane-mercafacil 2.214.0

data/deliver/lib/deliver/runner.rb

@@ -0,0 +1,310 @@
+require 'precheck/options'
+require 'precheck/runner'
+require 'fastlane_core/configuration/configuration'
+require 'fastlane_core/ipa_upload_package_builder'
+require 'fastlane_core/pkg_upload_package_builder'
+require 'fastlane_core/itunes_transporter'
+require 'spaceship'
+require_relative 'html_generator'
+require_relative 'submit_for_review'
+require_relative 'upload_price_tier'
+require_relative 'upload_metadata'
+require_relative 'upload_screenshots'
+require_relative 'sync_screenshots'
+require_relative 'detect_values'
+
+module Deliver
+  class Runner
+    attr_accessor :options
+
+    def initialize(options, skip_auto_detection = {})
+      self.options = options
+
+      login
+
+      Deliver::DetectValues.new.run!(self.options, skip_auto_detection)
+      FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:app], mask_keys: ['app_review_information.demo_password'], title: "deliver #{Fastlane::VERSION} Summary")
+    end
+
+    def login
+      if (api_token = Spaceship::ConnectAPI::Token.from(hash: options[:api_key], filepath: options[:api_key_path]))
+        UI.message("Creating authorization token for App Store Connect API")
+        Spaceship::ConnectAPI.token = api_token
+      elsif !Spaceship::ConnectAPI.token.nil?
+        UI.message("Using existing authorization token for App Store Connect API")
+      else
+        # Username is now optional since addition of App Store Connect API Key
+        # Force asking for username to prompt user if not already set
+        options.fetch(:username, force_ask: true)
+
+        # Team selection passed though FASTLANE_TEAM_ID and FASTLANE_TEAM_NAME environment variables
+        # Prompts select team if multiple teams and none specified
+        UI.message("Login to App Store Connect (#{options[:username]})")
+        Spaceship::ConnectAPI.login(options[:username], nil, use_portal: false, use_tunes: true)
+        UI.message("Login successful")
+      end
+    end
+
+    def run
+      if options[:verify_only]
+        UI.important("Verify flag is set, only package validation will take place and no submission will be made")
+        verify_binary
+        return
+      end
+
+      verify_version if options[:app_version].to_s.length > 0 && !options[:skip_app_version_update]
+
+      # Rejecting before upload meta
+      # Screenshots can not be update/deleted if in waiting for review
+      reject_version_if_possible if options[:reject_if_possible]
+
+      upload_metadata
+
+      has_binary = (options[:ipa] || options[:pkg])
+      if !options[:skip_binary_upload] && !options[:build_number] && has_binary
+        upload_binary
+      end
+
+      UI.success("Finished the upload to App Store Connect") unless options[:skip_binary_upload]
+
+      precheck_success = precheck_app
+      submit_for_review if options[:submit_for_review] && precheck_success
+    end
+
+    # Make sure we pass precheck before uploading
+    def precheck_app
+      return true unless options[:run_precheck_before_submit]
+      UI.message("Running precheck before submitting to review, if you'd like to disable this check you can set run_precheck_before_submit to false")
+
+      if options[:submit_for_review]
+        UI.message("Making sure we pass precheck 👮‍♀️ 👮 before we submit  🛫")
+      else
+        UI.message("Running precheck 👮‍♀️ 👮")
+      end
+
+      precheck_options = {
+        default_rule_level: options[:precheck_default_rule_level],
+        include_in_app_purchases: options[:precheck_include_in_app_purchases],
+        app_identifier: options[:app_identifier]
+      }
+
+      if options[:api_key] || options[:api_key_path]
+        if options[:precheck_include_in_app_purchases]
+          UI.user_error!("Precheck cannot check In-app purchases with the App Store Connect API Key (yet). Exclude In-app purchases from precheck, disable the precheck step in your build step, or use Apple ID login")
+        end
+
+        precheck_options[:api_key] = options[:api_key]
+        precheck_options[:api_key_path] = options[:api_key_path]
+      else
+        precheck_options[:username] = options[:username]
+        precheck_options[:platform] = options[:platform]
+      end
+
+      precheck_config = FastlaneCore::Configuration.create(Precheck::Options.available_options, precheck_options)
+      Precheck.config = precheck_config
+
+      precheck_success = true
+      begin
+        precheck_success = Precheck::Runner.new.run
+      rescue => ex
+        UI.error("fastlane precheck just tried to inspect your app's metadata for App Store guideline violations and ran into a problem. We're not sure what the problem was, but precheck failed to finished. You can run it in verbose mode if you want to see the whole error. We'll have a fix out soon 🚀")
+        UI.verbose(ex.inspect)
+        UI.verbose(ex.backtrace.join("\n"))
+      end
+
+      return precheck_success
+    end
+
+    # Make sure the version on App Store Connect matches the one in the ipa
+    # If not, the new version will automatically be created
+    def verify_version
+      app_version = options[:app_version]
+      UI.message("Making sure the latest version on App Store Connect matches '#{app_version}'...")
+
+      app = Deliver.cache[:app]
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      changed = app.ensure_version!(app_version, platform: platform)
+
+      if changed
+        UI.success("Successfully set the version to '#{app_version}'")
+      else
+        UI.success("'#{app_version}' is the latest version on App Store Connect")
+      end
+    end
+
+    # Upload all metadata, screenshots, pricing information, etc. to App Store Connect
+    def upload_metadata
+      upload_metadata = UploadMetadata.new
+      upload_screenshots = UploadScreenshots.new
+
+      # First, collect all the things for the HTML Report
+      screenshots = upload_screenshots.collect_screenshots(options)
+      upload_metadata.load_from_filesystem(options)
+
+      # Assign "default" values to all languages
+      upload_metadata.assign_defaults(options)
+
+      # Validate
+      validate_html(screenshots)
+
+      # Commit
+      upload_metadata.upload(options)
+
+      if options[:sync_screenshots]
+        sync_screenshots = SyncScreenshots.new(app: Deliver.cache[:app], platform: Spaceship::ConnectAPI::Platform.map(options[:platform]))
+        sync_screenshots.sync(screenshots)
+      else
+        upload_screenshots.upload(options, screenshots)
+      end
+
+      UploadPriceTier.new.upload(options)
+    end
+
+    # Verify the binary with App Store Connect
+    def verify_binary
+      UI.message("Verifying binary with App Store Connect")
+
+      ipa_path = options[:ipa]
+      pkg_path = options[:pkg]
+
+      platform = options[:platform]
+      transporter = transporter_for_selected_team
+
+      case platform
+      when "ios", "appletvos"
+        package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(
+          app_id: Deliver.cache[:app].id,
+          ipa_path: ipa_path,
+          package_path: "/tmp",
+          platform: platform
+        )
+        result = transporter.verify(package_path: package_path, asset_path: ipa_path, platform: platform)
+      when "osx"
+        package_path = FastlaneCore::PkgUploadPackageBuilder.new.generate(
+          app_id: Deliver.cache[:app].id,
+          pkg_path: pkg_path,
+          package_path: "/tmp",
+          platform: platform
+        )
+        result = transporter.verify(package_path: package_path, asset_path: pkg_path, platform: platform)
+      else
+        UI.user_error!("No suitable file found for verify for platform: #{options[:platform]}")
+      end
+
+      unless result
+        transporter_errors = transporter.displayable_errors
+        UI.user_error!("Error verifying the binary file: \n #{transporter_errors}")
+      end
+    end
+
+    # Upload the binary to App Store Connect
+    def upload_binary
+      UI.message("Uploading binary to App Store Connect")
+
+      ipa_path = options[:ipa]
+      pkg_path = options[:pkg]
+
+      platform = options[:platform]
+      transporter = transporter_for_selected_team
+
+      case platform
+      when "ios", "appletvos"
+        package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(
+          app_id: Deliver.cache[:app].id,
+          ipa_path: ipa_path,
+          package_path: "/tmp",
+          platform: platform
+        )
+        result = transporter.upload(package_path: package_path, asset_path: ipa_path, platform: platform)
+      when "osx"
+        package_path = FastlaneCore::PkgUploadPackageBuilder.new.generate(
+          app_id: Deliver.cache[:app].id,
+          pkg_path: pkg_path,
+          package_path: "/tmp",
+          platform: platform
+        )
+        result = transporter.upload(package_path: package_path, asset_path: pkg_path, platform: platform)
+      else
+        UI.user_error!("No suitable file found for upload for platform: #{options[:platform]}")
+      end
+
+      unless result
+        transporter_errors = transporter.displayable_errors
+        UI.user_error!("Error uploading ipa file: \n #{transporter_errors}")
+      end
+    end
+
+    def reject_version_if_possible
+      app = Deliver.cache[:app]
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+
+      submission = app.get_in_progress_review_submission(platform: platform)
+      if submission
+        submission.cancel_submission
+        UI.message("Review submission cancellation has been requested")
+
+        # An app version won't get removed from review instantly
+        # Polling until there is no longer an in-progress version
+        loop do
+          break if app.get_in_progress_review_submission(platform: platform).nil?
+          UI.message("Waiting for cancellation to take effect...")
+          sleep(15)
+        end
+
+        UI.success("Successfully cancelled previous submission!")
+      end
+    end
+
+    def submit_for_review
+      SubmitForReview.new.submit!(options)
+    end
+
+    private
+
+    # If App Store Connect API token, use token.
+    # If itc_provider was explicitly specified, use it.
+    # If there are multiple teams, infer the provider from the selected team name.
+    # If there are fewer than two teams, don't infer the provider.
+    def transporter_for_selected_team
+      # Use JWT auth
+      api_token = Spaceship::ConnectAPI.token
+      api_key = if options[:api_key].nil? && !api_token.nil?
+                  # Load api key info if user set api_key_path, not api_key
+                  { key_id: api_token.key_id, issuer_id: api_token.issuer_id, key: api_token.key_raw }
+                elsif !options[:api_key].nil?
+                  api_key = options[:api_key].transform_keys(&:to_sym).dup
+                  # key is still base 64 style if api_key is loaded from option
+                  api_key[:key] = Base64.decode64(api_key[:key]) if api_key[:is_key_content_base64]
+                  api_key
+                end
+
+      unless api_token.nil?
+        api_token.refresh! if api_token.expired?
+        return FastlaneCore::ItunesTransporter.new(nil, nil, false, nil, api_token.text, altool_compatible_command: true, api_key: api_key)
+      end
+
+      tunes_client = Spaceship::ConnectAPI.client.tunes_client
+
+      generic_transporter = FastlaneCore::ItunesTransporter.new(options[:username], nil, false, options[:itc_provider], altool_compatible_command: true, api_key: api_key)
+      return generic_transporter unless options[:itc_provider].nil? && tunes_client.teams.count > 1
+
+      begin
+        team = tunes_client.teams.find { |t| t['providerId'].to_s == tunes_client.team_id }
+        name = team['name']
+        provider_id = generic_transporter.provider_ids[name]
+        UI.verbose("Inferred provider id #{provider_id} for team #{name}.")
+        return FastlaneCore::ItunesTransporter.new(options[:username], nil, false, provider_id, altool_compatible_command: true, api_key: api_key)
+      rescue => ex
+        UI.verbose("Couldn't infer a provider short name for team with id #{tunes_client.team_id} automatically: #{ex}. Proceeding without provider short name.")
+        return generic_transporter
+      end
+    end
+
+    def validate_html(screenshots)
+      return if options[:force]
+      return if options[:skip_metadata] && options[:skip_screenshots]
+      HtmlGenerator.new.run(options, screenshots)
+    end
+  end
+end

data/deliver/lib/deliver/screenshot_comparable.rb

@@ -0,0 +1,62 @@
+require 'spaceship/connect_api/models/app_screenshot'
+require 'spaceship/connect_api/models/app_screenshot_set'
+
+require_relative 'app_screenshot'
+
+module Deliver
+  # This clsas enables you to compare equality between different representations of the screenshots
+  # in the standard API `Array#-` that requires objects to implements `eql?` and `hash`.
+  class ScreenshotComparable
+    # A unique key value that is consist of locale, filename, and checksum.
+    attr_reader :key
+
+    # A hash object that contains the source data of this representation class
+    attr_reader :context
+
+    def self.create_from_local(screenshot:, app_screenshot_set:)
+      raise ArgumentError unless screenshot.kind_of?(Deliver::AppScreenshot)
+      raise ArgumentError unless app_screenshot_set.kind_of?(Spaceship::ConnectAPI::AppScreenshotSet)
+
+      new(
+        path: "#{screenshot.language}/#{File.basename(screenshot.path)}",
+        checksum: calculate_checksum(screenshot.path),
+        context: {
+          screenshot: screenshot,
+          app_screenshot_set: app_screenshot_set
+        }
+      )
+    end
+
+    def self.create_from_remote(app_screenshot:, locale:)
+      raise ArgumentError unless app_screenshot.kind_of?(Spaceship::ConnectAPI::AppScreenshot)
+      raise ArgumentError unless locale.kind_of?(String)
+
+      new(
+        path: "#{locale}/#{app_screenshot.file_name}",
+        checksum: app_screenshot.source_file_checksum,
+        context: {
+          app_screenshot: app_screenshot,
+          locale: locale
+        }
+      )
+    end
+
+    def self.calculate_checksum(path)
+      bytes = File.binread(path)
+      Digest::MD5.hexdigest(bytes)
+    end
+
+    def initialize(path:, checksum:, context:)
+      @key = "#{path}/#{checksum}"
+      @context = context
+    end
+
+    def eql?(other)
+      key == other.key
+    end
+
+    def hash
+      key.hash
+    end
+  end
+end

data/deliver/lib/deliver/setup.rb

@@ -0,0 +1,203 @@
+require 'spaceship/tunes/tunes'
+
+require_relative 'module'
+require_relative 'download_screenshots'
+require_relative 'upload_metadata'
+
+module Deliver
+  class Setup
+    attr_accessor :is_swift
+
+    def run(options, is_swift: false)
+      containing = Helper.fastlane_enabled_folder_path
+      self.is_swift = is_swift
+
+      if is_swift
+        file_path = File.join(containing, 'Deliverfile.swift')
+      else
+        file_path = File.join(containing, 'Deliverfile')
+      end
+      data = generate_deliver_file(containing, options)
+      setup_deliver(file_path, data, containing, options)
+    end
+
+    def setup_deliver(file_path, data, deliver_path, options)
+      File.write(file_path, data)
+
+      screenshots_path = options[:screenshots_path] || File.join(deliver_path, 'screenshots')
+      unless options[:skip_screenshots]
+        download_screenshots(screenshots_path, options)
+
+        # Add a README to the screenshots folder
+        FileUtils.mkdir_p(screenshots_path) # just in case the fetching didn't work
+        File.write(File.join(screenshots_path, 'README.txt'), File.read("#{Deliver::ROOT}/lib/assets/ScreenshotsHelp"))
+      end
+
+      UI.success("Successfully created new Deliverfile at path '#{file_path}'")
+    end
+
+    # This method takes care of creating a new 'deliver' folder, containing the app metadata
+    # and screenshots folders
+    def generate_deliver_file(deliver_path, options)
+      app = Deliver.cache[:app]
+
+      platform = Spaceship::ConnectAPI::Platform.map(options[:platform])
+      v = app.get_latest_app_store_version(platform: platform)
+
+      metadata_path = options[:metadata_path] || File.join(deliver_path, 'metadata')
+      generate_metadata_files(app, v, metadata_path, options)
+
+      # Generate the final Deliverfile here
+      return File.read(deliverfile_path)
+    end
+
+    def deliverfile_path
+      if self.is_swift
+        return "#{Deliver::ROOT}/lib/assets/DeliverfileDefault.swift"
+      else
+        return "#{Deliver::ROOT}/lib/assets/DeliverfileDefault"
+      end
+    end
+
+    def generate_metadata_files(app, version, path, options)
+      # App info localizations
+      if options[:use_live_version]
+        app_info = app.fetch_live_app_info
+        UI.user_error!("The option `use_live_version` was set to `true`, however no live app was found on App Store Connect.") unless app_info
+      else
+        app_info = app.fetch_edit_app_info || app.fetch_live_app_info
+      end
+      app_info_localizations = app_info.get_app_info_localizations
+      app_info_localizations.each do |localization|
+        language = localization.locale
+
+        UploadMetadata::LOCALISED_APP_VALUES.each do |file_key, attribute_name|
+          content = localization.send(attribute_name.to_slug) || ""
+          content += "\n"
+
+          resulting_path = File.join(path, language, "#{file_key}.txt")
+          FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+          File.write(resulting_path, content)
+
+          UI.message("Writing to '#{resulting_path}'")
+        end
+      end
+
+      # Version localizations
+      version_localizations = version.get_app_store_version_localizations
+      version_localizations.each do |localization|
+        language = localization.locale
+
+        UploadMetadata::LOCALISED_VERSION_VALUES.each do |file_key, attribute_name|
+          content = localization.send(attribute_name) || ""
+          content += "\n"
+
+          resulting_path = File.join(path, language, "#{file_key}.txt")
+          FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+          File.write(resulting_path, content)
+
+          UI.message("Writing to '#{resulting_path}'")
+        end
+      end
+
+      # App info (categories)
+      UploadMetadata::NON_LOCALISED_APP_VALUES.each do |file_key, attribute_name|
+        category = app_info.send(attribute_name)
+
+        content = category ? category.id.to_s : ""
+        content += "\n"
+
+        resulting_path = File.join(path, "#{file_key}.txt")
+        FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+        File.write(resulting_path, content)
+
+        UI.message("Writing to '#{resulting_path}'")
+      end
+
+      # Version
+      UploadMetadata::NON_LOCALISED_VERSION_VALUES.each do |file_key, attribute_name|
+        content = version.send(attribute_name) || ""
+        content += "\n"
+
+        resulting_path = File.join(path, "#{file_key}.txt")
+        FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+        File.write(resulting_path, content)
+
+        UI.message("Writing to '#{resulting_path}'")
+      end
+
+      # Review information
+      app_store_review_detail = begin
+                                  version.fetch_app_store_review_detail
+                                rescue
+                                  nil
+                                end # errors if doesn't exist
+      UploadMetadata::REVIEW_INFORMATION_VALUES.each do |file_key, attribute_name|
+        if app_store_review_detail
+          content = app_store_review_detail.send(attribute_name) || ""
+        else
+          content = ""
+        end
+        content += "\n"
+
+        base_dir = File.join(path, UploadMetadata::REVIEW_INFORMATION_DIR)
+        resulting_path = File.join(base_dir, "#{file_key}.txt")
+        FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+        File.write(resulting_path, content)
+
+        UI.message("Writing to '#{resulting_path}'")
+      end
+    end
+
+    def generate_metadata_files_old(v, path)
+      app_details = v.application.details
+
+      # All the localised metadata
+      (UploadMetadata::LOCALISED_VERSION_VALUES.keys + UploadMetadata::LOCALISED_APP_VALUES.keys).each do |key|
+        v.description.languages.each do |language|
+          if UploadMetadata::LOCALISED_VERSION_VALUES.keys.include?(key)
+            content = v.send(key)[language].to_s
+          else
+            content = app_details.send(key)[language].to_s
+          end
+          content += "\n"
+          resulting_path = File.join(path, language, "#{key}.txt")
+          FileUtils.mkdir_p(File.expand_path('..', resulting_path))
+          File.write(resulting_path, content)
+          UI.message("Writing to '#{resulting_path}'")
+        end
+      end
+
+      # All non-localised metadata
+      (UploadMetadata::NON_LOCALISED_VERSION_VALUES.keys + UploadMetadata::NON_LOCALISED_APP_VALUES).each do |key|
+        if UploadMetadata::NON_LOCALISED_VERSION_VALUES.keys.include?(key)
+          content = v.send(key).to_s
+        else
+          content = app_details.send(key).to_s
+        end
+        content += "\n"
+        resulting_path = File.join(path, "#{key}.txt")
+        File.write(resulting_path, content)
+        UI.message("Writing to '#{resulting_path}'")
+      end
+
+      # Review information
+      UploadMetadata::REVIEW_INFORMATION_VALUES_LEGACY.each do |key, option_name|
+        content = v.send(key).to_s
+        content += "\n"
+        base_dir = File.join(path, UploadMetadata::REVIEW_INFORMATION_DIR)
+        FileUtils.mkdir_p(base_dir)
+        resulting_path = File.join(base_dir, "#{option_name}.txt")
+        File.write(resulting_path, content)
+        UI.message("Writing to '#{resulting_path}'")
+      end
+
+      UI.success("Successfully created new configuration files.")
+    end
+
+    def download_screenshots(path, options)
+      FileUtils.mkdir_p(path)
+      Deliver::DownloadScreenshots.run(options, path)
+    end
+  end
+end