fastlane-plugin-firebase_app_distribution 0.1.3 → 0.2.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 839bb3358367db7178eed367005e3ede2a7b5073f25924ea71c96120afdfcbc2
-  data.tar.gz: 4f0316d47fe8c3d0027cb24cc6389448c6e2372dd8413d83c4d6d0f49e7ff3a0
+  metadata.gz: b38b7e0efb3d03f71b9e4476b15304f9ffcddb75cd936acad55f16886222e458
+  data.tar.gz: '00228e7a41e3d55c4f0271ebbd5bd0aff4a699ec192b8e5e246a7dd271b9b5f3'
 SHA512:
-  metadata.gz: 38eb5236916ab973cda79be4442dfcfe62faacf3915cf8875131bf4ae703085a30d65e17c3c765e6c53b6adfc66db14e2075d4538549dd68e74ed9342c1830e3
-  data.tar.gz: 5382e2ddbe0081c20435d009826be4a83256aa65c93e48c34b2047f0bd38d074f44360b8939a45daef75546a06a3003259d6f73453ad8ff7f694af2ee6b55290
+  metadata.gz: 64478454789d88e5abdb0b8084e53b6e0d4320315073e59a3a5d789f2a7dde8adb34d79ca102148292977d763148645ad7b15ea2d8caeb21369a8932b9fd4f1e
+  data.tar.gz: ec77eb9cd77d44ebd4a3f3c6c89a5b3c37f3fc96a2c7bf8fa4ed227cbbca14b5c979583a75d555f2eba25912989d76672e9792eb0fe48cd18b63c56c7fc4b555

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_action.rb

@@ -1,39 +1,56 @@
-require 'tempfile'
 require 'fastlane/action'
 require 'open3'
 require 'shellwords'
+require 'googleauth'
+require_relative '../helper/upload_status_response'
 require_relative '../helper/firebase_app_distribution_helper'
+require_relative '../helper/firebase_app_distribution_error_message'
+require_relative '../client/firebase_app_distribution_api_client'
+require_relative '../helper/firebase_app_distribution_auth_client'
 
 ## TODO: should always use a file underneath? I think so.
 ## How should we document the usage of release notes?
 module Fastlane
   module Actions
     class FirebaseAppDistributionAction < Action
-      DEFAULT_FIREBASE_CLI_PATH = `which firebase`
       FIREBASECMD_ACTION = "appdistribution:distribute".freeze
 
+      extend Auth::FirebaseAppDistributionAuthClient
       extend Helper::FirebaseAppDistributionHelper
 
       def self.run(params)
         params.values # to validate all inputs before looking for the ipa/apk
-        cmd = [params[:firebase_cli_path].chomp, FIREBASECMD_ACTION]
-        cmd << Shellwords.escape(params[:ipa_path] || params[:apk_path])
-        cmd << "--app #{params[:app]}"
-
-        cmd << groups_flag(params)
-        cmd << testers_flag(params)
-        cmd << release_notes_flag(params)
-        cmd << flag_value_if_supplied('--token', :firebase_cli_token, params)
-        cmd << flag_if_supplied('--debug', :debug, params)
-
-        Actions.sh_control_output(
-          cmd.compact.join(" "),
-          print_command: false,
-          print_command_output: true
-        )
-      # make sure we do this, even in the case of an error.
-      ensure
-        cleanup_tempfiles
+        auth_token = fetch_auth_token(params[:service_credentials_file], params[:firebase_cli_token])
+        binary_path = params[:ipa_path] || params[:apk_path]
+        platform = lane_platform || platform_from_path(binary_path)
+        fad_api_client = Client::FirebaseAppDistributionApiClient.new(auth_token, platform)
+
+        if params[:app] # Set app_id if it is specified as a parameter
+          app_id = params[:app]
+        elsif platform == :ios
+          archive_path = Actions.lane_context[SharedValues::XCODEBUILD_ARCHIVE]
+          if archive_path
+            app_id = get_ios_app_id_from_archive(archive_path)
+          end
+        end
+
+        if app_id.nil?
+          UI.crash!(ErrorMessage::MISSING_APP_ID)
+        end
+        release_id = fad_api_client.upload(app_id, binary_path, platform.to_s)
+        if release_id.nil?
+          return
+        end
+
+        release_notes = get_value_from_value_or_file(params[:release_notes], params[:release_notes_file])
+        fad_api_client.post_notes(app_id, release_id, release_notes)
+
+        testers = get_value_from_value_or_file(params[:testers], params[:testers_file])
+        groups = get_value_from_value_or_file(params[:groups], params[:groups_file])
+        emails = string_to_array(testers)
+        group_ids = string_to_array(groups)
+        fad_api_client.enable_access(app_id, release_id, emails, group_ids)
+        UI.success("🎉 App Distribution upload finished successfully.")
       end
 
       def self.description
