fastlane 2.217.0 → 2.219.0

data/match/lib/match/module.rb

@@ -23,7 +23,8 @@ module Match
   end
 
   def self.cert_type_sym(type)
-    type = type.to_s
+    # To determine certificate types to fetch from the portal, we use `Sigh.certificate_types_for_profile_and_platform`, and it returns typed `Spaceship::ConnectAPI::Certificate::CertificateType` with the same values but uppercased, so we downcase them here
+    type = type.to_s.downcase
     return :mac_installer_distribution if type == "mac_installer_distribution"
     return :developer_id_installer if type == "developer_id_installer"
     return :developer_id_application if type == "developer_id"

data/match/lib/match/portal_cache.rb

@@ -0,0 +1,106 @@
+require 'fastlane_core/provisioning_profile'
+require 'spaceship/client'
+require_relative 'portal_fetcher'
+module Match
+  class Portal
+    class Cache
+      def self.build(params:, bundle_id_identifiers:)
+        require_relative 'profile_includes'
+        require 'sigh'
+
+        profile_type = Sigh.profile_type_for_distribution_type(
+          platform: params[:platform],
+          distribution_type: params[:type]
+        )
+
+        cache = Portal::Cache.new(
+          platform: params[:platform],
+          profile_type: profile_type,
+          additional_cert_types: params[:additional_cert_types],
+          bundle_id_identifiers: bundle_id_identifiers,
+          needs_profiles_devices: ProfileIncludes.can_force_include_all_devices?(params: params, notify: true),
+          needs_profiles_certificate_content: !ProfileIncludes.can_force_include_all_certificates?(params: params, notify: true),
+          include_mac_in_profiles: params[:include_mac_in_profiles]
+        )
+
+        return cache
+      end
+
+      attr_reader :platform, :profile_type, :bundle_id_identifiers, :additional_cert_types, :needs_profiles_devices, :needs_profiles_certificate_content, :include_mac_in_profiles
+
+      def initialize(platform:, profile_type:, additional_cert_types:, bundle_id_identifiers:, needs_profiles_devices:, needs_profiles_certificate_content:, include_mac_in_profiles:)
+        @platform = platform
+        @profile_type = profile_type
+
+        # Bundle Ids
+        @bundle_id_identifiers = bundle_id_identifiers
+
+        # Certs
+        @additional_cert_types = additional_cert_types
+
+        # Profiles
+        @needs_profiles_devices = needs_profiles_devices
+        @needs_profiles_certificate_content = needs_profiles_certificate_content
+
+        # Devices
+        @include_mac_in_profiles = include_mac_in_profiles
+      end
+
+      def portal_profile(stored_profile_path:, keychain_path:)
+        parsed = FastlaneCore::ProvisioningProfile.parse(stored_profile_path, keychain_path)
+        uuid = parsed["UUID"]
+
+        portal_profile = self.profiles.detect { |i| i.uuid == uuid }
+
+        portal_profile
+      end
+
+      def reset_certificates
+        @certificates = nil
+      end
+
+      def forget_portal_profile(portal_profile)
+        return unless @profiles && portal_profile
+
+        @profiles -= [portal_profile]
+      end
+
+      def bundle_ids
+        @bundle_ids ||= Match::Portal::Fetcher.bundle_ids(
+          bundle_id_identifiers: @bundle_id_identifiers
+        )
+
+        return @bundle_ids.dup
+      end
+
+      def certificates
+        @certificates ||= Match::Portal::Fetcher.certificates(
+          platform: @platform,
+          profile_type: @profile_type,
+          additional_cert_types: @additional_cert_types
+        )
+
+        return @certificates.dup
+      end
+
+      def profiles
+        @profiles ||= Match::Portal::Fetcher.profiles(
+          profile_type: @profile_type,
+          needs_profiles_devices: @needs_profiles_devices,
+          needs_profiles_certificate_content: @needs_profiles_certificate_content
+        )
+
+        return @profiles.dup
+      end
+
+      def devices
+        @devices ||= Match::Portal::Fetcher.devices(
+          platform: @platform,
+          include_mac_in_profiles: @include_mac_in_profiles
+        )
+
+        return @devices.dup
+      end
+    end
+  end
+end

data/match/lib/match/portal_fetcher.rb

