spaceship 0.37.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5876ed2b557a73506b42f22b1845d8e532574b96
-  data.tar.gz: 8b70dd155a884a368c2b55ea67b320674581928a
+  metadata.gz: c9b4955b9e80e81c5533fe2af232a21da7e1574d
+  data.tar.gz: 8dee46b8cb98408df79cd57ef17e245ce545425c
 SHA512:
-  metadata.gz: 705f85a89b839339b2b7b32344f8abf0525416add39db3a7ba07faf7b8fa2ae33f6db1dc7df0e7f225dce468fe60afd7400bcc8cfd82a59129ea783319bb8f17
-  data.tar.gz: 70d0bd2a25191aff18e84378fb0e300383c2a56fc9a1282f0286d8d5b868733677bfdf1790a02c6c6297f8c218a8d5816b7c1accfcc181c434c13e29cfde576a
+  metadata.gz: d8ad5bb425741a02cd3cb5981751825474791dc706d0ca3a46b3c3655079163b19d148696761ccaddf0f32e294d1f7f78c7c578aba89dd75425438e3c81ca424
+  data.tar.gz: 184f883e757dcaf0c0b39a8e8d577ef7eec8145d2b7ee94ffffe75d314d777532c0894214bcea1489ab42adcf78dc74e9d50b68522c639bd0371dea6994bfafb

data/lib/spaceship/client.rb

@@ -155,6 +155,7 @@ module Spaceship
 
     def store_cookie(path: nil)
       path ||= persistent_cookie_path
+      FileUtils.mkdir_p(File.expand_path("..", path))
 
       # really important to specify the session to true
       # otherwise myacinfo and more won't be stored
@@ -162,9 +163,21 @@ module Spaceship
       return File.read(path)
     end
 
+    # Returns preferred path for storing cookie
+    # for two step verification.
     def persistent_cookie_path
-      path = File.expand_path(File.join("~", ".spaceship", self.user, "cookie"))
-      FileUtils.mkdir_p(File.expand_path("..", path))
+      if ENV["SPACESHIP_COOKIE_PATH"]
+        path = File.expand_path(File.join(ENV["SPACESHIP_COOKIE_PATH"], "spaceship", self.user, "cookie"))
+      else
+        ["~/.spaceship", "/var/tmp/spaceship", "#{Dir.tmpdir}/spaceship"].each do |dir|
+          dir_parts = File.split(dir)
+          if directory_accessible?(dir_parts.first)
+            path = File.expand_path(File.join(dir, self.user, "cookie"))
+            break
+          end
+        end
+      end
+
       return path
     end
 
@@ -406,6 +419,10 @@ module Spaceship
 
     private
 
+    def directory_accessible?(path)
+      Dir.exist?(File.expand_path(path))
+    end
+
     def do_login(user, password)
       @loggedin = false
       ret = send_login_request(user, password) # different in subclasses

data/lib/spaceship/du/du_client.rb

@@ -14,8 +14,8 @@ module Spaceship
     # @!group Images
     #####################################################
 
-    def upload_screenshot(app_version, upload_file, content_provider_id, sso_token_for_image, device)
-      upload_file(app_version, upload_file, '/upload/image', content_provider_id, sso_token_for_image, screenshot_picture_type(device))
+    def upload_screenshot(app_version, upload_file, content_provider_id, sso_token_for_image, device, is_messages)
+      upload_file(app_version, upload_file, '/upload/image', content_provider_id, sso_token_for_image, screenshot_picture_type(device, is_messages))
     end
 
     def upload_large_icon(app_version, upload_file, content_provider_id, sso_token_for_image)
@@ -90,10 +90,22 @@ module Spaceship
       }
     end
 
-    def screenshot_picture_type(device)
+    def messages_picture_type_map
+      # rubocop:enable Style/ExtraSpacing
+      {
+        ipad:         "MZPFT.SortedTabletMessagesScreenShot",
+        ipadPro:      "MZPFT.SortedJ99MessagesScreenShot",
+        iphone6:      "MZPFT.SortedN61MessagesScreenShot",
+        iphone6Plus:  "MZPFT.SortedN56MessagesScreenShot",
+        iphone4:      "MZPFT.SortedN41MessagesScreenShot"
+      }
+    end
+
+    def screenshot_picture_type(device, is_messages)
+      map = is_messages ? messages_picture_type_map : picture_type_map
       device = device.to_sym
