fastlane_pricing_fix 2.212.1

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

@@ -0,0 +1,27 @@
+require_relative '../api_client'
+require_relative './users'
+require_relative '../../tunes/tunes_client'
+
+module Spaceship
+  class ConnectAPI
+    module Users
+      class Client < Spaceship::ConnectAPI::APIClient
+        def initialize(cookie: nil, current_team_id: nil, token: nil, another_client: nil)
+          another_client ||= Spaceship::Tunes.client if cookie.nil? && token.nil?
+
+          super(cookie: cookie, current_team_id: current_team_id, token: token, another_client: another_client)
+
+          # Used by most iris requests starting in July 2021
+          @additional_headers = { 'x-csrf-itc': '[asc-ui]' } if another_client
+
+          self.extend(Spaceship::ConnectAPI::Users::API)
+          self.users_request_client = self
+        end
+
+        def self.hostname
+          'https://appstoreconnect.apple.com/iris/v1/'
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api/users/users.rb

@@ -0,0 +1,135 @@
+require 'spaceship/connect_api/users/client'
+
+module Spaceship
+  class ConnectAPI
+    module Users
+      module API
+        def users_request_client=(users_request_client)
+          @users_request_client = users_request_client
+        end
+
+        def users_request_client
+          return @users_request_client if @users_request_client
+          raise TypeError, "You need to instantiate this module with users_request_client"
+        end
+
+        #
+        # users
+        #
+
+        # Get list of users
+        def get_users(filter: {}, includes: nil, limit: nil, sort: nil)
+          params = users_request_client.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+          users_request_client.get("users", params)
+        end
+
+        # Delete existing user
+        def delete_user(user_id: nil)
+          users_request_client.delete("users/#{user_id}")
+        end
+
+        # Add app permissions for user
+        # @deprecated Use {#post_user_visible_apps} instead.
+        def add_user_visible_apps(user_id: nil, app_ids: nil)
+          post_user_visible_apps(user_id: user_id, app_ids: app_ids)
+        end
+
+        def post_user_visible_apps(user_id: nil, app_ids: nil)
+          body = {
+            data: app_ids.map do |app_id|
+              {
+                type: "apps",
+                id: app_id
+              }
+            end
+          }
+
+          users_request_client.post("users/#{user_id}/relationships/visibleApps", body)
+        end
+
+        # Replace app permissions for user
+        def patch_user_visible_apps(user_id: nil, app_ids: nil)
+          body = {
+            data: app_ids.map do |app_id|
+              {
+                type: "apps",
+                id: app_id
+              }
+            end
+          }
+
+          users_request_client.patch("users/#{user_id}/relationships/visibleApps", body)
+        end
+
+        # Remove app permissions for user
+        def delete_user_visible_apps(user_id: nil, app_ids: nil)
+          body = {
+            data: app_ids.map do |app_id|
+              {
+                type: "apps",
+                id: app_id
+              }
+            end
+          }
+          params = nil
+          users_request_client.delete("users/#{user_id}/relationships/visibleApps", params, body)
+        end
+
+        # Get app permissions for user
+        def get_user_visible_apps(user_id: id, limit: nil)
+          params = users_request_client.build_params(filter: {}, includes: nil, limit: limit, sort: nil)
+          users_request_client.get("users/#{user_id}/visibleApps", params)
+        end
+
+        #
+        # invitations (invited users)
+        #
+
+        # Get all invited users
+        def get_user_invitations(filter: {}, includes: nil, limit: nil, sort: nil)
+          params = users_request_client.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+          users_request_client.get("userInvitations", params)
+        end
+
+        # Invite new users to App Store Connect
+        def post_user_invitation(email: nil, first_name: nil, last_name: nil, roles: [], provisioning_allowed: nil, all_apps_visible: nil, visible_app_ids: [])
+          body = {
+            data: {
+              type: "userInvitations",
+              attributes: {
+                email: email,
+                firstName: first_name,
+                lastName: last_name,
+                roles: roles,
+                provisioningAllowed: provisioning_allowed,
+                allAppsVisible: all_apps_visible
+              },
+              relationships: {
+                visibleApps: {
+                  data: visible_app_ids.map do |id|
+                    {
+                      id: id,
+                      type: "apps"
+                    }
+                  end
+                }
+              }
+            }
+          }
+          users_request_client.post("userInvitations", body)
+        end
+
+        # Remove invited user from team (not yet accepted)
+        def delete_user_invitation(user_invitation_id: nil)
+          users_request_client.delete("userInvitations/#{user_invitation_id}")
+        end
+
+        # Get all app permissions for invited user
+        def get_user_invitation_visible_apps(user_invitation_id: id, limit: nil)
+          params = users_request_client.build_params(filter: {}, includes: nil, limit: limit, sort: nil)
+          users_request_client.get("userInvitations/#{user_invitation_id}/visibleApps", params)
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api.rb

