fastlane_iac_publish 0.1.0

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

@@ -0,0 +1,33 @@
+require_relative '../client'
+require_relative '../../tunes/tunes_client'
+
+module Spaceship
+  class ConnectAPI
+    module Users
+      class Client < Spaceship::ConnectAPI::Client
+        def self.instance
+          # Verify there is a token or a client that can be used
+          if Spaceship::ConnectAPI.token
+            if @client.nil? || @client.token != Spaceship::ConnectAPI.token
+              @client = Client.new(token: Spaceship::ConnectAPI.token)
+            end
+          elsif Spaceship::Tunes.client
+            # Initialize new client if new or if team changed
+            if @client.nil? || @client.team_id != Spaceship::Tunes.client.team_id
+              @client = Client.client_with_authorization_from(Spaceship::Tunes.client)
+            end
+          end
+
+          # Need to handle not having a client but this shouldn't ever happen
+          raise "Please login using `Spaceship::Tunes.login('user', 'password')`" unless @client
+
+          @client
+        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,16 @@
+require 'spaceship/connect_api/users/client'
+
+module Spaceship
+  class ConnectAPI
+    module Users
+      #
+      # users
+      #
+
+      def get_users(filter: {}, includes: nil, limit: nil, sort: nil)
+        params = Client.instance.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+        Client.instance.get("users", params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+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_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

data/spaceship/lib/spaceship/errors.rb

@@ -0,0 +1,79 @@
+module Spaceship
+  # Base class for errors that want to present their message as
+  # preferred error info for fastlane error handling. See:
+  # fastlane_core/lib/fastlane_core/ui/fastlane_runner.rb
+  class BasicPreferredInfoError < StandardError
+    TITLE = 'The request could not be completed because:'.freeze
+
+    def preferred_error_info
+      message ? [TITLE, message] : nil
+    end
+  end
+
+  # Invalid user credentials were provided
+  class InvalidUserCredentialsError < BasicPreferredInfoError; end
+
+  # Raised when no user credentials were passed at all
+  class NoUserCredentialsError < BasicPreferredInfoError; end
+
+  class ProgramLicenseAgreementUpdated < BasicPreferredInfoError
+    def show_github_issues
+      false
+    end
+  end
+
+  class AppleIDAndPrivacyAcknowledgementNeeded < BasicPreferredInfoError
+    def show_github_issues
+      false
+    end
+  end
+
+  # User doesn't have enough permission for given action
+  class InsufficientPermissions < BasicPreferredInfoError
+    TITLE = 'Insufficient permissions for your Apple ID:'.freeze
+
+    def preferred_error_info
+      message ? [TITLE, message] : nil
+    end
+
+    # We don't want to show similar GitHub issues, as the error message
+    # should be pretty clear
+    def show_github_issues
+      false
+    end
+  end
+
+  class UnexpectedResponse < StandardError
+    attr_reader :error_info
+
+    def initialize(error_info = nil)
+      super(error_info)
+      @error_info = error_info
+    end
+
+    def preferred_error_info
+      return nil unless @error_info.kind_of?(Hash) && @error_info['resultString']
+
+      [
+        "Apple provided the following error info:",
+        @error_info['resultString'],
+        @error_info['userString']
+      ].compact.uniq # sometimes 'resultString' and 'userString' are the same value
+    end
+  end
+
+  # Raised when 302 is received from portal request
+  class AppleTimeoutError < BasicPreferredInfoError; end
+
+  # Raised when 401 is received from portal request
+  class UnauthorizedAccessError < BasicPreferredInfoError; end
+
+  # Raised when 500 is received from App Store Connect
+  class InternalServerError < BasicPreferredInfoError; end
+
+  # Raised when 502 is received from App Store Connect
+  class BadGatewayError < BasicPreferredInfoError; end
+
+  # Raised when 504 is received from App Store Connect
+  class GatewayTimeoutError < BasicPreferredInfoError; end
+end

data/spaceship/lib/spaceship/globals.rb

@@ -0,0 +1,12 @@
+module Spaceship
+  class Globals
+    # if spaceship is run with a FastlaneCore available respect the global state there
+    # otherwise fallback to $verbose
+    def self.verbose?
+      if Object.const_defined?("FastlaneCore")
+        return FastlaneCore::Globals.verbose? # rubocop:disable Require/MissingRequireStatement
+      end
+      return $verbose
+    end
+  end
+end

data/spaceship/lib/spaceship/helper/net_http_generic_request.rb

@@ -0,0 +1,14 @@
+require 'net/http'
+
+## monkey-patch Net::HTTP
+#
+# Certain apple endpoints return 415 responses if a Content-Type is supplied.
+# Net::HTTP will default a content-type if none is provided by faraday
+# This monkey-patch allows us to leave out the content-type if we do not specify one.
+module Net
+  class HTTPGenericRequest
+    def supply_default_content_type
+      return if content_type
+    end
+  end
+end