@@ -41,7 +58,7 @@ module Fastlane
       end
 
       def self.authors
-        ["Stefan Natchev"]
+        ["Stefan Natchev", "Manny Jimenez Github: mannyjimenez0810, Alonso Salas Infante Github: alonsosalasinfante"]
       end
 
       # supports markdown.
@@ -49,14 +66,26 @@ module Fastlane
         "Release your beta builds with Firebase App Distribution"
       end
 
-      def self.available_options
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+      def self.lane_platform
+        Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+      end
+
+      def self.platform_from_path(binary_path)
+        return nil unless binary_path
+        case binary_path.split('.').last
+        when 'ipa'
+          :ios
+        when 'apk'
+          :android
+        end
+      end
 
-        if platform == :ios || platform.nil?
+      def self.available_options
+        if lane_platform == :ios || lane_platform.nil?
           ipa_path_default = Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
         end
 
-        if platform == :android
+        if lane_platform == :android
           apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
         end
 
@@ -84,25 +113,13 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :app,
                                        env_name: "FIREBASEAPPDISTRO_APP",
                                        description: "Your app's Firebase App ID. You can find the App ID in the Firebase console, on the General Settings page",
-                                       optional: false,
+                                       optional: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :firebase_cli_path,
+                                       deprecated: "This plugin no longer uses the Firebase CLI",
                                        env_name: "FIREBASEAPPDISTRO_FIREBASE_CLI_PATH",
                                        description: "The absolute path of the firebase cli command",
-                                       default_value: DEFAULT_FIREBASE_CLI_PATH,
-                                       default_value_dynamic: true,
-                                       optional: false,
-                                       type: String,
-                                       verify_block: proc do |value|
-                                         value.chomp!
-                                         if value.to_s == "" || !File.exist?(value)
-                                           UI.user_error!("firebase_cli_path: missing path to firebase cli tool. Please install firebase in $PATH or specify path")
-                                         end
-
-                                         unless is_firebasecmd_supported?(value)
-                                           UI.user_error!("firebase_cli_path: `#{value}` does not support the `#{FIREBASECMD_ACTION}` command. Please download (https://appdistro.page.link/firebase-cli-download) or specify the path to the correct version of firebse")
-                                         end
-                                       end),
+                                       type: String),
           FastlaneCore::ConfigItem.new(key: :groups,
                                        env_name: "FIREBASEAPPDISTRO_GROUPS",
                                        description: "The groups used for distribution, separated by commas",
@@ -143,7 +160,11 @@ module Fastlane
                                        description: "Print verbose debug output",
                                        optional: true,
                                        default_value: false,
-                                       is_string: false)
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :service_credentials_file,
+                                       description: "Path to Google service account json",
+                                       optional: true,
+                                       type: String)
         ]
       end
 
@@ -165,18 +186,6 @@ module Fastlane
           CODE
         ]
       end