-      raise "Unknown picture type for device: #{device}" unless picture_type_map.key? device
-      picture_type_map[device]
+      raise "Unknown picture type for device: #{device}" unless map.key? device
+      map[device]
     end
 
     def parse_upload_response(response)

data/lib/spaceship/portal/certificate.rb

@@ -151,7 +151,7 @@ module Spaceship
         "UPV3DW712I" => ProductionPush,
         "Y3B2F3TYSI" => Passbook,
         "3T2ZP62QW8" => WebsitePush,
-        "E5D663CMZW" => WebsitePush,
+        "E5D663CMZW" => VoipPush,
         "4APLUP237T" => ApplePay
       }
 

data/lib/spaceship/portal/device.rb

@@ -22,7 +22,7 @@ module Spaceship
       #   "ios"
       attr_accessor :platform
 
-      # @return (String) Status of the device. Probably always "c"
+      # @return (String) Status of the device. "c" for enabled devices, "r" for disabled devices.
       # @example
       #   "c"
       attr_accessor :status
@@ -59,9 +59,10 @@ module Spaceship
         end
 
         # @param mac [Bool] Fetches Mac devices if true
+        # @param include_disabled [Bool] Whether to include disable devices. false by default.
         # @return (Array) Returns all devices registered for this account
-        def all(mac: false)
-          client.devices(mac: mac).map { |device| self.factory(device) }
+        def all(mac: false, include_disabled: false)
+          client.devices(mac: mac, include_disabled: include_disabled).map { |device| self.factory(device) }
         end
 
         # @return (Array) Returns all Apple TVs registered for this account
@@ -109,26 +110,29 @@ module Spaceship
         end
 
         # @param mac [Bool] Searches for Macs if true
+        # @param include_disabled [Bool] Whether to include disable devices. false by default.
         # @return (Device) Find a device based on the ID of the device. *Attention*:
         #  This is *not* the UDID. nil if no device was found.
-        def find(device_id, mac: false)
-          all(mac: mac).find do |device|
+        def find(device_id, mac: false, include_disabled: false)
+          all(mac: mac, include_disabled: include_disabled).find do |device|
             device.id == device_id
           end
         end
 
         # @param mac [Bool] Searches for Macs if true
+        # @param include_disabled [Bool] Whether to include disable devices. false by default.
         # @return (Device) Find a device based on the UDID of the device. nil if no device was found.
-        def find_by_udid(device_udid, mac: false)
-          all(mac: mac).find do |device|
+        def find_by_udid(device_udid, mac: false, include_disabled: false)
+          all(mac: mac, include_disabled: include_disabled).find do |device|
             device.udid.casecmp(device_udid) == 0
           end
         end
 
         # @param mac [Bool] Searches for Macs if true
+        # @param include_disabled [Bool] Whether to include disable devices. false by default.
         # @return (Device) Find a device based on its name. nil if no device was found.
-        def find_by_name(device_name, mac: false)
-          all(mac: mac).find do |device|
+        def find_by_name(device_name, mac: false, include_disabled: false)
+          all(mac: mac, include_disabled: include_disabled).find do |device|
             device.name == device_name
           end
         end
@@ -158,6 +162,31 @@ module Spaceship
           self.new(device)
         end
       end
+
+      def enabled?
+        return self.status == "c"
+      end
+
+      def disabled?
+        return self.status == "r"
+      end
+
+      # Enable current device.
+      def enable!
+        unless enabled?
+          attr = client.enable_device!(self.id, self.udid, mac: self.platform == 'mac')
+          initialize(attr)
+        end
+      end
+
+      # Disable current device. This will invalidate all provisioning profiles that use this device.
+      def disable!
+        if enabled?
+          client.disable_device!(self.id, self.udid, mac: self.platform == 'mac')
+          # disable request doesn't return device json, so we assume that the new status is "r" if response succeeded
+          self.status = "r"
+        end
+      end
     end
   end
 end

data/lib/spaceship/portal/portal_client.rb

@@ -216,26 +216,28 @@ module Spaceship
     # @!group Devices
     #####################################################
 
