fastlane 2.150.0.rc1 → 2.150.0.rc2

data/fastlane/lib/fastlane/actions/set_changelog.rb

@@ -9,16 +9,18 @@ module Fastlane
         Spaceship::Tunes.select_team
         UI.message("Login successful")
 
-        app = Spaceship::Application.find(params[:app_identifier]) || Spaceship::Application.find(params[:app_identifier], mac: true)
+        app = Spaceship::ConnectAPI::App.find(params[:app_identifier])
         UI.user_error!("Couldn't find app with identifier #{params[:app_identifier]}") if app.nil?
 
         version_number = params[:version]
-        platform = params[:platform]
+        platform = Spaceship::ConnectAPI::Platform.map(params[:platform])
+
         unless version_number
           # Automatically fetch the latest version
           UI.message("Fetching the latest version for this app")
-          if app.edit_version(platform: platform) && app.edit_version(platform: platform).version
-            version_number = app.edit_version(platform: platform).version
+          edit_version = app.get_edit_app_store_version(platform: platform)
+          if edit_version
+            version_number = edit_version.version_string
           else
             UI.message("You have to specify a new version number: ")
             version_number = STDIN.gets.strip
@@ -42,31 +44,32 @@ module Fastlane
 
         UI.important("Going to update the changelog to:\n\n#{changelog}\n\n")
 
-        if (v = app.edit_version(platform: platform))
-          if v.version != version_number
+        edit_version = app.get_edit_app_store_version(platform: platform)
+        if edit_version
+          if edit_version.version_string != version_number
             # Version is already there, make sure it matches the one we want to create
-            UI.message("Changing existing version number from '#{v.version}' to '#{version_number}'")
-            v.version = version_number
-            v.save!
+            UI.message("Changing existing version number from '#{edit_version.version_string}' to '#{version_number}'")
+            edit_version = edit_version.update(attributes: {
+              versionString: version_number
+            })
           else
-            UI.message("Updating changelog for existing version #{v.version}")
+            UI.message("Updating changelog for existing version #{edit_version.version_string}")
           end
         else
           UI.message("Creating the new version: #{version_number}")
-          app.create_version!(version_number)
-          app = Spaceship::Application.find(params[:app_identifier]) # Replace with .reload method once available
-          v = app.edit_version(platform: platform)
+          attributes = { versionString: version_number, platform: platform }
+          edit_version = Spaceship::ConnectAPI.post_app_store_version(app_id: app.id, attributes: attributes).first
         end
 
-        v.release_notes.languages.each do |lang|
-          v.release_notes[lang] = changelog
+        localizations = edit_version.get_app_store_version_localizations
+        localizations.each do |localization|
+          UI.message("Updating changelog for the '#{localization.locale}'")
+          localization.update(attributes: {
+            whatsNew: changelog
+          })
         end
 
-        UI.message("Found and updated changelog for the following languages: #{v.release_notes.languages.join(', ')}")
-        UI.message("Uploading changes to App Store Connect...")
-        v.save!
-
-        UI.success("👼  Successfully pushed the new changelog to #{v.url}")
+        UI.success("👼  Successfully pushed the new changelog to for #{edit_version.version_string}")
       end
 
       def self.default_changelog_path

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.150.0.rc1'.freeze
+  VERSION = '2.150.0.rc2'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
   RUBOCOP_REQUIREMENT = '0.49.1'.freeze

data/produce/lib/produce/itunes_connect.rb

@@ -85,13 +85,24 @@ module Produce
     end
 
     # Makes sure to get the value for the language
-    # Instead of using the user's value `UK English` spaceship should send
-    # `English_UK` to the server
+    # Instead of using the user's value `UK English` spaceship should send `en-UK`
     def language
       @language = Produce.config[:language]
 
       unless FastlaneCore::Languages::ALL_LANGUAGES.include?(@language)
-        UI.user_error!("Please enter one of available languages: #{FastlaneCore::Languages::ALL_LANGUAGES}")
+        mapped_language = Spaceship::Tunes::LanguageConverter.from_standard_to_itc_locale(@language)
+        if mapped_language.to_s.empty?
+          message = [
+            "Sending language name is deprecated. Could not map '#{@language}' to a locale.",
+            "Please enter one of available languages: #{FastlaneCore::Languages::ALL_LANGUAGES}"
+          ].join("\n")
+          UI.user_error!(message)
+        end
+
+        UI.deprecated("Sending language name is deprecated. '#{@language}' has been mapped to '#{mapped_language}'.")
+        UI.deprecated("Please enter one of available languages: #{FastlaneCore::Languages::ALL_LANGUAGES}")
+
+        @language = mapped_language
       end
 
       return @language

data/spaceship/lib/spaceship/client.rb

