fastlane 2.125.0.beta.20190531200016 → 2.125.0

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

@@ -0,0 +1,56 @@
+require_relative './model'
+module Spaceship
+  module ConnectAPI
+    class BuildBetaDetail
+      include Spaceship::ConnectAPI::Model
+
+      attr_accessor :auto_notify_enabled
+      attr_accessor :did_notify
+      attr_accessor :internal_build_state
+      attr_accessor :external_build_state
+
+      module InternalState
+        PROCESSING_EXCEPTION = "PROCESSING_EXCEPTION"
+        MISSING_EXPORT_COMPLIANCE = "MISSING_EXPORT_COMPLIANCE"
+        READY_FOR_BETA_TESTING = "READY_FOR_BETA_TESTING"
+        IN_BETA_TESTING = "IN_BETA_TESTING"
+        EXPIRED = "EXPIRED"
+        IN_EXPORT_COMPLIANCE_REVIEW = "IN_EXPORT_COMPLIANCE_REVIEW"
+      end
+
+      module ExternalState
+        PROCESSING = "PROCESSING"
+        PROCESSING_EXCEPTION = "PROCESSING_EXCEPTION"
+        MISSING_EXPORT_COMPLIANCE = "MISSING_EXPORT_COMPLIANCE"
+        READY_FOR_BETA_TESTING = "READY_FOR_BETA_TESTING"
+        IN_BETA_TESTING = "IN_BETA_TESTING"
+        EXPIRED = "EXPIRED"
+        READY_FOR_BETA_SUBMISSION = "READY_FOR_BETA_SUBMISSION"
+        IN_EXPORT_COMPLIANCE_REVIEW = "IN_EXPORT_COMPLIANCE_REVIEW"
+        WAITING_FOR_BETA_REVIEW = "WAITING_FOR_BETA_REVIEW"
+        IN_BETA_REVIEW = "IN_BETA_REVIEW"
+        BETA_REJECTED = "BETA_REJECTED"
+        BETA_APPROVED = "BETA_APPROVED"
+      end
+
+      attr_mapping({
+        "autoNotifyEnabled" => "auto_notify_enabled",
+        "didNotify" => "did_notify",
+        "internalBuildState" => "internal_build_state",
+        "externalBuildState" => "external_build_state"
+      })
+
+      def self.type
+        return "buildBetaDetails"
+      end
+
+      #
+      # Helpers
+      #
+
+      def ready_for_beta_submission?
+        return external_build_state == ExternalState::READY_FOR_BETA_SUBMISSION
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative './model'
+module Spaceship
+  module ConnectAPI
+    class BuildDelivery
+      include Spaceship::ConnectAPI::Model
+
+      attr_accessor :cf_build_version
+      attr_accessor :cf_build_short_version_string
+      attr_accessor :platform
+      attr_accessor :uploaded_date
+
+      attr_mapping({
+        "cfBundleVersion" => "cf_build_version",
+        "cfBundleShortVersionString" => "cf_build_short_version_string",
+        "platform" => "platform",
+        "uploadedDate" => "uploaded_date"
+      })
+
+      def self.type
+        return "buildDeliveries"
+      end
+
+      #
+      # API
+      #
+
+      def self.all(app_id: nil, version: nil, build_number: nil)
+        resps = client.get_build_deliveries(
+          filter: { app: app_id, cfBundleShortVersionString: version, cfBundleVersion: build_number },
+          limit: 1
+        ).all_pages
+        return resps.map(&:to_models).flatten
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+require_relative '../base'
+
+module Spaceship
+  module ConnectAPI
+    module Model
+      def self.included(base)
+        Spaceship::ConnectAPI::Models.types ||= []
+        Spaceship::ConnectAPI::Models.types << base
+        base.extend(Spaceship::ConnectAPI::Model)
+        base.extend(Spaceship::ConnectAPI::Model::ClassMethods)
+      end
+
+      module ClassMethods
+        def client
+          return Spaceship::ConnectAPI::Base.client
+        end
+      end
+
+      attr_accessor :id
+
+      def initialize(id, attributes)
+        self.id = id
+        update_attributes(attributes)
+      end
+
+      def update_attributes(attributes)
+        attributes.each do |key, value|
+          method = "#{key}=".to_sym
+          self.send(method, value) if self.respond_to?(method)
+        end
+      end
+
+      def client
+        return Spaceship::ConnectAPI::Base.client
+      end
+
+      #
+      # Example:
+      # { "minOsVersion" => "min_os_version" }
+      #
+      # Creates attr_write and attr_reader for :min_os_version
+      # Creates alias for :minOsVersion to :min_os_version
+      #
+      def attr_mapping(attr_map)
+        attr_map.each do |key, value|
+          # Actual
+          reader = value.to_sym
+          writer = "#{value}=".to_sym
+
+          has_reader = instance_methods.include?(reader)
+          has_writer = instance_methods.include?(writer)
+
+          send(:attr_reader, value) unless has_reader
+          send(:attr_writer, value) unless has_writer
+
+          # Alias
+          key_reader = key.to_sym
+          key_writer = "#{key}=".to_sym
+
+          # Alias the API response name to attribute name
+          alias_method(key_reader, reader)
+          alias_method(key_writer, writer)
+        end
+      end
+    end
+
+    module Models
+      class << self
+        attr_accessor :types
+        attr_accessor :types_cache
+      end
+
+      def self.parse(json)
+        data = json["data"]
+        raise "No data" unless data
+
+        included = json["included"] || []
+
+        if data.kind_of?(Hash)
+          inflate_model(data, included)
+        elsif data.kind_of?(Array)
+          return data.map do |model_data|
+            inflate_model(model_data, included)
+          end
+        else
+          raise "'data' is neither a hash nor an array"
+        end
+      end
+
+      def self.find_class(model_data)
+        # Initialize cache
+        @types_cache ||= {}
+
+        # Find class in cache
+        type_string = model_data["type"]
+        type_class = @types_cache[type_string]
+        return type_class if type_class
+
+        # Find class in array
+        type_class = @types.find do |type|
+          type.type == type_string
+        end
+
+        # Cache and return class
+        @types_cache[type_string] = type_class
+        return type_class
+      end
+
+      def self.inflate_model(model_data, included)
+        # Find class
+        type_class = find_class(model_data)
+        raise "No type class found for #{model_data['type']}" unless type_class
+
+        # Get id and attributes needed for inflating
+        id = model_data["id"]
+        attributes = model_data["attributes"]
+
+        # Instantiate object and inflate relationships
+        relationships = model_data["relationships"] || []
+        type_instance = type_class.new(id, attributes)
+        type_instance = inflate_model_relationships(type_instance, relationships, included)
+
+        return type_instance
+      end
+
+      def self.inflate_model_relationships(type_instance, relationships, included)
+        # Relationship attributes to set
+        attributes = {}
+
+        # 1. Iterate over relationships
+        # 2. Find id and type
+        # 3. Find matching id and type in included
+        # 4. Inflate matching data and set in attributes
+        relationships.each do |key, value|
+          # Validate data exists
+          value_data_or_datas = value["data"]
+          next unless value_data_or_datas
+
+          # Map an included data object
+          map_data = lambda do |value_data|
+            id = value_data["id"]
+            type = value_data["type"]
+
+            relationship_data = included.find do |included_data|
+              id == included_data["id"] && type == included_data["type"]
+            end
+
+            inflate_model(relationship_data, included)
+          end
+
+          # Map a hash or an array of data
+          if value_data_or_datas.kind_of?(Hash)
+            attributes[key] = map_data.call(value_data_or_datas)
+          elsif value_data_or_datas.kind_of?(Array)
+            attributes[key] = value_data_or_datas.map(&map_data)
+          end
+        end
+
+        type_instance.update_attributes(attributes)
+
+        return type_instance
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require_relative './model'
+module Spaceship
+  module ConnectAPI
+    class PreReleaseVersion
+      include Spaceship::ConnectAPI::Model
+
+      attr_accessor :version
+      attr_accessor :platform
+
+      attr_mapping({
+        "version" => "version",
+        "platform" => "platform"
+      })
+
+      def self.type
+        return "preReleaseVersions"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require_relative './model'
+module Spaceship
+  module ConnectAPI
+    class User
+      include Spaceship::ConnectAPI::Model
+
+      attr_accessor :username
+      attr_accessor :first_name
+      attr_accessor :last_name
+      attr_accessor :email
+      attr_accessor :preferred_currency_territory
+      attr_accessor :agreed_to_terms
+      attr_accessor :roles
+      attr_accessor :all_apps_visible
+      attr_accessor :provisioning_allowed
+      attr_accessor :email_vetting_required
+      attr_accessor :notifications
+
+      attr_mapping({
+        "username" => "username",
+        "firstName" => "first_name",
+        "lastName" => "last_name",
+        "email" => "email",
+        "preferredCurrencyTerritory" => "preferred_currency_territory",
+        "agreedToTerms" => "agreed_to_terms",
+        "roles" => "roles",
+        "allAppsVisible" => "all_apps_visible",
+        "provisioningAllowed" => "provisioning_allowed",
+        "emailVettingRequired" => "email_vetting_required",
+        "notifications" => "notifications"
+      })
+
+      def self.type
+        return "users"
+      end
+
+      #
+      # API
+      #
+
+      def self.all(filter: {}, includes: nil, limit: nil, sort: nil)
+        return client.get_users(filter: filter, includes: includes)
+      end
+
+      def self.find(email: nil, includes: nil)
+        return all(filter: { email: email }, includes: includes)
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api/response.rb