-
-      ## TODO: figure out if we can surpress color output.
-      def self.is_firebasecmd_supported?(cmd)
-        outerr, status = Open3.capture2e(cmd, "--non-interactive", FIREBASECMD_ACTION, "--help")
-        return false unless status.success?
-
-        if outerr =~ /is not a Firebase command/
-          return false
-        end
-
-        true
-      end
     end
   end
 end

data/lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_login.rb

@@ -0,0 +1,58 @@
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require "google/apis/people_v1"
+require "fileutils"
+
+module Fastlane
+  module Actions
+    class FirebaseAppDistributionLoginAction < Action
+      OOB_URI = "urn:ietf:wg:oauth:2.0:oob"
+      SCOPE = "https://www.googleapis.com/auth/cloud-platform"
+      CLIENT_ID = "563584335869-fgrhgmd47bqnekij5i8b5pr03ho849e6.apps.googleusercontent.com"
+      CLIENT_SECRET = "j9iVZfS8kkCEFUPaAeJV0sAi"
+
+      def self.run(params)
+        client_id = Google::Auth::ClientId.new(CLIENT_ID, CLIENT_SECRET)
+        authorizer = Google::Auth::UserAuthorizer.new(client_id, SCOPE, nil)
+        url = authorizer.get_authorization_url(base_url: OOB_URI)
+
+        UI.message("Open the following address in your browser and sign in with your Google account:")
+        UI.message(url)
+        UI.message("")
+        code = UI.input("Enter the resulting code here: ")
+        credentials = authorizer.get_credentials_from_code(code: code, base_url: OOB_URI)
+        UI.message("")
+
+        UI.success("Set the refresh token as the FIREBASE_TOKEN environment variable")
+        UI.success("Refresh Token: #{credentials.refresh_token}")
+      rescue Signet::AuthorizationError
+        UI.error("The code you entered is invalid. Copy and paste the code and try again.")
+      rescue => error
+        UI.error(error.to_s)
+        UI.crash!("An error has occured, please login again.")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Authenticate with Firebase App Distribution using a Google account."
+      end
+
+      def self.details
+        "Log in to Firebase App Distribution using a Google account to generate an authentication "\
+        "token. This token is stored within an environment variable and used to authenticate with your Firebase project. "\
+        "See https://firebase.google.com/docs/app-distribution/ios/distribute-fastlane for more information."
+      end
+
+      def self.authors
+        ["Manny Jimenez Github: mannyjimenez0810, Alonso Salas Infante Github: alonsosalasinfante"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb

@@ -0,0 +1,228 @@
+require 'fastlane_core/ui/ui'
+require_relative '../actions/firebase_app_distribution_login'
+
+module Fastlane
+  module Client
+    class FirebaseAppDistributionApiClient
+      BASE_URL = "https://firebaseappdistribution.googleapis.com"
+      TOKEN_CREDENTIAL_URI = "https://oauth2.googleapis.com/token"
+      MAX_POLLING_RETRIES = 60
+      POLLING_INTERVAL_SECONDS = 2
+
+      def initialize(auth_token, platform)
+        @auth_token = auth_token
+
+        if platform.nil?
+          @binary_type = "IPA/APK"
+        elsif platform == :ios
+          @binary_type = "IPA"
+        else
+          @binary_type = "APK"
+        end
+      end
+
+      # Enables tester access to the specified app release. Skips this
+      # step if no testers are passed in (emails and group_ids are nil/empty).
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   release_id - App release ID, returned by upload_status endpoint
+      #   emails - String array of app testers' email addresses
+      #   group_ids - String array of Firebase tester group IDs
+      #
+      # Throws a user_error if app_id, emails, or group_ids are invalid
+      def enable_access(app_id, release_id, emails, group_ids)
+        if (emails.nil? || emails.empty?) && (group_ids.nil? || group_ids.empty?)
+          UI.success("✅ No testers passed in. Skipping this step.")
+          return
+        end
+        payload = { emails: emails, groupIds: group_ids }
+        begin
+          connection.post(enable_access_url(app_id, release_id), payload.to_json) do |request|
+            request.headers["Authorization"] = "Bearer " + @auth_token
+          end
+        rescue Faraday::ResourceNotFound
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+        rescue Faraday::ClientError
+          UI.user_error!("#{ErrorMessage::INVALID_TESTERS} \nEmails: #{emails} \nGroups: #{group_ids}")
+        end
+        UI.success("✅ Added testers/groups.")
+      end
+
+      # Posts notes for the specified app release. Skips this
+      # step if no notes are passed in (release_notes is nil/empty).
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   release_id - App release ID, returned by upload_status endpoint
+      #   release_notes - String of notes for this release
+      #
+      # Throws a user_error if app_id or release_id are invalid
+      def post_notes(app_id, release_id, release_notes)
+        payload = { releaseNotes: { releaseNotes: release_notes } }
+        if release_notes.nil? || release_notes.empty?
+          UI.success("✅ No release notes passed in. Skipping this step.")
+          return
+        end
+        begin
+          connection.post(release_notes_create_url(app_id, release_id), payload.to_json) do |request|
+            request.headers["Authorization"] = "Bearer " + @auth_token
+          end
+        rescue Faraday::ResourceNotFound
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+          # rescue Faraday::ClientError
+          #   UI.user_error!("#{ErrorMessage::INVALID_RELEASE_ID}: #{release_id}")
+        end
+        UI.success("✅ Posted release notes.")
+      end
+
+      # Returns the url encoded upload token used for get_upload_status calls:
+      # projects/<project-number>/apps/<app-id>/releases/-/binaries/<binary-hash>
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   binary_path - Absolute path to your app's apk/ipa file
+      #
+      # Throws a user_error if an invalid app id is passed in, the binary file does
+      # not exist, or invalid auth credentials are used (e.g. wrong project permissions)
+      def get_upload_token(app_id, binary_path)
+        if binary_path.nil? || !File.exist?(binary_path)
+          UI.crash!("#{ErrorMessage.binary_not_found(@binary_type)}: #{binary_path}")
+        end
+        binary_hash = Digest::SHA256.hexdigest(File.open(binary_path).read)
+
+        begin
+          response = connection.get(v1_apps_url(app_id)) do |request|
+            request.headers["Authorization"] = "Bearer " + @auth_token
+          end
+        rescue Faraday::ResourceNotFound
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+        end
+        contact_email = response.body[:contactEmail]
+        if contact_email.nil? || contact_email.strip.empty?
+          UI.user_error!(ErrorMessage::GET_APP_NO_CONTACT_EMAIL_ERROR)
+        end
+        return upload_token_format(response.body[:appId], response.body[:projectNumber], binary_hash)
+      end
+
+      # Uploads the app binary to the Firebase API
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   binary_path - Absolute path to your app's apk/ipa file
+      #   platform - 'android' or 'ios'
+      #
+      # Throws a user_error if an invalid app id is passed in, or if the binary file does not exist
+      def upload_binary(app_id, binary_path, platform)
+        connection.post(binary_upload_url(app_id), File.open(binary_path).read) do |request|
+          request.headers["Authorization"] = "Bearer " + @auth_token
+          request.headers["X-APP-DISTRO-API-CLIENT-ID"] = "fastlane"
+          request.headers["X-APP-DISTRO-API-CLIENT-TYPE"] =  platform
+          request.headers["X-APP-DISTRO-API-CLIENT-VERSION"] = Fastlane::FirebaseAppDistribution::VERSION
+        end
+      rescue Faraday::ResourceNotFound
+        UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+      rescue Errno::ENOENT # Raised when binary_path file does not exist
+        UI.user_error!("#{ErrorMessage.binary_not_found(@binary_type)}: #{binary_path}")
+      end
+
+      # Uploads the binary file if it has not already been uploaded
+      # Takes at least POLLING_INTERVAL_SECONDS between polling get_upload_status
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   binary_path - Absolute path to your app's apk/ipa file
+      #
+      # Returns the release_id on a successful release, otherwise returns nil.
+      #
+      # Throws a UI error if the number of polling retries exceeds MAX_POLLING_RETRIES
+      # Crashes if not able to upload the binary
+      def upload(app_id, binary_path, platform)
+        upload_token = get_upload_token(app_id, binary_path)
+        upload_status_response = get_upload_status(app_id, upload_token)
+        if upload_status_response.success? || upload_status_response.already_uploaded?
+          UI.success("✅ This #{@binary_type} has been uploaded before. Skipping upload step.")
+        else
+          unless upload_status_response.in_progress?
+            UI.message("⌛ Uploading the #{@binary_type}.")
+            upload_binary(app_id, binary_path, platform)
+          end
+          MAX_POLLING_RETRIES.times do
+            upload_status_response = get_upload_status(app_id, upload_token)
+            if upload_status_response.success? || upload_status_response.already_uploaded?
+              UI.success("✅ Uploaded the #{@binary_type}.")
+              break
+            elsif upload_status_response.in_progress?
+              sleep(POLLING_INTERVAL_SECONDS)
+            else
+              if !upload_status_response.message.nil?
+                UI.user_error!("#{ErrorMessage.upload_binary_error(@binary_type)}: #{upload_status_response.message}")
+              else
+                UI.user_error!(ErrorMessage.upload_binary_error(@binary_type))
+              end
+            end
+          end
+          unless upload_status_response.success?
+            UI.error("It took longer than expected to process your #{@binary_type}, please try again.")
+            return nil
+          end
+        end
+        upload_status_response.release_id
+      end
+
+      # Fetches the status of an uploaded binary
+      #
+      # args
+      #   app_id - Firebase App ID
+      #   upload_token - URL encoded upload token
+      #
+      # Returns the release ID on a successful release, otherwise returns nil.
+      #
+      # Throws a user_error if an invalid app_id is passed in
+      def get_upload_status(app_id, upload_token)
+        begin
+          response = connection.get(upload_status_url(app_id, upload_token)) do |request|
+            request.headers["Authorization"] = "Bearer " + @auth_token
+          end
+        rescue Faraday::ResourceNotFound
+          UI.user_error!("#{ErrorMessage::INVALID_APP_ID}: #{app_id}")
+        end
+        return UploadStatusResponse.new(response.body)
+      end
+
+      private
+
+      def v1_apps_url(app_id)
+        "/v1alpha/apps/#{app_id}"
+      end
+
+      def release_notes_create_url(app_id, release_id)
+        "#{v1_apps_url(app_id)}/releases/#{release_id}/notes"
+      end
+
+      def enable_access_url(app_id, release_id)
+        "#{v1_apps_url(app_id)}/releases/#{release_id}/enable_access"
+      end
+
+      def binary_upload_url(app_id)
+        "/app-binary-uploads?app_id=#{app_id}"
+      end
+
+      def upload_status_url(app_id, app_token)
+        "#{v1_apps_url(app_id)}/upload_status/#{app_token}"
+      end
+
+      def upload_token_format(app_id, project_number, binary_hash)
+        CGI.escape("projects/#{project_number}/apps/#{app_id}/releases/-/binaries/#{binary_hash}")
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |conn|
+          conn.response(:json, parser_options: { symbolize_names: true })
+          conn.response(:raise_error) # raise_error middleware will run before the json middleware
+          conn.adapter(Faraday.default_adapter)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_auth_client.rb

@@ -0,0 +1,91 @@
+require 'fastlane_core/ui/ui'
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+  module Auth
+    module FirebaseAppDistributionAuthClient
+      TOKEN_CREDENTIAL_URI = "https://oauth2.googleapis.com/token"
+
+      # Returns the auth token for any of the auth methods (Firebase CLI token,
+      # Google service account, firebase-tools). To ensure that a specific
+      # auth method is used, unset all other auth variables/parameters to nil/empty
+      #
+      # args
+      #   google_service_path - Absolute path to the Google service account file
+      #   firebase_cli_token - Firebase CLI refresh token from login action or
+      #                        CI environment
+      #
+      # env variables
+      #   GOOGLE_APPLICATION_CREDENTIALS - see google_service_path
+      #   FIREBASE_TOKEN - see firebase_cli_token
+      #
+      # Crashes if given invalid or missing credentials
+      def fetch_auth_token(google_service_path, firebase_cli_token)
+        if !google_service_path.nil? && !google_service_path.empty?
+          UI.message("Authenticating with --service_credentials_file path parameter: #{google_service_path}")
+          token = service_account(google_service_path)
+        elsif !firebase_cli_token.nil? && !firebase_cli_token.empty?
+          UI.message("Authenticating with --firebase_cli_token parameter")
+          token = firebase_token(firebase_cli_token)
+        elsif !ENV["FIREBASE_TOKEN"].nil? && !ENV["FIREBASE_TOKEN"].empty?
+          UI.message("Authenticating with FIREBASE_TOKEN environment variable")
+          token = firebase_token(ENV["FIREBASE_TOKEN"])
+        elsif !ENV["GOOGLE_APPLICATION_CREDENTIALS"].nil? && !ENV["GOOGLE_APPLICATION_CREDENTIALS"].empty?
+          UI.message("Authenticating with GOOGLE_APPLICATION_CREDENTIALS environment variable: #{ENV['GOOGLE_APPLICATION_CREDENTIALS']}")
+          token = service_account(ENV["GOOGLE_APPLICATION_CREDENTIALS"])
+        elsif (refresh_token = refresh_token_from_firebase_tools)
+          UI.message("No authentication method specified. Using cached Firebase CLI credentials.")
+          token = firebase_token(refresh_token)
+        else
+          UI.user_error!(ErrorMessage::MISSING_CREDENTIALS)
+        end
+        UI.success("🔐 Authenticated successfully.")
+        token
+      end
+
+      private
+
+      def refresh_token_from_firebase_tools
+        if ENV["XDG_CONFIG_HOME"].nil? || ENV["XDG_CONFIG_HOME"].empty?
+          config_path = File.expand_path(".config/configstore/firebase-tools.json", "~")
+        else
+          config_path = File.expand_path("configstore/firebase-tools.json", ENV["XDG_CONFIG_HOME"])
+        end
+
+        if File.exist?(config_path)
+          begin
+            refresh_token = JSON.parse(File.read(config_path))['tokens']['refresh_token']
+            refresh_token unless refresh_token.nil? || refresh_token.empty?
+          # TODO: Catch parser errors, improve error handling here
+          # Returns nil when there is an empty "tokens" field in the firebase-tools json
+          rescue NoMethodError
+          end
+        end
+      end
+
+      def firebase_token(refresh_token)
+        client = Signet::OAuth2::Client.new(
+          token_credential_uri: TOKEN_CREDENTIAL_URI,
+          client_id: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_ID,
+          client_secret: Fastlane::Actions::FirebaseAppDistributionLoginAction::CLIENT_SECRET,
+          refresh_token: refresh_token
+        )
+        client.fetch_access_token!
+        client.access_token
+      rescue Signet::AuthorizationError
+        UI.user_error!(ErrorMessage::REFRESH_TOKEN_ERROR)
+      end
+
+      def service_account(google_service_path)
+        service_account_credentials = Google::Auth::ServiceAccountCredentials.make_creds(
+          json_key_io: File.open(google_service_path),
+          scope: Fastlane::Actions::FirebaseAppDistributionLoginAction::SCOPE
+        )
+        service_account_credentials.fetch_access_token!["access_token"]
+      rescue Errno::ENOENT
+        UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_NOT_FOUND}: #{google_service_path}")
+      rescue Signet::AuthorizationError
+        UI.user_error!("#{ErrorMessage::SERVICE_CREDENTIALS_ERROR}: #{google_service_path}")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_error_message.rb