@@ -194,15 +194,16 @@ module Spaceship
       self.new(cookie: another_client.instance_variable_get(:@cookie), current_team_id: another_client.team_id)
     end
 
-    def initialize(cookie: nil, current_team_id: nil)
+    def initialize(cookie: nil, current_team_id: nil, timeout: nil)
       options = {
        request: {
-          timeout:       (ENV["SPACESHIP_TIMEOUT"] || 300).to_i,
-          open_timeout:  (ENV["SPACESHIP_TIMEOUT"] || 300).to_i
+          timeout:       (ENV["SPACESHIP_TIMEOUT"] || timeout || 300).to_i,
+          open_timeout:  (ENV["SPACESHIP_TIMEOUT"] || timeout || 300).to_i
         }
       }
       @current_team_id = current_team_id
       @cookie = cookie || HTTP::CookieJar.new
+
       @client = Faraday.new(self.class.hostname, options) do |c|
         c.response(:json, content_type: /\bjson$/)
         c.response(:xml, content_type: /\bxml$/)

data/spaceship/lib/spaceship/connect_api.rb

@@ -1,6 +1,7 @@
 require 'spaceship/connect_api/model'
 require 'spaceship/connect_api/response'
 require 'spaceship/connect_api/token'
+require 'spaceship/connect_api/file_uploader'
 
 require 'spaceship/connect_api/provisioning/provisioning'
 require 'spaceship/connect_api/testflight/testflight'
@@ -35,6 +36,8 @@ require 'spaceship/connect_api/models/age_rating_declaration'
 require 'spaceship/connect_api/models/app_category'
 require 'spaceship/connect_api/models/app_info'
 require 'spaceship/connect_api/models/app_info_localization'
+require 'spaceship/connect_api/models/app_preview_set'
+require 'spaceship/connect_api/models/app_preview'
 require 'spaceship/connect_api/models/app_price'
 require 'spaceship/connect_api/models/app_price_tier'
 require 'spaceship/connect_api/models/app_review_attachment'
@@ -47,6 +50,7 @@ require 'spaceship/connect_api/models/app_store_version_phased_release'
 require 'spaceship/connect_api/models/app_store_version'
 require 'spaceship/connect_api/models/idfa_declaration'
 require 'spaceship/connect_api/models/reset_ratings_request'
+require 'spaceship/connect_api/models/territory'
 
 module Spaceship
   class ConnectAPI
@@ -84,7 +88,7 @@ module Spaceship
         case platform.to_sym
         when :appletvos, :tvos
           return Spaceship::ConnectAPI::Platform::TV_OS
-        when :osx, :macos
+        when :osx, :macos, :mac
           return Spaceship::ConnectAPI::Platform::MAC_OS
         when :ios
           return Spaceship::ConnectAPI::Platform::IOS

data/spaceship/lib/spaceship/connect_api/client.rb

@@ -13,7 +13,7 @@ module Spaceship
       # Instantiates a client with cookie session or a JWT token.
       def initialize(cookie: nil, current_team_id: nil, token: nil)
         if token.nil?