@@ -0,0 +1,132 @@
+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'
+require 'spaceship/connect_api/users/users'
+require 'spaceship/connect_api/tunes/tunes'
+
+require 'spaceship/connect_api/models/bundle_id_capability'
+require 'spaceship/connect_api/models/bundle_id'
+require 'spaceship/connect_api/models/capabilities'
+require 'spaceship/connect_api/models/certificate'
+require 'spaceship/connect_api/models/device'
+require 'spaceship/connect_api/models/profile'
+
+require 'spaceship/connect_api/models/user'
+require 'spaceship/connect_api/models/user_invitation'
+
+require 'spaceship/connect_api/models/app'
+require 'spaceship/connect_api/models/beta_app_localization'
+require 'spaceship/connect_api/models/beta_build_localization'
+require 'spaceship/connect_api/models/beta_build_metric'
+require 'spaceship/connect_api/models/beta_app_review_detail'
+require 'spaceship/connect_api/models/beta_app_review_submission'
+require 'spaceship/connect_api/models/beta_feedback'
+require 'spaceship/connect_api/models/beta_group'
+require 'spaceship/connect_api/models/beta_screenshot'
+require 'spaceship/connect_api/models/beta_tester'
+require 'spaceship/connect_api/models/beta_tester_metric'
+require 'spaceship/connect_api/models/build'
+require 'spaceship/connect_api/models/build_delivery'
+require 'spaceship/connect_api/models/build_beta_detail'
+require 'spaceship/connect_api/models/build_bundle'
+require 'spaceship/connect_api/models/build_bundle_file_sizes'
+require 'spaceship/connect_api/models/custom_app_organization'
+require 'spaceship/connect_api/models/custom_app_user'
+require 'spaceship/connect_api/models/pre_release_version'
+
+require 'spaceship/connect_api/models/app_data_usage'
+require 'spaceship/connect_api/models/app_data_usage_category'
+require 'spaceship/connect_api/models/app_data_usage_data_protection'
+require 'spaceship/connect_api/models/app_data_usage_grouping'
+require 'spaceship/connect_api/models/app_data_usage_purposes'
+require 'spaceship/connect_api/models/app_data_usages_publish_state'
+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_point'
+require 'spaceship/connect_api/models/app_price_tier'
+require 'spaceship/connect_api/models/app_store_review_attachment'
+require 'spaceship/connect_api/models/app_store_review_detail'
+require 'spaceship/connect_api/models/app_store_version_release_request'
+require 'spaceship/connect_api/models/app_store_version_submission'
+require 'spaceship/connect_api/models/app_screenshot_set'
+require 'spaceship/connect_api/models/app_screenshot'
+require 'spaceship/connect_api/models/app_store_version_localization'
+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/review_submission'
+require 'spaceship/connect_api/models/review_submission_item'
+require 'spaceship/connect_api/models/reset_ratings_request'
+require 'spaceship/connect_api/models/sandbox_tester'
+require 'spaceship/connect_api/models/territory'
+
+require 'spaceship/connect_api/models/resolution_center_message'
+require 'spaceship/connect_api/models/resolution_center_thread'
+require 'spaceship/connect_api/models/review_rejection'
+require 'spaceship/connect_api/models/actor'
+
+module Spaceship
+  class ConnectAPI
+    # Defined in the App Store Connect API docs:
+    # https://developer.apple.com/documentation/appstoreconnectapi/platform
+    #
+    # Used for query param filters
+    module Platform
+      IOS = "IOS"
+      MAC_OS = "MAC_OS"
+      TV_OS = "TV_OS"
+      WATCH_OS = "WATCH_OS"
+
+      ALL = [IOS, MAC_OS, TV_OS, WATCH_OS]
+
+      def self.map(platform)
+        return platform if ALL.include?(platform)
+
+        # Map from fastlane input and Spaceship::TestFlight platform values
+        case platform.to_sym
+        when :appletvos, :tvos
+          return Spaceship::ConnectAPI::Platform::TV_OS
+        when :osx, :macos, :mac
+          return Spaceship::ConnectAPI::Platform::MAC_OS
+        when :ios
+          return Spaceship::ConnectAPI::Platform::IOS
+        else
+          raise "Cannot find a matching platform for '#{platform}' - valid values are #{ALL.join(', ')}"
+        end
+      end
+    end
+
+    # Defined in the App Store Connect API docs:
+    #
+    # Used for creating BundleId and Device
+    module BundleIdPlatform
+      IOS = "IOS"
+      MAC_OS = "MAC_OS"
+
+      ALL = [IOS, MAC_OS]
+
+      def self.map(platform)
+        return platform if ALL.include?(platform)
+
+        # Map from fastlane input and Spaceship::TestFlight platform values
+        case platform.to_sym
+        when :osx, :macos, :mac
+          return Spaceship::ConnectAPI::Platform::MAC_OS
+        when :ios
+          return Spaceship::ConnectAPI::Platform::IOS
+        else
+          raise "Cannot find a matching platform for '#{platform}' - valid values are #{ALL.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/du/du_client.rb