@@ -0,0 +1,34 @@
+module ErrorMessage
+  MISSING_CREDENTIALS = "Missing authentication credentials. Check that your Firebase refresh token is set or that your service account file path is correct and try again."
+  MISSING_APP_ID = "Missing app id. Please check that the app parameter is set and try again"
+  SERVICE_CREDENTIALS_NOT_FOUND = "Service credentials file does not exist. Please check the service credentials path and try again"
+  PARSE_SERVICE_CREDENTIALS_ERROR = "Failed to extract service account information from the service credentials file"
+  UPLOAD_RELEASE_NOTES_ERROR = "App Distribution halted because it had a problem uploading release notes"
+  UPLOAD_TESTERS_ERROR = "App Distribution halted because it had a problem adding testers/groups"
+  GET_RELEASE_TIMEOUT = "App Distribution failed to fetch release information"
+  REFRESH_TOKEN_ERROR = "App Distribution could not generate credentials from the refresh token specified."
+  GET_APP_ERROR = "App Distribution failed to fetch app information"
+  APP_NOT_ONBOARDED_ERROR = "App Distribution not onboarded"
+  GET_APP_NO_CONTACT_EMAIL_ERROR = "App Distribution could not find a contact email associated with this app. Contact Email"
+  INVALID_APP_ID = "App Distribution could not find your app. Make sure to onboard your app by pressing the \"Get started\" button on the App Distribution page in the Firebase console: https://console.firebase.google.com/project/_/appdistribution. App ID"
+  INVALID_PATH = "Could not read content from"
+  INVALID_TESTERS = "Could not enable access for testers. Check that the groups exist and the tester emails are formatted correctly"
+  INVALID_RELEASE_ID = "App distribution failed to fetch release with id"
+  SERVICE_CREDENTIALS_ERROR = "App Distribution could not generate credentials from the service credentials file specified. Service Account Path"
+
+  def self.binary_not_found(binary_type)
+    "Could not find the #{binary_type}. Make sure you set the #{binary_type} path parameter to point to your #{binary_type}"
+  end
+
+  def self.parse_binary_metadata_error(binary_type)
+    "Failed to extract #{binary_type} metadata from the #{binary_type} path"
+  end
+
+  def self.upload_binary_error(binary_type)
+    "App Distribution halted because it had a problem uploading the #{binary_type}"
+  end
+
+  def self.binary_processing_error(binary_type)
+    "App Distribution failed to process the #{binary_type}"
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_helper.rb