@@ -0,0 +1,72 @@
+require 'fastlane_core/provisioning_profile'
+require 'spaceship/client'
+require 'spaceship/connect_api/models/profile'
+
+module Match
+  class Portal
+    module Fetcher
+      def self.profiles(profile_type:, needs_profiles_devices: false, needs_profiles_certificate_content: false, name: nil)
+        includes = ['bundleId']
+
+        if needs_profiles_devices
+          includes += ['devices', 'certificates']
+        end
+
+        if needs_profiles_certificate_content
+          includes += ['certificates']
+        end
+
+        profiles = Spaceship::ConnectAPI::Profile.all(
+          filter: { profileType: profile_type, name: name }.compact,
+          includes: includes.uniq.join(',')
+        )
+
+        profiles
+      end
+
+      def self.certificates(platform:, profile_type:, additional_cert_types:)
+        require 'sigh'
+        certificate_types = Sigh.certificate_types_for_profile_and_platform(platform: platform, profile_type: profile_type)
+
+        additional_cert_types ||= []
+        additional_cert_types.map! do |cert_type|
+          case Match.cert_type_sym(cert_type)
+          when :mac_installer_distribution
+            Spaceship::ConnectAPI::Certificate::CertificateType::MAC_INSTALLER_DISTRIBUTION
+          when :developer_id_installer
+            Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPER_ID_INSTALLER
+          end
+        end
+
+        certificate_types += additional_cert_types
+
+        filter = { certificateType: certificate_types.uniq.sort.join(',') } unless certificate_types.empty?
+
+        certificates = Spaceship::ConnectAPI::Certificate.all(
+          filter: filter
+        ).select(&:valid?)
+
+        certificates
+      end
+
+      def self.devices(platform: nil, include_mac_in_profiles: false)
+        devices = Spaceship::ConnectAPI::Device.devices_for_platform(
+          platform: platform,
+          include_mac_in_profiles: include_mac_in_profiles
+        )
+
+        devices
+      end
+
+      def self.bundle_ids(bundle_id_identifiers: nil)
+        filter = { identifier: bundle_id_identifiers.join(',') } if bundle_id_identifiers
+
+        bundle_ids = Spaceship::ConnectAPI::BundleId.all(
+          filter: filter
+        )
+
+        bundle_ids
+      end
+    end
+  end
+end

data/match/lib/match/profile_includes.rb