-          super(cookie: cookie, current_team_id: current_team_id)
+          super(cookie: cookie, current_team_id: current_team_id, timeout: 1200)
         else
           options = {
             request: {
@@ -78,46 +78,76 @@ module Spaceship
       end
 
       def get(url_or_path, params = nil)
-        response = request(:get) do |req|
-          req.url(url_or_path)
-          req.options.params_encoder = Faraday::NestedParamsEncoder
-          req.params = params if params
-          req.headers['Content-Type'] = 'application/json'
+        response = with_asc_retry do
+          request(:get) do |req|
+            req.url(url_or_path)
+            req.options.params_encoder = Faraday::NestedParamsEncoder
+            req.params = params if params
+            req.headers['Content-Type'] = 'application/json'
+          end
         end
         handle_response(response)
       end
 
       def post(url_or_path, body)
-        response = request(:post) do |req|
-          req.url(url_or_path)
-          req.body = body.to_json
-          req.headers['Content-Type'] = 'application/json'
+        response = with_asc_retry do
+          request(:post) do |req|
+            req.url(url_or_path)
+            req.body = body.to_json
+            req.headers['Content-Type'] = 'application/json'
+          end
         end
         handle_response(response)
       end
 
       def patch(url_or_path, body)
-        response = request(:patch) do |req|
-          req.url(url_or_path)
-          req.body = body.to_json
-          req.headers['Content-Type'] = 'application/json'
+        response = with_asc_retry do
+          request(:patch) do |req|
+            req.url(url_or_path)
+            req.body = body.to_json
+            req.headers['Content-Type'] = 'application/json'
+          end
         end
         handle_response(response)
       end
 
       def delete(url_or_path, params = nil, body = nil)
-        response = request(:delete) do |req|
-          req.url(url_or_path)
-          req.options.params_encoder = Faraday::NestedParamsEncoder if params
-          req.params = params if params
-          req.body = body.to_json if body
-          req.headers['Content-Type'] = 'application/json' if body
+        response = with_asc_retry do
+          request(:delete) do |req|
+            req.url(url_or_path)
+            req.options.params_encoder = Faraday::NestedParamsEncoder if params
+            req.params = params if params
+            req.body = body.to_json if body
+            req.headers['Content-Type'] = 'application/json' if body
+          end
         end
         handle_response(response)
       end
 
       protected
 
+      def with_asc_retry(tries = 5, &_block)
+        tries = 1 if Object.const_defined?("SpecHelper")
+        response = yield
+
+        tries -= 1
+        status = response.status if response
+
+        if [504].include?(status)
+          msg = "Timeout received! Retrying after 3 seconds (remaining: #{tries})..."
+          raise msg
+        end
+
+        return response
+      rescue => error
+        puts(error) if Spaceship::Globals.verbose?
+        if tries.zero?
+          return response
+        else
+          retry
+        end
+      end
+
       def handle_response(response)
         if (200...300).cover?(response.status) && (response.body.nil? || response.body.empty?)
           return

data/spaceship/lib/spaceship/connect_api/file_uploader.rb

@@ -0,0 +1,66 @@
+require 'faraday' # HTTP Client
+require 'faraday-cookie_jar'
+require 'faraday_middleware'
+
+module Spaceship
+  class ConnectAPI
+    module FileUploader
+      def self.upload(upload_operation, payload)
+        # {
+        #   "method": "PUT",
+        #   "url": "https://some-url-apple-gives-us",
+        #   "length": 57365,
+        #   "offset": 0,
+        #   "requestHeaders": [
+        #     {
+        #       "name": "Content-Type",
+        #       "value": "image/png"
+        #     }
+        #   ]
+        # }
+
+        headers = {}
+        upload_operation["requestHeaders"].each do |hash|
+          headers[hash["name"]] = hash["value"]
+        end
+
+        client.send(
+          upload_operation["method"].downcase,
+          upload_operation["url"],
+          payload,
+          headers
+        )
+      end
+
+      def self.client
+        options = {
+          request: {
+              timeout: (ENV["SPACESHIP_TIMEOUT"] || 300).to_i,
+              open_timeout: (ENV["SPACESHIP_TIMEOUT"] || 300).to_i
+            }
+        }
+
+        @client ||= Faraday.new(options) do |c|
+          c.response(:json, content_type: /\bjson$/)
+          c.response(:xml, content_type: /\bxml$/)
+          c.response(:plist, content_type: /\bplist$/)
+          c.adapter(Faraday.default_adapter)
+
+          if ENV['SPACESHIP_DEBUG']
+            # for debugging only
+            # This enables tracking of networking requests using Charles Web Proxy
+            c.proxy = "https://127.0.0.1:8888"
+            c.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+          elsif ENV["SPACESHIP_PROXY"]
+            c.proxy = ENV["SPACESHIP_PROXY"]
+            c.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE if ENV["SPACESHIP_PROXY_SSL_VERIFY_NONE"]
+          end
+
+          if ENV["DEBUG"]
+            puts("To run spaceship through a local proxy, use SPACESHIP_DEBUG")
+          end
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api/models/age_rating_declaration.rb

@@ -91,10 +91,14 @@ module Spaceship
 
       def self.map_value_from_itc(key, value)
         if ["gamblingAndContests", "unrestrictedWebAccess"].include?(key)
-          return LEGACY_BOOLEAN_VALUE_ITC_MAP[value]
+          new_value = LEGACY_BOOLEAN_VALUE_ITC_MAP[value]
+          return value if new_value.nil?
+          return new_value
         else
           return LEGACY_RATING_VALUE_ITC_MAP[value]
         end
+
+        return value
       end
 
       #

data/spaceship/lib/spaceship/connect_api/models/app.rb

@@ -55,15 +55,24 @@ module Spaceship
       end
 
       def self.create(name: nil, version_string: nil, sku: nil, primary_locale: nil, bundle_id: nil, platforms: nil)
-        Spaceship::ConnectAPI.post_app(name: name, version_string: version_string, sku: sku, primary_locale: primary_locale, bundle_id: bundle_id, platforms: platforms)
+        Spaceship::ConnectAPI.post_app(
+          name: name,
+          version_string: version_string,
+          sku: sku, primary_locale:
+          primary_locale,
+          bundle_id: bundle_id,
+          platforms: platforms,
+          territory_ids: territory_ids,
+          available_in_new_territories: available_in_new_territories
+        )
       end
 
       def self.get(app_id: nil, includes: "appStoreVersions")
         return Spaceship::ConnectAPI.get_app(app_id: app_id, includes: includes).first
       end
 
-      def update(attributes: nil)
-        return Spaceship::ConnectAPI.patch_app(app_id: id, attributes: attributes)
+      def update(attributes: nil, app_price_tier_id: nil, territory_ids: nil)
+        return Spaceship::ConnectAPI.patch_app(app_id: id, attributes: attributes, app_price_tier_id: app_price_tier_id, territory_ids: territory_ids)
       end
 
       #
@@ -95,11 +104,6 @@ module Spaceship
         return resp.to_models
       end
 
-      def update_app_price_tier(app_price_tier_id: nil)
-        resp = Spaceship::ConnectAPI.patch_app_app_prices(app_id: id, app_price_tier_id: app_price_tier_id)
-        return resp.first
-      end
-
       #
       # App Store Versions
       #

data/spaceship/lib/spaceship/connect_api/models/app_info.rb

@@ -38,19 +38,11 @@ module Spaceship
       #
 
       def update(filter: {}, includes: nil, limit: nil, sort: nil)
-        Spaceship::ConnectAPI.patch_app_info(app_info_id: id)
+        Spaceship::ConnectAPI.patch_app_info(app_info_id: id).first
       end
 
-      def update_categories(primary_category_id: nil, secondary_category_id: nil, primary_subcategory_one_id: nil, primary_subcategory_two_id: nil, secondary_subcategory_one_id: nil, secondary_subcategory_two_id: nil)
-        Spaceship::ConnectAPI.patch_app_info_categories(
-          app_info_id: id,
-          primary_category_id: primary_category_id,
-          secondary_category_id: secondary_category_id,
-          primary_subcategory_one_id: primary_subcategory_one_id,
-          primary_subcategory_two_id: primary_subcategory_two_id,
-          secondary_subcategory_one_id: secondary_subcategory_one_id,
-          secondary_subcategory_two_id: secondary_subcategory_two_id
-        )
+      def update_categories(category_id_map: nil)
+        Spaceship::ConnectAPI.patch_app_info_categories(app_info_id: id, category_id_map: category_id_map).first
       end
 
       def delete!(filter: {}, includes: nil, limit: nil, sort: nil)

data/spaceship/lib/spaceship/connect_api/models/app_preview.rb

@@ -0,0 +1,77 @@
+require_relative '../model'
+require_relative '../file_uploader'
+
+module Spaceship
+  class ConnectAPI
+    class AppPreview
+      include Spaceship::ConnectAPI::Model
+
+      attr_accessor :file_size
+      attr_accessor :file_name
+      attr_accessor :source_file_checksum
+      attr_accessor :preview_frame_time_code
+      attr_accessor :mime_type
+      attr_accessor :video_url
+      attr_accessor :preview_image
+      attr_accessor :upload_operations
+      attr_accessor :asset_deliver_state
+      attr_accessor :upload
+
+      attr_mapping({
+        "fileSize" => "file_size",
+        "fileName" => "file_name",
+        "sourceFileChecksum" => "source_file_checksum",
+        "previewFrameTimeCode" => "preview_frame_time_code",
+        "mimeType" => "mime_type",
+        "videoUrl" => "video_url",
+        "previewImage" => "preview_image",
+        "uploadOperations" => "upload_operations",
+        "assetDeliveryState" => "asset_delivery_state",
+        "uploaded" => "uploaded"
+      })
+
+      def self.type
+        return "appPreviews"
+      end
+
+      #
+      # API
+      #
+
+      def self.create(app_preview_set_id: nil, path: nil)
+        require 'faraday'
+
+        filename = File.basename(path)
+        filesize = File.size(path)
+        payload = File.binread(path)
+
+        post_attributes = {
+          fileSize: filesize,
+          fileName: filename
+        }
+
+        post_resp = Spaceship::ConnectAPI.post_app_preview(
+          app_preview_set_id: app_preview_set_id,
+          attributes: post_attributes
+        ).to_models.first
+
+        upload_operation = post_resp.upload_operations.first
+        Spaceship::ConnectAPI::FileUploader.upload(upload_operation, payload)
+
+        patch_attributes = {
+          uploaded: true,
+          sourceFileChecksum: "checksum-holder"
+        }
+
+        Spaceship::ConnectAPI.patch_app_preview(
+          app_preview_id: post_resp.id,
+          attributes: patch_attributes
+        ).to_models.first
+      end
+
+      def delete!(filter: {}, includes: nil, limit: nil, sort: nil)
+        Spaceship::ConnectAPI.delete_app_preview(app_preview_id: id)
+      end
+    end
+  end
+end