-    def devices(mac: false)
+    def devices(mac: false, include_disabled: false)
       paging do |page_number|
         r = request(:post, "account/#{platform_slug(mac)}/device/listDevices.action", {
           teamId: team_id,
           pageNumber: page_number,
           pageSize: page_size,
-          sort: 'name=asc'
+          sort: 'name=asc',
+          includeRemovedDevices: include_disabled
         })
         parse_response(r, 'devices')
       end
     end
 
-    def devices_by_class(device_class)
+    def devices_by_class(device_class, include_disabled: false)
       paging do |page_number|
         r = request(:post, 'account/ios/device/listDevices.action', {
           teamId: team_id,
           pageNumber: page_number,
           pageSize: page_size,
           sort: 'name=asc',
-          deviceClasses: device_class
+          deviceClasses: device_class,
+          includeRemovedDevices: include_disabled
         })
         parse_response(r, 'devices')
       end
@@ -256,6 +258,22 @@ module Spaceship
       parse_response(req, 'device')
     end
 
+    def disable_device!(device_id, device_udid, mac: false)
+      request(:post, "https://developer.apple.com/services-account/#{PROTOCOL_VERSION}/account/#{platform_slug(mac)}/device/deleteDevice.action", {
+        teamId: team_id,
+        deviceId: device_id
+      })
+    end
+
+    def enable_device!(device_id, device_udid, mac: false)
+      req = request(:post, "https://developer.apple.com/services-account/#{PROTOCOL_VERSION}/account/#{platform_slug(mac)}/device/enableDevice.action", {
+          teamId: team_id,
+          displayId: device_id,
+          deviceNumber: device_udid
+      })
+      parse_response(req, 'device')
+    end
+
     #####################################################
     # @!group Certificates
     #####################################################

data/lib/spaceship/tunes/app_version.rb

@@ -168,14 +168,13 @@ module Spaceship
         # @param application (Spaceship::Tunes::Application) The app this version is for
         # @param app_id (String) The unique Apple ID of this app
         # @param is_live (Boolean)
-        def find(application, app_id, is_live)
+        def find(application, app_id, is_live, platform: nil)
           # we only support applications
-          platform = Spaceship::Tunes::AppVersionCommon.find_platform(application.raw_data['versionSets'])
-          raise "We do not support BUNDLE types right now" if platform['type'] == 'BUNDLE'
+          raise "We do not support BUNDLE types right now" if application.type == 'BUNDLE'
 
           # too bad the "id" field is empty, it forces us to make more requests to the server
           # these could also be cached
-          attrs = client.app_version(app_id, is_live)
+          attrs = client.app_version(app_id, is_live, platform: platform)
           return nil unless attrs
 
           attrs[:application] = application
@@ -380,16 +379,17 @@ module Spaceship
       # @param sort_order (Fixnum): The sort_order, from 1 to 5
       # @param language (String): The language for this screenshot
       # @param device (string): The device for this screenshot
-      def upload_screenshot!(screenshot_path, sort_order, language, device)
+      # @param is_messages (Bool): True if the screenshot is for iMessage
+      def upload_screenshot!(screenshot_path, sort_order, language, device, is_messages)
         raise "sort_order must be higher than 0" unless sort_order > 0
         raise "sort_order must not be > 5" if sort_order > 5
         # this will also check both language and device parameters
-        device_lang_screenshots = screenshots_data_for_language_and_device(language, device)["value"]
+        device_lang_screenshots = screenshots_data_for_language_and_device(language, device, is_messages)["value"]
 
         existing_sort_orders = device_lang_screenshots.map { |s| s["value"]["sortOrder"] }
         if screenshot_path # adding / replacing
           upload_file = UploadFile.from_path screenshot_path
-          screenshot_data = client.upload_screenshot(self, upload_file, device)
+          screenshot_data = client.upload_screenshot(self, upload_file, device, is_messages)
 
           # Since October 2016 we also need to pass the size, height, width and checksum
           # otherwise iTunes Connect validation will fail at a later point
@@ -411,7 +411,8 @@ module Spaceship
           # if this value is not set, iTC will fallback to another device type for screenshots
           language_details = raw_data_details.find { |d| d["language"] == language }["displayFamilies"]["value"]
           device_language_details = language_details.find { |display_family| display_family['name'] == device }