@@ -0,0 +1,120 @@
+require_relative 'portal_fetcher'
+require_relative 'module'
+
+module Match
+  class ProfileIncludes
+    PROV_TYPES_WITH_DEVICES = [:adhoc, :development]
+    PROV_TYPES_WITH_MULTIPLE_CERTIFICATES = [:development]
+
+    def self.can_force_include?(params:, notify:)
+      self.can_force_include_all_devices?(params: params, notify: notify) &&
+        self.can_force_include_all_certificates?(params: params, notify: notify)
+    end
+
+    ###############
+    #
+    # DEVICES
+    #
+    ###############
+
+    def self.should_force_include_all_devices?(params:, portal_profile:, cached_devices:)
+      return false unless self.can_force_include_all_devices?(params: params)
+
+      force = devices_differ?(portal_profile: portal_profile, platform: params[:platform], include_mac_in_profiles: params[:include_mac_in_profiles], cached_devices: cached_devices)
+
+      return force
+    end
+
+    def self.can_force_include_all_devices?(params:, notify: false)
+      return false if params[:readonly] || params[:force]
+      return false unless params[:force_for_new_devices]
+
+      provisioning_type = params[:type].to_sym
+
+      can_force = PROV_TYPES_WITH_DEVICES.include?(provisioning_type)
+
+      if !can_force && notify
+        # App Store provisioning profiles don't contain device identifiers and
+        # thus shouldn't be renewed if the device count has changed.
+        UI.important("Warning: `force_for_new_devices` is set but is ignored for #{provisioning_type}.")
+        UI.important("You can safely stop specifying `force_for_new_devices` when running Match for type '#{provisioning_type}'.")
+      end
+
+      can_force
+    end
+
+    def self.devices_differ?(portal_profile:, platform:, include_mac_in_profiles:, cached_devices:)
+      return false unless portal_profile
+
+      profile_devices = portal_profile.devices || []
+
+      portal_devices = cached_devices
+      portal_devices ||= Match::Portal::Fetcher.devices(platform: platform, include_mac_in_profiles: include_mac_in_profiles)
+
+      profile_device_ids = profile_devices.map(&:id).sort
+      portal_devices_ids = portal_devices.map(&:id).sort
+
+      devices_differs = profile_device_ids != portal_devices_ids
+
+      UI.important("Devices in the profile and available on the portal differ. Recreating a profile") if devices_differs
+
+      return devices_differs
+    end
+
+    ###############
+    #
+    # CERTIFICATES
+    #
+    ###############
+
+    def self.should_force_include_all_certificates?(params:, portal_profile:, cached_certificates:)
+      return false unless self.can_force_include_all_certificates?(params: params)
+
+      force = certificates_differ?(portal_profile: portal_profile, platform: params[:platform], cached_certificates: cached_certificates)
+
+      return force
+    end
+
+    def self.can_force_include_all_certificates?(params:, notify: false)
+      return false if params[:readonly] || params[:force]
+      return false unless params[:force_for_new_certificates]
+
+      unless params[:include_all_certificates]
+        UI.important("You specified 'force_for_new_certificates: true', but new certificates will not be added, cause 'include_all_certificates' is 'false'") if notify
+        return false
+      end
+
+      provisioning_type = params[:type].to_sym
+
+      can_force = PROV_TYPES_WITH_MULTIPLE_CERTIFICATES.include?(provisioning_type)
+
+      if !can_force && notify
+        # All other (not development) provisioning profiles don't contain
+        # multiple certificates, thus shouldn't be renewed
+        # if the certificates  count has changed.
+        UI.important("Warning: `force_for_new_certificates` is set but is ignored for non-'development' provisioning profiles.")
+        UI.important("You can safely stop specifying `force_for_new_certificates` when running Match for '#{provisioning_type}' provisioning profiles.")
+      end
+
+      can_force
+    end
+
+    def self.certificates_differ?(portal_profile:, platform:, cached_certificates:)
+      return false unless portal_profile
+
+      profile_certs = portal_profile.certificates || []
+
+      portal_certs = cached_certificates
+      portal_certs ||= Match::Portal::Fetcher.certificates(platform: platform, profile_type: portal_profile.profile_type)
+
+      profile_certs_ids = profile_certs.map(&:id).sort
+      portal_certs_ids = portal_certs.map(&:id).sort
+
+      certificates_differ = profile_certs_ids != portal_certs_ids
+
+      UI.important("Certificates in the profile and available on the portal differ. Recreating a profile") if certificates_differ
+
+      return certificates_differ
+    end
+  end
+end

data/match/lib/match/runner.rb

@@ -2,6 +2,8 @@ require 'fastlane_core/cert_checker'
 require 'fastlane_core/provisioning_profile'
 require 'fastlane_core/print_table'
 require 'spaceship/client'
+require 'sigh/module'
+
 require_relative 'generator'
 require_relative 'module'
 require_relative 'table_printer'
@@ -10,6 +12,8 @@ require_relative 'utils'
 
 require_relative 'storage'
 require_relative 'encryption'
+require_relative 'profile_includes'
+require_relative 'portal_cache'
 
 module Match
   # rubocop:disable Metrics/ClassLength
@@ -19,6 +23,8 @@ module Match
 
     attr_accessor :storage
 
+    attr_accessor :cache
+
     # rubocop:disable Metrics/PerceivedComplexity
     def run(params)
       self.files_to_commit = []
@@ -60,12 +66,18 @@ module Match
 
       # sometimes we get an array with arrays, this is a bug. To unblock people using match, I suggest we flatten
       # then in the future address the root cause of https://github.com/fastlane/fastlane/issues/11324
-      app_identifiers = app_identifiers.flatten
+      app_identifiers = app_identifiers.flatten.uniq
 
-      # Verify the App ID (as we don't want 'match' to fail at a later point)
       if spaceship
+        # Cache bundle ids, certificates, profiles, and devices.
+        self.cache = Portal::Cache.build(
+          params: params,
+          bundle_id_identifiers: app_identifiers
+        )
+
+        # Verify the App ID (as we don't want 'match' to fail at a later point)
         app_identifiers.each do |app_identifier|
-          spaceship.bundle_identifier_exists(username: params[:username], app_identifier: app_identifier, platform: params[:platform])
+          spaceship.bundle_identifier_exists(username: params[:username], app_identifier: app_identifier, cached_bundle_ids: self.cache.bundle_ids)
         end
       end
 