@@ -0,0 +1,138 @@
+require_relative '../client'
+require_relative '../tunes/display_family'
+require_relative 'utilities'
+
+module Spaceship
+  # This class is used to upload Digital files (Images, Videos, JSON files) onto the du-itc service.
+  # Its implementation is tied to the tunes module (in particular using +AppVersion+ instances)
+  class DUClient < Spaceship::Client #:nodoc:
+    #####################################################
+    # @!group Init and Login
+    #####################################################
+
+    def self.hostname
+      "https://du-itc.itunes.apple.com"
+    end
+
+    #####################################################
+    # @!group Images
+    #####################################################
+
+    def upload_screenshot(app_version, upload_file, content_provider_id, sso_token_for_image, device, is_messages)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/image', content_provider_id: content_provider_id, sso_token: sso_token_for_image, du_validation_rule_set: screenshot_picture_type(device, is_messages))
+    end
+
+    def upload_purchase_merch_screenshot(app_id, upload_file, content_provider_id, sso_token_for_image)
+      upload_file(app_id: app_id, upload_file: upload_file, path: '/upload/image', content_provider_id: content_provider_id, sso_token: sso_token_for_image, du_validation_rule_set: 'MZPFT.MerchandisingIAPIcon')
+    end
+
+    def upload_purchase_review_screenshot(app_id, upload_file, content_provider_id, sso_token_for_image)
+      upload_file(app_id: app_id, upload_file: upload_file, path: '/upload/image', content_provider_id: content_provider_id, sso_token: sso_token_for_image, du_validation_rule_set: get_picture_type(upload_file))
+    end
+
+    def upload_large_icon(app_version, upload_file, content_provider_id, sso_token_for_image)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/image', content_provider_id: content_provider_id, sso_token: sso_token_for_image, du_validation_rule_set: 'MZPFT.LargeApplicationIcon')
+    end
+
+    def upload_watch_icon(app_version, upload_file, content_provider_id, sso_token_for_image)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/image', content_provider_id: content_provider_id, sso_token: sso_token_for_image, du_validation_rule_set: 'MZPFT.GizmoAppIcon')
+    end
+
+    def upload_geojson(app_version, upload_file, content_provider_id, sso_token_for_image)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/geo-json', content_provider_id: content_provider_id, sso_token: sso_token_for_image)
+    end
+
+    def upload_trailer(app_version, upload_file, content_provider_id, sso_token_for_video)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/purple-video', content_provider_id: content_provider_id, sso_token: sso_token_for_video)
+    end
+
+    def upload_trailer_preview(app_version, upload_file, content_provider_id, sso_token_for_image, device)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/image', content_provider_id: content_provider_id, sso_token: sso_token_for_image, du_validation_rule_set: screenshot_picture_type(device, nil))
+    end
+
+    def upload_app_review_attachment(app_version, upload_file, content_provider_id, sso_token_for_attachment)
+      upload_file(app_version: app_version, upload_file: upload_file, path: '/upload/app-resolution-file', content_provider_id: content_provider_id, sso_token: sso_token_for_attachment)
+    end
+
+    def get_picture_type(upload_file)
+      resolution = Utilities.resolution(upload_file.file_path)
+      result = device_resolution_map.find do |key, resolutions|
+        resolutions.include?(resolution)
+      end
+      raise "Unknown device for screen resolution #{resolution}" if result.nil?
+
+      picture_type_map[result[0]]
+    end
+
+    private
+
+    def upload_file(app_version: nil, upload_file: nil, path: nil, content_provider_id: nil, sso_token: nil, du_validation_rule_set: nil, app_id: nil)
+      raise "File #{upload_file.file_path} is empty" if upload_file.file_size == 0
+
+      if app_id
+        app_id = app_id
+        app_type = nil
+        version = nil
+        referrer = nil
+      else
+        version = app_version.version
+        app_id = app_version.application.apple_id
+        app_type = app_version.app_type
+        referrer = app_version.application.url
+      end
+
+      r = request(:post) do |req|
+        req.url("#{self.class.hostname}#{path}")
+        req.body = upload_file.bytes
+        req.headers['Accept'] = 'application/json, text/plain, */*'
+        req.headers['Content-Type'] = upload_file.content_type
+        req.headers['X-Apple-Upload-Referrer'] = referrer if referrer
+        req.headers['Referrer'] = referrer if referrer
+        req.headers['X-Apple-Upload-AppleId'] = app_id
+        req.headers['X-Apple-Jingle-Correlation-Key'] = "#{app_type}:AdamId=#{app_id}:Version=#{version}" if app_type
+        req.headers['X-Apple-Upload-itctoken'] = sso_token
+        req.headers['X-Apple-Upload-ContentProviderId'] = content_provider_id
+        req.headers['X-Original-Filename'] = upload_file.file_name
+        req.headers['X-Apple-Upload-Validation-RuleSets'] = du_validation_rule_set if du_validation_rule_set
+        req.headers['Content-Length'] = upload_file.file_size.to_s
+        req.headers['Connection'] = "keep-alive"
+      end
+
+      if r.status == 500 && r.body.include?("Server Error")
+        return upload_file(app_version: app_version, upload_file: upload_file, path: path, content_provider_id: content_provider_id, sso_token: sso_token, du_validation_rule_set: du_validation_rule_set, app_id: app_id)
+      end
+
+      parse_upload_response(r)
+    end
+
+    def picture_type_map
+      Spaceship::Tunes::DisplayFamily.all.map { |v| [v.name.to_sym, v.picture_type] }.to_h
+    end
+
+    def messages_picture_type_map
+      Spaceship::Tunes::DisplayFamily.all.select(&:messages_supported?).map { |v| [v.name.to_sym, v.messages_picture_type] }.to_h
+    end
+
+    def device_resolution_map
+      Spaceship::Tunes::DisplayFamily.all.map { |v| [v.name.to_sym, v.screenshot_resolutions] }.to_h
+    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 map.key?(device)
+      map[device]
+    end
+
+    def parse_upload_response(response)
+      content = response.body
+      if !content['statusCode'].nil? && content['statusCode'] != 200
+        error_codes = ""
+        error_codes = content['errorCodes'].join(',') unless content['errorCodes'].nil?
+        error_message = "[#{error_codes}] #{content['localizedMessage']}"
+        raise UnexpectedResponse.new, error_message
+      end
+      content
+    end
+  end
+end

