fastlane-mercafacil 2.214.0

data/spaceship/lib/spaceship/connect_api/provisioning/provisioning.rb

@@ -0,0 +1,264 @@
+require 'spaceship/connect_api/provisioning/client'
+
+module Spaceship
+  class ConnectAPI
+    module Provisioning
+      module API
+        def provisioning_request_client=(provisioning_request_client)
+          @provisioning_request_client = provisioning_request_client
+        end
+
+        def provisioning_request_client
+          return @provisioning_request_client if @provisioning_request_client
+          raise TypeError, "You need to instantiate this module with provisioning_request_client"
+        end
+
+        #
+        # bundleIds
+        #
+
+        def get_bundle_ids(filter: {}, includes: nil, limit: nil, sort: nil)
+          params = provisioning_request_client.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+          provisioning_request_client.get("bundleIds", params)
+        end
+
+        def get_bundle_id(bundle_id_id: {}, includes: nil)
+          params = provisioning_request_client.build_params(filter: nil, includes: includes, limit: nil, sort: nil)
+          provisioning_request_client.get("bundleIds/#{bundle_id_id}", params)
+        end
+
+        def post_bundle_id(name:, platform:, identifier:, seed_id:)
+          attributes = {
+            name: name,
+            platform: platform,
+            identifier: identifier,
+            seedId: seed_id
+          }
+
+          body = {
+            data: {
+              attributes: attributes,
+              type: "bundleIds"
+            }
+          }
+
+          provisioning_request_client.post("bundleIds", body)
+        end
+
+        #
+        # bundleIdCapability
+        #
+
+        def get_bundle_id_capabilities(bundle_id_id:, includes: nil, limit: nil, sort: nil)
+          params = provisioning_request_client.build_params(filter: nil, includes: includes, limit: limit, sort: sort)
+          provisioning_request_client.get("bundleIds/#{bundle_id_id}/bundleIdCapabilities", params)
+        end
+
+        def get_available_bundle_id_capabilities(bundle_id_id:)
+          params = provisioning_request_client.build_params(filter: { bundleId: bundle_id_id })
+          provisioning_request_client.get("capabilities", params)
+        end
+
+        def post_bundle_id_capability(bundle_id_id:, capability_type:, settings: [])
+          body = {
+            data: {
+              attributes: {
+                capabilityType: capability_type,
+                settings: settings
+              },
+              type: "bundleIdCapabilities",
+              relationships: {
+                bundleId: {
+                  data: {
+                    type: "bundleIds",
+                    id: bundle_id_id
+                  }
+                },
+                capability: {
+                  data: {
+                    type: "capabilities",
+                    id: capability_type
+                  }
+                }
+              }
+            }
+          }
+          provisioning_request_client.post("bundleIdCapabilities", body)
+        end
+
+        def patch_bundle_id_capability(bundle_id_id:, seed_id:, enabled: false, capability_type:, settings: [])
+          body = {
+            data: {
+              type: "bundleIds",
+              id: bundle_id_id,
+              attributes: {
+                teamId: seed_id
+              },
+              relationships: {
+                bundleIdCapabilities: {
+                  data: [
+                    {
+                      type: "bundleIdCapabilities",
+                      attributes: {
+                          enabled: enabled,
+                          settings: settings
+                      },
+                      relationships: {
+                        capability: {
+                          data: {
+                              type: "capabilities",
+                              id: capability_type
+                            }
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+
+          provisioning_request_client.patch("bundleIds/#{bundle_id_id}", body)
+        end
+
+        def delete_bundle_id_capability(bundle_id_capability_id:)
+          provisioning_request_client.delete("bundleIdCapabilities/#{bundle_id_capability_id}")
+        end
+
+        #
+        # certificates
+        #
+
+        def get_certificates(profile_id: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+          params = provisioning_request_client.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+          if profile_id.nil?
+            provisioning_request_client.get("certificates", params)
+          else
+            provisioning_request_client.get("profiles/#{profile_id}/certificates", params)
+          end
+        end
+
+        def get_certificate(certificate_id: nil, includes: nil)
+          params = provisioning_request_client.build_params(filter: nil, includes: includes, limit: nil, sort: nil)
+          provisioning_request_client.get("certificates/#{certificate_id}", params)
+        end
+
+        def post_certificate(attributes: {})
+          body = {
+            data: {
+              attributes: attributes,
+              type: "certificates"
+            }
+          }
+
+          provisioning_request_client.post("certificates", body)
+        end
+
+        def delete_certificate(certificate_id: nil)
+          raise "Certificate id is nil" if certificate_id.nil?
+
+          provisioning_request_client.delete("certificates/#{certificate_id}")
+        end
+
+        #
+        # devices
+        #
+
+        def get_devices(profile_id: nil, filter: {}, includes: nil, limit: nil, sort: nil)
+          params = provisioning_request_client.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+          if profile_id.nil?
+            provisioning_request_client.get("devices", params)
+          else
+            provisioning_request_client.get("profiles/#{profile_id}/devices", params)
+          end
+        end
+
+        def post_device(name: nil, platform: nil, udid: nil)
+          attributes = {
+            name: name,
+            platform: platform,
+            udid: udid
+          }
+
+          body = {
+            data: {
+              attributes: attributes,
+              type: "devices"
+            }
+          }
+
+          provisioning_request_client.post("devices", body)
+        end
+
+        def patch_device(id: nil, status: nil, new_name: nil)
+          raise "Device id is nil" if id.nil?
+
+          attributes = {
+            name: new_name,
+            status: status
+          }
+
+          body = {
+            data: {
+              attributes: attributes,
+              id: id,
+              type: "devices"
+            }
+          }
+
+          provisioning_request_client.patch("devices/#{id}", body)
+        end
+
+        #
+        # profiles
+        #
+
+        def get_profiles(filter: {}, includes: nil, limit: nil, sort: nil)
+          params = provisioning_request_client.build_params(filter: filter, includes: includes, limit: limit, sort: sort)
+          provisioning_request_client.get("profiles", params)
+        end
+
+        def post_profiles(bundle_id_id: nil, certificates: nil, devices: nil, attributes: {})
+          body = {
+            data: {
+              attributes: attributes,
+              type: "profiles",
+              relationships: {
+                bundleId: {
+                  data: {
+                    type: "bundleIds",
+                    id: bundle_id_id
+                  }
+                },
+                certificates: {
+                  data: certificates.map do |certificate|
+                    {
+                      type: "certificates",
+                      id: certificate
+                    }
+                  end
+                },
+                devices: {
+                  data: (devices || []).map do |device|
+                    {
+                      type: "devices",
+                      id: device
+                    }
+                  end
+                }
+              }
+            }
+          }
+
+          provisioning_request_client.post("profiles", body)
+        end
+
+        def delete_profile(profile_id: nil)
+          raise "Profile id is nil" if profile_id.nil?
+
+          provisioning_request_client.delete("profiles/#{profile_id}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require_relative './model'
+
+module Spaceship
+  class ConnectAPI
+    class Response
+      include Enumerable
+      attr_reader :body
+      attr_reader :status
+      attr_reader :headers
+      attr_reader :client
+
+      def initialize(body: nil, status: nil, headers: nil, client: nil)
+        @body = body
+        @status = status
+        @headers = headers
+        @client = client
+      end
+
+      def next_url
+        return nil if body.nil?
+        links = body["links"] || {}
+        return links["next"]
+      end
+
+      def next_page(&block)
+        url = next_url
+        return nil if url.nil?
+        if block_given?
+          return yield(url)
+        else
+          return client.get(url)
+        end
+      end
+
+      def next_pages(count: 1, &block)
+        if !count.nil? && count < 0
+          count = 0
+        end
+
+        responses = [self]
+        counter = 0
+
+        resp = self
+        loop do
+          resp = resp.next_page(&block)
+          break if resp.nil?
+          responses << resp
+          counter += 1
+
+          break if !count.nil? && counter >= count
+        end
+
+        return responses
+      end
+
+      def all_pages(&block)
+        return next_pages(count: nil, &block)
+      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
+
+      def all_pages_each(&block)
+        to_models.each do |model|
+          yield(model)
+        end
+
+        resp = self
+        loop do
+          resp = resp.next_page
+          break if resp.nil?
+          resp.each(&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require_relative './client'
+
+require_relative './testflight/testflight'
+
+module Spaceship
+  class ConnectAPI
+    class << self
+      # This client stores the global client when using the lazy syntax
+      attr_accessor :client
+
+      # Forward class calls to the global client
+      # This is implemented for backwards compatibility
+      extend(Forwardable)
+      def_delegators(:client, *Spaceship::ConnectAPI::Provisioning::API.instance_methods(false))
+      def_delegators(:client, *Spaceship::ConnectAPI::TestFlight::API.instance_methods(false))
+      def_delegators(:client, *Spaceship::ConnectAPI::Tunes::API.instance_methods(false))
+      def_delegators(:client, *Spaceship::ConnectAPI::Users::API.instance_methods(false))
+
+      def client
+        # Always look for a client set explicitly by the client first
+        return @client if @client
+
+        # A client may not always be explicitly set (specially when running tools like match, sigh, pilot, etc)
+        # In that case, create a new client based on existing sessions
+        # Note: This does not perform logins on the user. It is only reusing the cookies and selected teams
+        return nil if Spaceship::Tunes.client.nil? && Spaceship::Portal.client.nil?
+
+        implicit_client = ConnectAPI::Client.new(tunes_client: Spaceship::Tunes.client, portal_client: Spaceship::Portal.client)
+        return implicit_client
+      end
+
+      def token=(token)
+        @client = ConnectAPI::Client.new(token: token)
+      end
+
+      def token
+        return nil if @client.nil?
+        return @client.token
+      end
+
+      def token?
+        (@client && @client.token)
+      end
+
+      # Initializes client with Apple's App Store Connect JWT auth key.
+      #
+      # This method will automatically use the arguments from environment
+      # variables if not given.
+      #
+      # The key_id, issuer_id and either filepath or key are needed to authenticate.
+      #
+      # @param key_id (String) (optional): The key id
+      # @param issuer_id (String) (optional): The issuer id
+      # @param filepath (String) (optional): The filepath
+      # @param key (String) (optional): The key
+      # @param duration (Integer) (optional): How long this session should last
+      # @param in_house (Boolean) (optional): Whether this session is an Enterprise one
+      #
+      # @raise InvalidUserCredentialsError: raised if authentication failed
+      #
+      # @return (Spaceship::ConnectAPI::Client) The client the login method was called for
+      def auth(key_id: nil, issuer_id: nil, filepath: nil, key: nil, duration: nil, in_house: nil)
+        @client = ConnectAPI::Client.auth(key_id: key_id, issuer_id: issuer_id, filepath: filepath, key: key, duration: duration, in_house: in_house)
+      end
+
+      # Authenticates with Apple's web services. This method has to be called once
+      # to generate a valid session.
+      #
+      # This method will automatically use the username from the Appfile (if available)
+      # and fetch the password from the Keychain (if available)
+      #
+      # @param user (String) (optional): The username (usually the email address)
+      # @param password (String) (optional): The password
+      # @param use_portal (Boolean) (optional): Whether to log in to Spaceship::Portal or not
+      # @param use_tunes (Boolean) (optional): Whether to log in to Spaceship::Tunes or not
+      # @param portal_team_id (String) (optional): The Spaceship::Portal team id
+      # @param tunes_team_id (String) (optional): The Spaceship::Tunes team id
+      # @param team_name (String) (optional): The team name
+      # @param skip_select_team (Boolean) (optional): Whether to skip automatic selection or prompt for team
+      #
+      # @raise InvalidUserCredentialsError: raised if authentication failed
+      #
+      # @return (Spaceship::ConnectAPI::Client) The client the login method was called for
+      def login(user = nil, password = nil, use_portal: true, use_tunes: true, portal_team_id: nil, tunes_team_id: nil, team_name: nil, skip_select_team: false)
+        @client = ConnectAPI::Client.login(user, password, use_portal: use_portal, use_tunes: use_tunes, portal_team_id: portal_team_id, tunes_team_id: tunes_team_id, team_name: team_name, skip_select_team: skip_select_team)
+      end
+
+      # Open up the team selection for the user (if necessary).
+      #
+      # If the user is in multiple teams, a team selection is shown.
+      # The user can then select a team by entering the number
+      #
+      # @param portal_team_id (String) (optional): The Spaceship::Portal team id
+      # @param tunes_team_id (String) (optional): The Spaceship::Tunes team id
+      # @param team_name (String) (optional): The name of an App Store Connect team
+      def select_team(portal_team_id: nil, tunes_team_id: nil, team_name: nil)
+        return if client.nil?
+        client.select_team(portal_team_id: portal_team_id, tunes_team_id: tunes_team_id, team_name: team_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require_relative '../api_client'
+require_relative './testflight'
+require_relative '../../tunes/tunes_client'
+
+module Spaceship
+  class ConnectAPI
+    module TestFlight
+      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::TestFlight::API)
+          self.test_flight_request_client = self
+        end
+
+        def self.hostname
+          'https://appstoreconnect.apple.com/iris/v1/'
+        end
+      end
+    end
+  end
+end