@@ -78,17 +90,24 @@ module Match
         fetch_certificate(params: params, working_directory: storage.working_directory, specific_cert_type: additional_cert_type)
       end
 
+      profile_type = Sigh.profile_type_for_distribution_type(
+        platform: params[:platform],
+        distribution_type: params[:type]
+      )
+
       cert_ids << cert_id
-      spaceship.certificates_exists(username: params[:username], certificate_ids: cert_ids) if spaceship
+      spaceship.certificates_exists(username: params[:username], certificate_ids: cert_ids, platform: params[:platform], profile_type: profile_type, cached_certificates: self.cache.certificates) if spaceship
 
       # Provisioning Profiles
+
       unless params[:skip_provisioning_profiles]
         app_identifiers.each do |app_identifier|
           loop do
             break if fetch_provisioning_profile(params: params,
+                                          profile_type: profile_type,
                                         certificate_id: cert_id,
                                         app_identifier: app_identifier,
-                                    working_directory: storage.working_directory)
+                                     working_directory: storage.working_directory)
           end
         end
       end
@@ -141,12 +160,15 @@ module Match
 
       if certs.count == 0 || keys.count == 0
         UI.important("Couldn't find a valid code signing identity for #{cert_type}... creating one for you now")
-        UI.crash!("No code signing identity found and can not create a new one because you enabled `readonly`") if params[:readonly]
+        UI.crash!("No code signing identity found and cannot create a new one because you enabled `readonly`") if params[:readonly]
         cert_path = Generator.generate_certificate(params, cert_type, prefixed_working_directory, specific_cert_type: specific_cert_type)
         private_key_path = cert_path.gsub(".cer", ".p12")
 
         self.files_to_commit << cert_path
         self.files_to_commit << private_key_path
+
+        # Reset certificates cache since we have a new cert.
+        self.cache.reset_certificates
       else
         cert_path = select_cert_or_key(paths: certs)
 
@@ -199,7 +221,7 @@ module Match
 
     # rubocop:disable Metrics/PerceivedComplexity
     # @return [String] The UUID of the provisioning profile so we can verify it with the Apple Developer Portal
-    def fetch_provisioning_profile(params: nil, certificate_id: nil, app_identifier: nil, working_directory: nil)
+    def fetch_provisioning_profile(params: nil, profile_type:, certificate_id: nil, app_identifier: nil, working_directory: nil)
       prov_type = Match.profile_type_sym(params[:type])
 
       names = [Match::Generator.profile_type_name(prov_type), app_identifier]
@@ -222,20 +244,26 @@ module Match
       end
 
       # Install the provisioning profiles
-      profile = profiles.last
+      stored_profile_path = profiles.last
       force = params[:force]
 
-      if params[:force_for_new_devices]
-        force = should_force_include_all_devices(params: params, prov_type: prov_type, profile: profile, keychain_path: keychain_path) unless force
-      end
+      if spaceship
+        # check if profile needs to be updated only if not in readonly mode
+        portal_profile = self.cache.portal_profile(stored_profile_path: stored_profile_path, keychain_path: keychain_path) if stored_profile_path
 
-      if params[:include_all_certificates]
-        # Clearing specified certificate id which will prevent a profile being created with only one certificate
-        certificate_id = nil
-        force = should_force_include_all_certificates(params: params, prov_type: prov_type, profile: profile, keychain_path: keychain_path) unless force
+        if params[:force_for_new_devices]
+          force ||= ProfileIncludes.should_force_include_all_devices?(params: params, portal_profile: portal_profile, cached_devices: self.cache.devices)
+        end
+
+        if params[:include_all_certificates]
+          # Clearing specified certificate id which will prevent a profile being created with only one certificate
+          certificate_id = nil
+          force ||= ProfileIncludes.should_force_include_all_certificates?(params: params, portal_profile: portal_profile, cached_certificates: self.cache.certificates)
+        end
       end
 
-      if profile.nil? || force
+      is_new_profile_created = false
+      if stored_profile_path.nil? || force
         if params[:readonly]
           UI.error("No matching provisioning profiles found for '#{profile_file}'")
           UI.error("A new one cannot be created because you enabled `readonly`")