@@ -1,60 +1,39 @@
 require 'fastlane_core/ui/ui'
-
+require 'cfpropertylist'
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
-
   module Helper
     module FirebaseAppDistributionHelper
-      def testers_flag(params)
-        file_flag_if_supplied("--testers-file", "testers", params)
-      end
-
-      def groups_flag(params)
-        file_flag_if_supplied("--groups-file", "groups", params)
-      end
-
-      def release_notes_flag(params)
-        file_flag_if_supplied("--release-notes-file", "release_notes", params)
-      end
-
-      def file_flag_if_supplied(flag, param_name, params)
-        file = params["#{param_name}_file".to_sym]
-        file ||= file_for_contents(param_name.to_sym, params)
-
-        if file
-          return "#{flag} #{file}"
+      def get_value_from_value_or_file(value, path)
+        if (value.nil? || value.empty?) && !path.nil?
+          begin
+            return File.open(path).read
+          rescue Errno::ENOENT
+            UI.crash!("#{ErrorMessage::INVALID_PATH}: #{path}")
+          end
         end
+        value
       end
 
-      def flag_value_if_supplied(flag, param_name, params)
-        "#{flag} #{params[param_name]}" if params[param_name]
-      end
-
-      def flag_if_supplied(flag, param_name, params)
-        flag if params[param_name]
+      # Returns the array representation of a string with comma seperated values.
+      #
+      # Does not work with strings whose individual values have spaces. EX "Hello World" the space will be removed to "HelloWorld"
+      def string_to_array(string)
+        return nil if string.nil? || string.empty?
+        string_array = string.gsub(/\s+/, '').split(",")
+        return string_array
       end
 