data/spaceship/lib/spaceship/du/upload_file.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+
+require_relative 'utilities'
+
+module Spaceship
+  # a wrapper around the concept of file required to make uploads to DU
+  class UploadFile
+    attr_reader :file_path
+    attr_reader :file_name
+    attr_reader :file_size
+    attr_reader :content_type
+    attr_reader :bytes
+
+    class << self
+      def from_path(path)
+        raise "Image must exists at path: #{path}" unless File.exist?(path)
+
+        # md5 from original. keeping track of md5s allows to skip previously uploaded in deliver
+        content_md5 = Spaceship::Utilities.md5digest(path)
+        path = remove_alpha_channel(path) if File.extname(path).casecmp('.png').zero?
+
+        content_type = Utilities.content_type(path)
+        self.new(
+          file_path: path,
+          file_name: 'ftl_' + content_md5 + '_' + File.basename(path),
+          file_size: File.size(path),
+          content_type: content_type,
+          bytes: File.read(path)
+        )
+      end
+
+      # As things like screenshots and app icon shouldn't contain the alpha channel
+      # This will copy the image into /tmp to remove the alpha channel there
+      # That's done to not edit the original image
+      def remove_alpha_channel(original)
+        path = "/tmp/#{Digest::MD5.hexdigest(original)}.png"
+        FileUtils.copy(original, path)
+        if mac? # sips is only available on macOS
+          `sips -s format bmp '#{path}' &> /dev/null` # &> /dev/null since there is warning because of the extension
+          `sips -s format png '#{path}'`
+        end
+        return path
+      end
+
+      def mac?
+        (/darwin/ =~ RUBY_PLATFORM) != nil
+      end
+    end
+
+    private
+
+    def initialize(args)
+      args.each do |k, v|
+        instance_variable_set("@#{k}", v) unless v.nil?
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/du/utilities.rb