@@ -245,38 +273,53 @@ module Match
             all_profiles.each { |p| UI.error("- '#{p}'") }
           end
           UI.error("If you are certain that a profile should exist, double-check the recent changes to your match repository")
-          UI.user_error!("No matching provisioning profiles found and can not create a new one because you enabled `readonly`. Check the output above for more information.")
+          UI.user_error!("No matching provisioning profiles found and cannot create a new one because you enabled `readonly`. Check the output above for more information.")
         end
 
-        profile = Generator.generate_provisioning_profile(params: params,
-                                                       prov_type: prov_type,
-                                                  certificate_id: certificate_id,
-                                                  app_identifier: app_identifier,
-                                                           force: force,
-                                               working_directory: prefixed_working_directory)
-        self.files_to_commit << profile
-      end
+        stored_profile_path = Generator.generate_provisioning_profile(
+          params: params,
+          prov_type: prov_type,
+          certificate_id: certificate_id,
+          app_identifier: app_identifier,
+          force: force,
+          cache: self.cache,
+          working_directory: prefixed_working_directory
+        )
 
-      if Helper.mac?
-        installed_profile = FastlaneCore::ProvisioningProfile.install(profile, keychain_path)
+        # Recreation of the profile means old profile is invalid.
+        # Removing it from cache. We don't need a new profile in cache.
+        self.cache.forget_portal_profile(portal_profile) if portal_profile
+
+        self.files_to_commit << stored_profile_path
+
+        is_new_profile_created = true
       end
-      parsed = FastlaneCore::ProvisioningProfile.parse(profile, keychain_path)
+
+      parsed = FastlaneCore::ProvisioningProfile.parse(stored_profile_path, keychain_path)
       uuid = parsed["UUID"]
+      name = parsed["Name"]
 
-      if params[:output_path]
-        FileUtils.cp(profile, params[:output_path])
-      end
+      check_profile_existence = !is_new_profile_created && spaceship
+      if check_profile_existence && !spaceship.profile_exists(profile_type: profile_type,
+                                                              name: name,
+                                                              username: params[:username],
+                                                              uuid: uuid,
+                                                              cached_profiles: self.cache.profiles)
 
-      if spaceship && !spaceship.profile_exists(type: prov_type,
-                                                username: params[:username],
-                                                uuid: uuid,
-                                                platform: params[:platform])
         # This profile is invalid, let's remove the local file and generate a new one
-        File.delete(profile)
+        File.delete(stored_profile_path)
         # This method will be called again, no need to modify `files_to_commit`
         return nil
       end
 