-      ##
-      # always return a file for a given content
-      def file_for_contents(parameter_name, params)
-        if @tempfiles.nil?
-          @tempfiles = []
-        end
-
-        contents = params[parameter_name]
-        return nil if contents.nil?
-
-        file = Tempfile.new(parameter_name.to_s)
-        file.write(contents)
-        file.close
-        @tempfiles << file
-
-        file.path
+      def parse_plist(path)
+        CFPropertyList.native_types(CFPropertyList::List.new(file: path).value)
       end
 
-      def cleanup_tempfiles
-        return if @tempfiles.nil?
-        @tempfiles.each(&:unlink)
+      def get_ios_app_id_from_archive(path)
+        app_path = parse_plist("#{path}/Info.plist")["ApplicationProperties"]["ApplicationPath"]
+        UI.shell_error!("can't extract application path from Info.plist at #{path}") if app_path.empty?
+        identifier = parse_plist("#{path}/Products/#{app_path}/GoogleService-Info.plist")["GOOGLE_APP_ID"]
+        UI.shell_error!("can't extract GOOGLE_APP_ID") if identifier.empty?
+        return identifier
       end
     end
   end

data/lib/fastlane/plugin/firebase_app_distribution/helper/upload_status_response.rb

@@ -0,0 +1,37 @@
+class UploadStatusResponse
+  def initialize(response_json_hash)
+    @response_json_hash = response_json_hash
+  end
+
+  def status
+    @response_json_hash[:status]
+  end
+
+  def success?
+    status == 'SUCCESS'
+  end
+
+  def in_progress?
+    status == 'IN_PROGRESS'
+  end
+
+  def error?
+    status == 'ERROR'
+  end
+
+  def already_uploaded?
+    status == 'ALREADY_UPLOADED'
+  end
+
+  def release_hash
+    @response_json_hash[:release]
+  end
+
+  def release_id
+    release_hash ? release_hash[:id] : nil
+  end
+
+  def message
+    @response_json_hash[:message]
+  end
+end