@@ -0,0 +1,70 @@
+require_relative './base'
+require_relative './models/model'
+
+module Spaceship
+  module ConnectAPI
+    class Response
+      include Enumerable
+      attr_reader :body
+      attr_reader :status
+
+      def initialize(body: nil, status: nil)
+        @body = body
+        @status = status
+      end
+
+      def client
+        return Spaceship::ConnectAPI::Base.client
+      end
+
+      def next_url
+        return nil if body.nil?
+        links = body["links"] || {}
+        return links["next"]
+      end
+
+      def next_page
+        url = next_url
+        return nil if url.nil?
+        return client.get(url)
+      end
+
+      def next_pages(count: 1)
+        if !count.nil? && count < 0
+          count = 0
+        end
+
+        responses = [self]
+        counter = 0
+
+        resp = self
+        loop do
+          resp = resp.next_page
+          break if resp.nil?
+          responses << resp
+          counter += 1
+
+          break if !count.nil? && counter >= count
+        end
+
+        return responses
+      end
+
+      def all_pages
+        return next_pages(count: nil)
+      end
+
+      def to_models
+        return [] if body.nil?
+        model_or_models = Spaceship::ConnectAPI::Models.parse(body)
+        return [model_or_models].flatten
+      end
+
+      def each(&block)
+        to_models.each do |model|
+          yield(model)
+        end
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api/token.rb

@@ -0,0 +1,44 @@
+require 'jwt'
+require 'openssl'
+
+# extract pem from .p8
+# openssl pkcs8 -topk8 -outform PEM -in AuthKey.p8 -out key.pem -nocrypt
+
+# compute public key
+# openssl ec -in key.pem -pubout -out public_key.pem -aes256
+
+module Spaceship
+  module ConnectAPI
+    class Token
+      # maximum expiration supported by AppStore (20 minutes)
+      MAX_TOKEN_DURATION = 1200
+
+      attr_reader :key_id
+      attr_reader :issuer_id
+      attr_reader :text
+
+      def initialize(key_id: nil, issuer_id: nil, key: nil)
+        @expiration = Time.now + MAX_TOKEN_DURATION
+        @key_id = key_id
+        @key = key
+        @issuer_id = issuer_id
+
+        header = {
+          kid: key_id
+        }
+
+        payload = {
+          iss: issuer_id,
+          exp: @expiration.to_i,
+          aud: 'appstoreconnect-v1'
+        }
+
+        @text = JWT.encode(payload, key, 'ES256', header)
+      end
+
+      def expired?
+        @expiration < Time.now
+      end
+    end
+  end
+end