+      if Helper.mac?
+        installed_profile = FastlaneCore::ProvisioningProfile.install(stored_profile_path, keychain_path)
+      end
+
+      if params[:output_path]
+        FileUtils.cp(stored_profile_path, params[:output_path])
+      end
+
       Utils.fill_environment(Utils.environment_variable_name(app_identifier: app_identifier,
                                                                        type: prov_type,
                                                                    platform: params[:platform]),
@@ -308,145 +351,6 @@ module Match
       return uuid
     end
     # rubocop:enable Metrics/PerceivedComplexity
-
-    def should_force_include_all_devices(params: nil, prov_type: nil, profile: nil, keychain_path: nil)
-      return false unless params[:force_for_new_devices] && !params[:readonly]
-
-      force = false
-
-      prov_types_without_devices = [:appstore, :developer_id]
-      if !prov_types_without_devices.include?(prov_type) && !params[:force]
-        force = device_count_different?(profile: profile, keychain_path: keychain_path, platform: params[:platform].to_sym, include_mac_in_profiles: params[:include_mac_in_profiles])
-      else
-        # App Store provisioning profiles don't contain device identifiers and
-        # thus shouldn't be renewed if the device count has changed.
-        UI.important("Warning: `force_for_new_devices` is set but is ignored for App Store & Developer ID provisioning profiles.")
-        UI.important("You can safely stop specifying `force_for_new_devices` when running Match for type 'appstore' or 'developer_id'.")
-      end
-
-      return force
-    end
-
-    def device_count_different?(profile: nil, keychain_path: nil, platform: nil, include_mac_in_profiles: false)
-      return false unless profile
-
-      parsed = FastlaneCore::ProvisioningProfile.parse(profile, keychain_path)
-      uuid = parsed["UUID"]
-
-      all_profiles = Spaceship::ConnectAPI::Profile.all(includes: "devices")
-      portal_profile = all_profiles.detect { |i| i.uuid == uuid }
-
-      if portal_profile
-        profile_device_count = portal_profile.devices.count
-
-        device_classes =
-          case platform
-          when :ios
-            [
-              Spaceship::ConnectAPI::Device::DeviceClass::IPAD,
-              Spaceship::ConnectAPI::Device::DeviceClass::IPHONE,
-              Spaceship::ConnectAPI::Device::DeviceClass::IPOD,
-              Spaceship::ConnectAPI::Device::DeviceClass::APPLE_WATCH
-            ]
-          when :tvos
-            [
-              Spaceship::ConnectAPI::Device::DeviceClass::APPLE_TV
-            ]
-          when :macos, :catalyst
-            [
-              Spaceship::ConnectAPI::Device::DeviceClass::MAC
-            ]
-          else
-            []
-          end
-        if platform == :ios && include_mac_in_profiles
-          device_classes += [Spaceship::ConnectAPI::Device::DeviceClass::APPLE_SILICON_MAC]
-        end
-
-        devices = Spaceship::ConnectAPI::Device.all
-        unless device_classes.empty?
-          devices = devices.select do |device|
-            device_classes.include?(device.device_class) && device.enabled?
-          end
-        end
-
-        portal_device_count = devices.size
-
-        return portal_device_count != profile_device_count
-      end
-      return false
-    end
-
-    def should_force_include_all_certificates(params: nil, prov_type: nil, profile: nil, keychain_path: nil)
-      unless params[:include_all_certificates]
-        if params[:force_for_new_certificates]
-          UI.important("You specified 'force_for_new_certificates: true', but new certificates will not be added, cause 'include_all_certificates' is 'false'")
-        end
-        return false
-      end
-
-      force = false
-
-      if params[:force_for_new_certificates] && !params[:readonly]
-        if prov_type == :development && !params[:force]
-          force = certificate_count_different?(profile: profile, keychain_path: keychain_path, platform: params[:platform].to_sym)
-        else
-          # All other (not development) provisioning profiles don't contain
-          # multiple certificates, thus shouldn't be renewed
-          # if the certificates  count has changed.
-          UI.important("Warning: `force_for_new_certificates` is set but is ignored for non-'development' provisioning profiles.")
-          UI.important("You can safely stop specifying `force_for_new_certificates` when running Match for '#{prov_type}' provisioning profiles.")
-        end
-      end
-
-      return force
-    end
-
-    def certificate_count_different?(profile: nil, keychain_path: nil, platform: nil)
-      return false unless profile
-
-      parsed = FastlaneCore::ProvisioningProfile.parse(profile, keychain_path)
-      uuid = parsed["UUID"]
-
-      all_profiles = Spaceship::ConnectAPI::Profile.all(includes: "certificates")
-      portal_profile = all_profiles.detect { |i| i.uuid == uuid }
-
-      return false unless portal_profile
-
-      # When a certificate expires (not revoked) provisioning profile stays valid.
-      # And if we regenerate certificate count will not differ:
-      #   * For portal certificates, we filter out the expired one but includes a new certificate;
-      #   * Profile still contains an expired certificate and is valid.
-      # Thus, we need to check the validity of profile certificates too.
-      profile_certs_count = portal_profile.certificates.select(&:valid?).count
-
-      certificate_types =
-        case platform
-        when :ios, :tvos
-          [
-            Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPMENT,
-            Spaceship::ConnectAPI::Certificate::CertificateType::IOS_DEVELOPMENT
-          ]
-        when :macos, :catalyst
-          [
-            Spaceship::ConnectAPI::Certificate::CertificateType::DEVELOPMENT,
-            Spaceship::ConnectAPI::Certificate::CertificateType::MAC_APP_DEVELOPMENT
-          ]
-        else
-          []
-        end
-
-      certificates = Spaceship::ConnectAPI::Certificate.all
-      unless certificate_types.empty?
-        certificates = certificates.select do |certificate|
-          certificate_types.include?(certificate.certificateType) && certificate.valid?
-        end
-      end
-
-      portal_certs_count = certificates.size
-
-      return portal_certs_count != profile_certs_count
-    end
   end
   # rubocop:enable Metrics/ClassLength
 end