data/lib/fastlane/plugin/firebase_app_distribution/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module FirebaseAppDistribution
-    VERSION = "0.1.3"
+    VERSION = "0.2.0.pre.4"
   end
 end

metadata

@@ -1,14 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-firebase_app_distribution
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0.pre.4
 platform: ruby
 authors:
 - Stefan Natchev
-autorequire: 
+- Manny Jimenez
+- Alonso Salas Infante
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-08 00:00:00.000000000 Z
+date: 2020-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -136,9 +138,11 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.127.1
-description: 
+description:
 email:
 - snatchev@google.com
+- mannyjimenez@google.com
+- alonsosi@google.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -147,13 +151,18 @@ files:
 - README.md
 - lib/fastlane/plugin/firebase_app_distribution.rb
 - lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_action.rb
+- lib/fastlane/plugin/firebase_app_distribution/actions/firebase_app_distribution_login.rb
+- lib/fastlane/plugin/firebase_app_distribution/client/firebase_app_distribution_api_client.rb
+- lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_auth_client.rb
+- lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_error_message.rb
 - lib/fastlane/plugin/firebase_app_distribution/helper/firebase_app_distribution_helper.rb
+- lib/fastlane/plugin/firebase_app_distribution/helper/upload_status_response.rb
 - lib/fastlane/plugin/firebase_app_distribution/version.rb
-homepage: https://github.com/fastlane-community/fastlane-plugin-firebase_app_distribution
+homepage: https://github.com/fastlane/fastlane-plugin-firebase_app_distribution
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -164,12 +173,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Release your beta builds to Firebase App Distribution. https://firebase.google.com/docs/app-distribution
 test_files: []