-          device_language_details["scaled"]["value"] = false
+          scaled_key = is_messages ? "messagesScaled" : "scaled"
+          device_language_details[scaled_key]["value"] = false
 
           if existing_sort_orders.include?(sort_order) # replace
             device_lang_screenshots[existing_sort_orders.index(sort_order)] = new_screenshot
@@ -447,7 +448,7 @@ module Spaceship
       def upload_trailer!(trailer_path, language, device, timestamp = "05.00", preview_image_path = nil)
         raise "No app trailer supported for iphone35" if device == 'iphone35'
 
-        device_lang_trailer = trailer_data_for_language_and_device(language, device)
+        device_lang_trailer = trailer_data_for_language_and_device(language, device, is_messages)
         if trailer_path # adding / replacing trailer / replacing preview
           raise "Invalid timestamp #{timestamp}" if (timestamp =~ /^[0-9][0-9].[0-9][0-9]$/).nil?
 
@@ -554,8 +555,9 @@ module Spaceship
         @transit_app_file = Tunes::TransitAppFile.factory(transit_app_file) if transit_app_file
       end
 
-      def screenshots_data_for_language_and_device(language, device)
-        container_data_for_language_and_device("screenshots", language, device)
+      def screenshots_data_for_language_and_device(language, device, is_messages)
+        data_field = is_messages ? "messagesScreenshots" : "screenshots"
+        container_data_for_language_and_device(data_field, language, device)
       end
 
       def trailer_data_for_language_and_device(language, device)
@@ -582,7 +584,7 @@ module Spaceship
 
         raw_data_details.each do |row|
           # Now that's one language right here
-          @screenshots[row['language']] = setup_screenshots_for(row)
+          @screenshots[row['language']] = setup_screenshots_for(row) + setup_messages_screenshots_for(row)
         end
       end
 
@@ -626,6 +628,34 @@ module Spaceship
           #       "isRequired": false,
           #       "errorKeys": null
           #     }],
+          #   "messagesScaled": {
+          #     "value": false,
+          #     "isEditable": false,
+          #     "isRequired": false,
+          #     "errorKeys": null
+          #   },
+          #   "messagesScreenshots": {
+          #     "value": [{
+          #       "value": {
+          #         "assetToken": "Purple62/v4/08/0a/04/080a0430-c2cc-2577-f491-9e0a09c58ffe/mzl.pbcpzqyg.jpg",
+          #         "sortOrder": 1,
+          #         "type": null,
+          #         "originalFileName": "ios-414-1.jpg"
+          #       },
+          #       "isEditable": true,
+          #       "isRequired": false,
+          #       "errorKeys": null
+          #     }, {
+          #       "value": {
+          #         "assetToken": "Purple71/v4/de/81/aa/de81aa10-64f6-332e-c974-9ee46adab675/mzl.cshkjvwl.jpg",
+          #         "sortOrder": 2,
+          #         "type": null,
+          #         "originalFileName": "ios-414-2.jpg"
+          #       },
+          #       "isEditable": true,
+          #       "isRequired": false,
+          #       "errorKeys": null
+          #     }],
           #     "isEditable": true,
           #     "isRequired": false,
           #     "errorKeys": null
@@ -651,6 +681,31 @@ module Spaceship
         return result
       end
 
+      # generates the nested data structure to represent screenshots
+      def setup_messages_screenshots_for(row)
+        return [] if row.nil? || row["displayFamilies"].nil?
+
+        display_families = row.fetch("displayFamilies", {}).fetch("value", nil)
+        return [] unless display_families
+
+        result = []
+
+        display_families.each do |display_family|
+          display_family_screenshots = display_family.fetch("messagesScreenshots", {})
+          next unless display_family_screenshots
+          display_family_screenshots.fetch("value", []).each do |screenshot|
+            screenshot_data = screenshot["value"]
+            data = {
+                device_type: display_family['name'],
+                language: row["language"]
+            }.merge(screenshot_data)
+            result << Tunes::AppScreenshot.factory(data)
+          end
+        end
+
+        return result
+      end
+
       def setup_trailers
         @trailers = {}
         raw_data_details.each do |row|

data/lib/spaceship/tunes/app_version_common.rb

@@ -10,18 +10,20 @@ module Spaceship
           version['id']
         end
 