@@ -0,0 +1,99 @@
+require 'fastimage'
+require "English"
+
+module Spaceship
+  # Set of utility methods useful to work with media files
+  module Utilities #:nodoc:
+    # Identifies the content_type of a file based on its file name extension.
+    # Supports all formats required by DU-UTC right now (video, images and json)
+    # @param path (String) the path to the file
+    def content_type(path)
+      supported_file_types = {
+        '.jpg' => 'image/jpeg',
+        '.jpeg' => 'image/jpeg',
+        '.png' => 'image/png',
+        '.geojson' => 'application/json',
+        '.mov' => 'video/quicktime',
+        '.m4v' => 'video/mp4',
+        '.mp4' => 'video/mp4',
+        '.txt' => 'text/plain',
+        '.pdf' => 'application/pdf',
+        '.doc' => 'application/msword',
+        '.docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.rtf' => 'application/rtf',
+        '.pages' => 'application/x-iwork-pages-sffpages',
+        '.xls' => 'application/vnd.ms-excel',
+        '.xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.numbers' => 'application/x-iwork-numbers-sffnumbers',
+        '.rar' => 'application/x-rar-compressed',
+        '.plist' => 'application/xml',
+        '.crash' => 'text/x-apport',
+        '.avi' => 'video/x-msvideo',
+        '.zip' => 'application/zip'
+      }
+
+      extension = File.extname(path.downcase)
+      return supported_file_types[extension] if supported_file_types[extension]
+      raise "Unknown content-type for file #{path}"
+    end
+
+    # Identifies the resolution of a video or an image.
+    # Supports all video and images required by DU-UTC right now
+    # @param path (String) the path to the file
+    def resolution(path)
+      return FastImage.size(path) if content_type(path).start_with?("image")
+      return video_resolution(path) if content_type(path).start_with?("video")
+      raise "Cannot find resolution of file #{path}"
+    end
+
+    # Is the video or image in portrait mode ?
+    # Supports all video and images required by DU-UTC right now
+    # @param path (String) the path to the file
+    def portrait?(path)
+      resolution = resolution(path)
+      resolution[0] < resolution[1]
+    end
+
+    # Grabs a screenshot from the specified video at the specified timestamp using `ffmpeg`
+    # @param video_path (String) the path to the video file
+    # @param timestamp (String) the `ffmpeg` timestamp format (e.g. 00.00)
+    # @param dimensions (Array) the dimension of the screenshot to generate
+    # @return the TempFile containing the generated screenshot
+    def grab_video_preview(video_path, timestamp, dimensions)
+      width, height = dimensions
+      require 'tempfile'
+      tmp = Tempfile.new(['video_preview', ".jpg"])
+      file = tmp.path
+      command = "ffmpeg -y -i \"#{video_path}\" -s #{width}x#{height} -ss \"#{timestamp}\" -vframes 1 \"#{file}\" 2>&1 >/dev/null"
+      # puts "COMMAND: #{command}"
+      `#{command}`
+      raise "Failed to grab screenshot at #{timestamp} from #{video_path} (using #{command})" unless $CHILD_STATUS.to_i == 0
+      tmp
+    end
+
+    # identifies the resolution of a video using `ffmpeg`
+    # @param video_path (String) the path to the video file
+    # @return [Array] the resolution of the video
+    def video_resolution(video_path)
+      command = "ffmpeg -i \"#{video_path}\" 2>&1"
+      # puts "COMMAND: #{command}"
+      output = `#{command}`
+      # Note: ffmpeg exits with 1 if no output specified
+      # raise "Failed to find video information from #{video_path} (using #{command})" unless $CHILD_STATUS.to_i == 0
+      output = output.force_encoding("BINARY")
+      video_infos = output.split("\n").select { |l| l =~ /Stream.*Video/ }
+      raise "Unable to find Stream Video information from ffmpeg output of #{command}" if video_infos.count == 0
+      video_info = video_infos[0]
+      res = video_info.match(/.* ([0-9]+)x([0-9]+).*/)
+      raise "Unable to parse resolution information from #{video_info}" if res.size < 3
+      [res[1].to_i, res[2].to_i]
+    end
+
+    # @return (String) md5 checksum of given file
+    def md5digest(file_path)
+      Digest::MD5.hexdigest(File.read(file_path))
+    end
+
+    module_function :content_type, :grab_video_preview, :portrait?, :resolution, :video_resolution, :md5digest
+  end
+end