-        def find_platform(versions)
+        def find_platform(versions, search_platform: nil)
           # We only support platforms that exist ATM
           platform = versions.detect do |p|
             ['ios', 'osx', 'appletvos'].include? p['platformString']
           end
 
-          raise "Could not find platform ios, osx or appletvos for app #{app_id}" unless platform
+          raise "Could not find platform 'ios', 'osx' or 'appletvos'" unless platform
 
           # If your app has versions for both iOS and tvOS we will default to returning the iOS version for now.
           # This is intentional as we need to do more work to support apps that have hybrid versions.
-          if versions.length > 1
+          if versions.length > 1 && search_platform.nil?
             platform = versions.detect { |p| p['platformString'] == "ios" }
+          elsif !search_platform.nil?
+            platform = versions.detect { |p| p['platformString'] == search_platform }
           end
           platform
         end

data/lib/spaceship/tunes/application.rb

@@ -34,6 +34,9 @@ module Spaceship
       #   nil
       attr_accessor :app_icon_preview_url
 
+      # @return (Array) An array of all versions sets
+      attr_accessor :version_sets
+
       attr_mapping(
         'adamId' => :apple_id,
         'name' => :name,
@@ -91,21 +94,28 @@ module Spaceship
       # @!group Getting information
       #####################################################
 
+      def version_set_for_platform(platform)
+        version_sets.each do |version_set|
+          return version_set if version_set.platform == platform
+        end
+        nil
+      end
+
       # @return (Spaceship::AppVersion) Receive the version that is currently live on the
       #  App Store. You can't modify all values there, so be careful.
-      def live_version
-        Spaceship::AppVersion.find(self, self.apple_id, true)
+      def live_version(platform: nil)
+        Spaceship::AppVersion.find(self, self.apple_id, true, platform: platform)
       end
 
       # @return (Spaceship::AppVersion) Receive the version that can fully be edited
-      def edit_version
-        Spaceship::AppVersion.find(self, self.apple_id, false)
+      def edit_version(platform: nil)
+        Spaceship::AppVersion.find(self, self.apple_id, false, platform: platform)
       end
 
       # @return (Spaceship::AppVersion) This will return the `edit_version` if available
       #   and fallback to the `live_version`. Use this to just access the latest data
-      def latest_version
-        edit_version || live_version
+      def latest_version(platform: nil)
+        edit_version(platform: platform) || live_version(platform: platform)
       end
 
       # @return (String) An URL to this specific resource. You can enter this URL into your browser
@@ -126,11 +136,40 @@ module Spaceship
         Tunes::AppRatings.factory(attrs)
       end
 
+      def platforms
+        platforms = []
+        version_sets.each do |version_set|
+          platforms << version_set.platform
+        end
+        platforms
+      end
+
+      def type
+        if self.version_sets.nil?
+          raise 'The application has no version sets and Spaceship does not know what to do here.'
+        end
+
+        if self.version_sets.length == 1
+          version_sets[0].platform
+        end
+        platform = Spaceship::Tunes::AppVersionCommon.find_platform(raw_data['versionSets'])
+        platform['type']
+      end
+
       # kept for backward compatibility
       # tries to guess the platform of the currently submitted apps
       # note that as ITC now supports multiple app types, this might break
       # if your app supports more than one
       def platform
+        if self.version_sets.nil?
+          raise 'The application has no version sets and Spaceship does not know what to do here.'
+        end
+
+        if self.version_sets.length == 1
+          version_sets[0].platform
+        elsif self.platforms == %w(ios appletvos)
+          'ios'
+        end
         Spaceship::Tunes::AppVersionCommon.find_platform(raw_data['versionSets'])['platformString']
       end
 
@@ -156,12 +195,12 @@ module Spaceship
       # Create a new version of your app
       # Since we have stored the outdated raw_data, we need to refresh this object
       # otherwise `edit_version` will return nil
-      def create_version!(version_number)
-        if edit_version
+      def create_version!(version_number, platform: nil)
+        if edit_version(platform: platform)
           raise "Cannot create a new version for this app as there already is an `edit_version` available"
         end
 
-        client.create_version!(apple_id, version_number)
+        client.create_version!(apple_id, version_number, platform.nil? ? 'ios' : platform)
 
         # Future: implemented -reload method
       end
@@ -170,8 +209,8 @@ module Spaceship
       # This will either create a new version or change the version number
       # from an existing version
       # @return (Bool) Was something changed?
-      def ensure_version!(version_number)
-        if (e = edit_version)
+      def ensure_version!(version_number, platform: nil)
+        if (e = edit_version(platform: platform))
           if e.version.to_s != version_number.to_s
             # Update an existing version
             e.version = version_number
@@ -180,7 +219,7 @@ module Spaceship
           end
           return false
         else
-          create_version!(version_number)
+          create_version!(version_number, platform: platform)
           return true
         end
       end
@@ -200,9 +239,9 @@ module Spaceship
       #####################################################
 
       # TestFlight: A reference to all the build trains
-      # @return [Hash] a hash, the version number being the key
-      def build_trains
-        Tunes::BuildTrain.all(self, self.apple_id)
+      # @return [Hash] a hash, the version number and platform being the key
+      def build_trains(platform: nil)
+        Tunes::BuildTrain.all(self, self.apple_id, platform: platform)
       end
 
       # The numbers of all build trains that were uploaded
@@ -224,11 +263,11 @@ module Spaceship
         end
       end
 
-      # @return [Array] A list of all builds in an invalid state
-      def all_invalid_builds
+      # @return [Array]A list of binaries which are in the invalid state
+      def all_invalid_builds(platform: nil)
         builds = []
 
-        self.build_trains.values.each do |train|
+        self.build_trains(platform: platform).values.each do |train|
           builds.concat(train.invalid_builds)
         end
 
@@ -237,10 +276,10 @@ module Spaceship
 
       # @return [Array] This will return an array of *all* processing builds
       #   this include pre-processing or standard processing
-      def all_processing_builds
+      def all_processing_builds(platform: nil)
         builds = []
 
-        self.build_trains.values.each do |train|
+        self.build_trains(platform: platform).each do |version_number, train|
           builds.concat(train.processing_builds)
         end
 
@@ -249,9 +288,9 @@ module Spaceship
 
       # Get all builds that are already processed for all build trains
       # You can either use the return value (array) or pass a block
-      def builds
+      def builds(platform: nil)
         all_builds = []
-        self.build_trains.each do |version_number, train|
+        self.build_trains(platform: platform).each do |version_number, train|
           train.builds.each do |build|
             yield(build) if block_given?
             all_builds << build unless block_given?
@@ -301,6 +340,11 @@ module Spaceship
       # @!group General
       #####################################################
       def setup
+        super
+        @version_sets = (self.raw_data['versionSets'] || []).map do |attrs|
+          attrs[:application] = self
+          Tunes::VersionSet.factory(attrs)
+        end
       end
 
       #####################################################
@@ -381,8 +425,7 @@ module Spaceship
       # private to module
       def ensure_not_a_bundle
         # we only support applications
-        platform = Spaceship::Tunes::AppVersionCommon.find_platform(raw_data['versionSets'])
-        raise "We do not support BUNDLE types right now" if platform['type'] == 'BUNDLE'
+        raise "We do not support BUNDLE types right now" if self.type == 'BUNDLE'
       end
     end
   end

data/lib/spaceship/tunes/build_train.rb

@@ -6,6 +6,10 @@ module Spaceship
       # @return (Spaceship::Tunes::Application) A reference to the application this train is for
       attr_accessor :application
 
+      # @return (Spaceship::Tunes::VersionSet) A reference to the version set
+      #   this train is for
+      attr_accessor :version_set
+
       # @return (Array) An array of all builds that are inside this train (Spaceship::Tunes::Build)
       attr_reader :builds
 
@@ -45,16 +49,18 @@ module Spaceship
 
         # @param application (Spaceship::Tunes::Application) The app this train is for
         # @param app_id (String) The unique Apple ID of this app
-        def all(application, app_id)
+        def all(application, app_id, platform: nil)
           trains = []
-          trains += client.build_trains(app_id, 'internal')['trains']
-          trains += client.build_trains(app_id, 'external')['trains']
+          trains += client.build_trains(app_id, 'internal', platform: platform)['trains']
+          trains += client.build_trains(app_id, 'external', platform: platform)['trains']
 
           result = {}
           trains.each do |attrs|
             attrs[:application] = application
             current = self.factory(attrs)
-            result[current.version_string] = current
+            if (!platform.nil? && current.platform == platform) || platform.nil?
+              result[current.version_string] = current
+            end
           end
           result
         end
@@ -101,6 +107,8 @@ module Spaceship
             @processing_builds << build
           end
         end
+
+        self.version_set = self.application.version_set_for_platform(self.platform)
       end
 
       # @return (Spaceship::Tunes::Build) The latest build for this train, sorted by upload time.
@@ -110,7 +118,7 @@ module Spaceship
 
       # @param (testing_type) internal or external
       def update_testing_status!(new_value, testing_type, build = nil)
-        data = client.build_trains(self.application.apple_id, testing_type)
+        data = client.build_trains(self.application.apple_id, testing_type, platform: self.application.platform)
 
         build ||= latest_build if testing_type == 'external'
         testing_key = "#{testing_type}Testing"

data/lib/spaceship/tunes/tunes.rb

@@ -1,5 +1,6 @@
 require 'spaceship/tunes/tunes_base'
 require 'spaceship/tunes/application'
+require 'spaceship/tunes/version_set'
 require 'spaceship/tunes/app_version'
 require 'spaceship/tunes/app_version_common'
 require 'spaceship/tunes/app_submission'

data/lib/spaceship/tunes/tunes_client.rb

@@ -129,6 +129,7 @@ module Spaceship
       loop do
         puts "Multiple iTunes Connect teams found, please enter the number of the team you want to use: "
         puts "Note: to automatically choose the team, provide either the iTunes Connect Team ID, or the Team Name in your fastlane/Appfile:"
+        puts "Alternatively you can pass the team name or team ID using the `FASTLANE_ITC_TEAM_ID` or `FASTLANE_ITC_TEAM_NAME` environment variable"
         first_team = teams.first["contentProvider"]
         puts ""
         puts "  itc_team_id \"#{first_team['contentProviderId']}\""
@@ -265,6 +266,7 @@ module Spaceship
     #   can't be changed after you submit your first build.
     def create_application!(name: nil, primary_language: nil, version: nil, sku: nil, bundle_id: nil, bundle_id_suffix: nil, company_name: nil)
       # First, we need to fetch the data from Apple, which we then modify with the user's values
+      primary_language ||= "English"
       app_type = 'ios'
       r = request(:get, "ra/apps/create/v2/?platformString=#{app_type}")
       data = parse_response(r, 'data')
@@ -274,7 +276,8 @@ module Spaceship
       data['versionString'] = { value: version }
       data['name'] = { value: name }
       data['bundleId'] = { value: bundle_id }
-      data['primaryLanguage'] = { value: primary_language || 'English' }
+      data['primaryLanguage'] = { value: primary_language }
+      data['primaryLocaleCode'] = { value: primary_language.to_language_code }
       data['vendorId'] = { value: sku }
       data['bundleIdSuffix'] = { value: bundle_id_suffix }
       data['companyName'] = { value: company_name } if company_name
@@ -328,14 +331,14 @@ module Spaceship
     # @!group AppVersions
     #####################################################
 
-    def app_version(app_id, is_live)
+    def app_version(app_id, is_live, platform: nil)
       raise "app_id is required" unless app_id
 
       # First we need to fetch the IDs for the edit / live version
       r = request(:get, "ra/apps/#{app_id}/overview")
       platforms = parse_response(r, 'data')['platforms']
 
-      platform = Spaceship::Tunes::AppVersionCommon.find_platform(platforms)
+      platform = Spaceship::Tunes::AppVersionCommon.find_platform(platforms, search_platform: platform)
       return nil unless platform
 
       version_id = Spaceship::Tunes::AppVersionCommon.find_version_id(platform, is_live)
@@ -484,13 +487,27 @@ module Spaceship
     # @param app_version (AppVersion): The version of your app
     # @param upload_image (UploadFile): The image to upload
     # @param device (string): The target device
+    # @param is_messages (Bool): True if the screenshot is for iMessage
     # @return [JSON] the response
-    def upload_screenshot(app_version, upload_image, device)
+    def upload_screenshot(app_version, upload_image, device, is_messages)
       raise "app_version is required" unless app_version
       raise "upload_image is required" unless upload_image
       raise "device is required" unless device
 
-      du_client.upload_screenshot(app_version, upload_image, content_provider_id, sso_token_for_image, device)
+      du_client.upload_screenshot(app_version, upload_image, content_provider_id, sso_token_for_image, device, is_messages)
+    end
+
+    # Uploads an iMessage screenshot
+    # @param app_version (AppVersion): The version of your app
+    # @param upload_image (UploadFile): The image to upload
+    # @param device (string): The target device
+    # @return [JSON] the response
+    def upload_messages_screenshot(app_version, upload_image, device)
+      raise "app_version is required" unless app_version
+      raise "upload_image is required" unless upload_image
+      raise "device is required" unless device
+
+      du_client.upload_messages_screenshot(app_version, upload_image, content_provider_id, sso_token_for_image, device)
     end
 
     # Uploads the transit app file
@@ -558,9 +575,11 @@ module Spaceship
     #####################################################
 
     # @param (testing_type) internal or external
-    def build_trains(app_id, testing_type)
+    def build_trains(app_id, testing_type, platform: nil)
       raise "app_id is required" unless app_id
-      r = request(:get, "ra/apps/#{app_id}/trains/?testingType=#{testing_type}")
+      url = "ra/apps/#{app_id}/trains/?testingType=#{testing_type}"
+      url += "&platform=#{platform}" unless platform.nil?
+      r = request(:get, url)
       parse_response(r, 'data')
     end
 
@@ -589,13 +608,15 @@ module Spaceship
     end
 
     # All build trains, even if there is no TestFlight
-    def all_build_trains(app_id: nil, platform: nil)
-      r = request(:get, "ra/apps/#{app_id}/buildHistory?platform=#{platform || 'ios'}")
+    def all_build_trains(app_id: nil, platform: 'ios')
+      platform = 'ios' if platform.nil?
+      r = request(:get, "ra/apps/#{app_id}/buildHistory?platform=#{platform}")
       handle_itc_response(r.body)
     end
 
-    def all_builds_for_train(app_id: nil, train: nil, platform: nil)
-      r = request(:get, "ra/apps/#{app_id}/trains/#{train}/buildHistory?platform=#{platform || 'ios'}")
+    def all_builds_for_train(app_id: nil, train: nil, platform: 'ios')
+      platform = 'ios' if platform.nil?
+      r = request(:get, "ra/apps/#{app_id}/trains/#{train}/buildHistory?platform=#{platform}")
       handle_itc_response(r.body)
     end
 

data/lib/spaceship/tunes/version_set.rb

@@ -0,0 +1,35 @@
+module Spaceship
+  module Tunes
+    # Represents a version set inside of an application
+    class VersionSet < TunesBase
+      #####################################################
+      # @!group General metadata
+      #####################################################
+
+      # @return (String) The type of the version set. So far only APP
+      attr_accessor :type
+
+      # @return (Spaceship::Tunes::Application) A reference to the application the version_set is contained in
+      attr_accessor :application
+
+      # @return (String)
+      attr_accessor :platform
+
+      attr_mapping(
+        'type' => :type,
+        'platformString' => :platform
+      )
+
+      class << self
+        # Create a new object based on a hash.
+        # This is used to create a new object based on the server response.
+        def factory(attrs)
+          self.new(attrs)
+        end
+      end
+    end
+  end
+end
+
+#
+#

data/lib/spaceship/version.rb

@@ -1,4 +1,4 @@
 module Spaceship
-  VERSION = "0.37.0".freeze
+  VERSION = "0.38.0".freeze
   DESCRIPTION = "Ruby library to access the Apple Dev Center and iTunes Connect".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spaceship
 version: !ruby/object:Gem::Version
-  version: 0.37.0
+  version: 0.38.0
 platform: ruby
 authors:
 - Felix Krause
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-03 00:00:00.000000000 Z
+date: 2016-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: credentials_manager
@@ -377,6 +377,7 @@ files:
 - lib/spaceship/tunes/tunes_base.rb
 - lib/spaceship/tunes/tunes_client.rb
 - lib/spaceship/tunes/user_detail.rb
+- lib/spaceship/tunes/version_set.rb
 - lib/spaceship/two_step_client.rb
 - lib/spaceship/ui.rb
 - lib/spaceship/update_checker.rb
@@ -401,7 +402,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Ruby library to access the Apple Dev Center and iTunes Connect