fastlane-plugin-firebase_management_api 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c456fd3fde81966d576ecc095789ac862c3859fe635a6a2a14880edbc4a6f06d
+  data.tar.gz: e4d4430728bda4d189d296e8165967874168c5d4a6b997051818f36f45351d34
+SHA512:
+  metadata.gz: da9ff9e31d404bf836964599443e2468db203cbb5664e23661611dbb37f7f28a91862d8191e935a575c7b545620fa3ae89d6bc0c185882c5c6c4f793f6c7720e
+  data.tar.gz: bc13fc7004eea8fc53a36cb2c12b0a0ef180abcc81076f8a103ec21eb0791aba32383df9d054cccb2cc71dd191658b5d3ddf17fa1e8f0e715bf3fa8be3d1bc93

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Tomas Kohout <email@tomaskohout.cz>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+# firebase_management `fastlane` Plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-firebase_management)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-firebase_management`, add it to your project by running:
+
+```bash
+fastlane add_plugin firebase_management
+```
+
+## About firebase_management
+
+An unofficial tool to access Firebase project settings. It allows you to create new apps and download config files (GoogleInfo.plist for ios and google-services.json for android).
+
+Plugin uses new official [Firebase Management API](https://firebase.google.com/docs/projects/api/reference/rest/) introduced on Firebase Summit 10/2018. It's based on [tkohout/fastlane-firebase-plugin](https://github.com/tkohout/fastlane-firebase-plugin), which uses web scraping instead of official API to manage Firebase apps. The plan is that both plugins will live next to each other until official API will contain all desired features and tkohout's plugin won't be needed anymore.
+
+New features like deleting apps or APNs keys/certificates management are promised by guys from Google/Firebase so stay tuned 🤙
+
+**This very first version was developed using alpha version of the API in a very short time, so it may contain bugs or mistakes. Issues and PRs are very welcome! 🤗**
+
+### Actions
+
+List all projects and apps
+
+```
+firebase_management_list
+```
+
+Add app to a project and download config file
+
+```
+firebase_management_add_app
+```
+
+Add sha to an android app and download config file
+
+```
+firebase_management_upload_sha
+```
+
+Download config file for a client
+
+```
+firebase_management_download_config
+```
+
+### Authentication
+
+~~Plugin works only with service accounts.~~
+
+#### User login
+
+You can use your ordinary account in combination with client secret json file created in GCP console.
+
+#### Service accounts
+
+A service account is a special Google account that belongs to your application or a virtual machine, instead of to an individual end user. Read more [here](https://cloud.google.com/iam/docs/service-accounts).
+
+All you need for the plugin to work is a json file with service account private key information. The easiest way to get it is...
+
+Go to Firebase Console -> Your project -> Project settings -> Service accounts and tap on button `Generate new private key`. 🎉 That's the file you need!
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).
+
+## Warning
+
+DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY.
+
+UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+THE DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY PROVIDED ABOVE SHALL BE INTERPRETED IN A MANNER THAT, TO THE EXTENT POSSIBLE, MOST CLOSELY APPROXIMATES AN ABSOLUTE DISCLAIMER AND WAIVER OF ALL LIABILITY.

data/lib/fastlane/plugin/firebase_management_api/actions/firebase_add_app_action.rb

@@ -0,0 +1,200 @@
+module Fastlane
+	module Actions
+		class FirebaseManagementAddAppAction < Action
+			
+			def self.run(params)
+				manager = FirebaseManagement::Manager.new
+				
+				# login
+				api = nil
+				if params[:service_account_json_path] != nil then
+					api = manager.serviceAccountLogin(params[:service_account_json_path])
+				elsif params[:email] != nil && params[:client_secret_json_path] != nil then
+					api = manager.userLogin(params[:email], params[:client_secret_json_path])
+				else
+					UI.error "You must define service_account_json_path or email with client_secret_json_path."
+					return nil
+				end
+
+				# select project
+				project_id = params[:project_id] || manager.select_project(nil)["projectId"]
+
+				# select type
+				type = params[:type].to_sym
+
+				bundle_id = params[:bundle_id]
+
+				display_name = params[:display_name]
+
+				case type
+				when :ios
+					# download apps for project
+					apps = api.ios_app_list(project_id)
+
+					# search for newly created app
+					app = apps.detect {|app| app["bundleId"] == bundle_id }
+					
+					UI.success "Start detect app "
+
+					if app != nil then
+						UI.success "You already have app with id: #{app["appId"]}"
+					else
+						UI.success "Start create new app "
+
+						# create new ios app on Firebase
+						api.add_ios_app(project_id, bundle_id, display_name)
+
+						# App creation is a long-running operation.
+						# Creation endpoint returns operation ID which should be used to check
+						# the result of the operation. This requires another Google API to be
+						# enabled and other stuff to do so just wait for 3 seconds here, fetch
+						# apps from Firebase and check whether the new app is there.
+						sleep 3
+
+						# download apps for project
+						apps = api.ios_app_list(project_id)
+
+						# search for newly created app
+						app = apps.detect {|app| app["bundleId"] == bundle_id }
+						# present result to user
+						if app != nil then
+							UI.success "New app with id: #{app["appId"]} successfully created"
+						else
+							UI.crash! "Unable to create new app"
+						end
+					end
+						
+
+				when :android
+						
+					# download apps for project
+					apps = api.android_app_list(project_id)
+
+					# search for newly created app
+					app = apps.detect {|app| app["packageName"] == bundle_id }
+							
+					if app != nil then
+						UI.success "You already have app with id: #{app["appId"]}"
+					else
+						
+						# create new android app on Firebase
+						api.add_android_app(project_id, bundle_id, display_name)
+
+						# see reason described above
+						sleep 3	
+						
+						# download apps for project
+						apps = api.android_app_list(project_id)
+
+						# search for newly created app
+						app = apps.detect {|app| app["packageName"] == bundle_id }
+
+						# present result to user
+						if app != nil then
+							UI.success "New app with id: #{app["appId"]} successfully created"
+						else
+							UI.crash! "Unable to create new app"
+						end
+					end
+
+				end
+
+				if params[:download_config] then
+					#Download config
+					Actions::FirebaseManagementDownloadConfigAction.run(
+						service_account_json_path: params[:service_account_json_path],
+						project_id: project_id,
+						app_id: app["appId"],
+						type: type,
+						output_path: params[:output_path]
+					)
+				end
+			end
+
+			def self.description
+				"Add new app to Firebase project"
+			end
+
+			def self.authors
+				["Ackee, s.r.o."]
+			end
+
+			def self.return_value
+				# If your method provides a return value, you can describe here what it does
+			end
+
+			def self.details
+				# Optional:
+				"Firebase plugin helps you list your projects, create applications and download configuration files."
+			end
+
+			def self.available_options
+				[
+					FastlaneCore::ConfigItem.new(key: :email,
+											env_name: "FIREBASE_EMAIL",
+										 description: "User's email to identify stored credentials",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :client_secret_json_path,
+											env_name: "FIREBASE_CLIENT_SECRET_JSON_PATH",
+										 description: "Path to client secret json file",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :service_account_json_path,
+											env_name: "FIREBASE_SERVICE_ACCOUNT_JSON_PATH",
+										 description: "Path to service account json key",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :project_id,
+											env_name: "FIREBASE_PROJECT_ID",
+										 description: "Project id",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :download_config,
+											env_name: "FIREBASE_DOWNLOAD_CONFIG",
+										 description: "Should download config for created client",
+											optional: false,
+											is_string: false,
+											default_value: false),
+
+					FastlaneCore::ConfigItem.new(key: :type,
+											env_name: "FIREBASE_TYPE",
+										 description: "Type of client (ios, android)",
+											verify_block: proc do |value|
+												types = [:ios, :android]
+												UI.user_error!("Type must be in #{types}") unless types.include?(value.to_sym)
+											end
+										 ),
+					FastlaneCore::ConfigItem.new(key: :bundle_id,
+											env_name: "FIREBASE_BUNDLE_ID",
+										 description: "Bundle ID (package name)",
+											optional: false),
+
+					FastlaneCore::ConfigItem.new(key: :display_name,
+											env_name: "FIREBASE_DISPLAY_NAME",
+										 description: "Display name",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :output_path,
+					                        env_name: "FIREBASE_OUTPUT_PATH",
+					                     description: "Path for the downloaded config",
+					                        optional: false,
+					                   default_value: "./"),
+
+					FastlaneCore::ConfigItem.new(key: :output_name,
+					                        env_name: "FIREBASE_OUTPUT_NAME",
+					                     description: "Name of the downloaded file",
+					                        optional: true)
+				]	
+			end
+
+			def self.is_supported?(platform)
+				# Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+				# See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+				#
+				# [:ios, :mac, :android].include?(platform)
+				true
+			end
+		end
+	end
+end

data/lib/fastlane/plugin/firebase_management_api/actions/firebase_add_app_sha_action.rb

@@ -0,0 +1,128 @@
+module Fastlane
+	module Actions
+		class FirebaseManagementUploadShaAction < Action
+			
+			def self.run(params)
+				manager = FirebaseManagement::Manager.new
+				
+				# login
+				api = nil
+				if params[:service_account_json_path] != nil then
+					api = manager.serviceAccountLogin(params[:service_account_json_path])
+				elsif params[:email] != nil && params[:client_secret_json_path] != nil then
+					api = manager.userLogin(params[:email], params[:client_secret_json_path])
+				else
+					UI.error "You must define service_account_json_path or email with client_secret_json_path."
+					return nil
+				end
+
+				# select project
+				project_id = params[:project_id] || manager.select_project(nil)["projectId"]
+				
+				# select app
+				app_id = params[:app_id] || manager.select_app(project_id, nil, :android)["appId"]
+
+				# create new android app on Firebase
+				api.upload_sha(project_id, app_id, params[:sha_hash], params[:cert_type])
+
+				if params[:download_config] then
+					#Download config
+					Actions::FirebaseManagementDownloadConfigAction.run(
+						service_account_json_path: params[:service_account_json_path],
+						project_id: project_id,
+						app_id: app["appId"],
+						type: type,
+						output_path: params[:output_path]
+					)
+				end
+			end
+
+			def self.description
+				"Add sha to to Firebase android app"
+			end
+
+			def self.authors
+				["NicoLourenco"]
+			end
+
+			def self.return_value
+				# If your method provides a return value, you can describe here what it does
+			end
+
+			def self.details
+				# Optional:
+				"Firebase plugin helps you list your projects, create applications and download configuration files."
+			end
+
+			def self.available_options
+				[
+					FastlaneCore::ConfigItem.new(key: :email,
+											env_name: "FIREBASE_EMAIL",
+										 description: "User's email to identify stored credentials",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :client_secret_json_path,
+											env_name: "FIREBASE_CLIENT_SECRET_JSON_PATH",
+										 description: "Path to client secret json file",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :service_account_json_path,
+											env_name: "FIREBASE_SERVICE_ACCOUNT_JSON_PATH",
+										 description: "Path to service account json key",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :project_id,
+											env_name: "FIREBASE_PROJECT_ID",
+										 description: "Project id",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :app_id,
+											env_name: "FIREBASE_APP_ID",
+										 description: "Project app id",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :sha_hash,
+											env_name: "FIREBASE_SHA_HASH",
+										 description: "Sha hash",
+											optional: false),
+
+					FastlaneCore::ConfigItem.new(key: :download_config,
+											env_name: "FIREBASE_DOWNLOAD_CONFIG",
+										 description: "Should download config for created client",
+											optional: false,
+											is_string: false,
+											default_value: false),
+
+					FastlaneCore::ConfigItem.new(key: :cert_type,
+											env_name: "FIREBASE_CERT_TYPE",
+										 description: "Type of certificate (SHA_1, SHA_256)",
+										 optional: false,
+											verify_block: proc do |value|
+												types = [:SHA_1, :SHA_256]
+												UI.user_error!("Type must be in #{types}") unless types.include?(value.to_sym)
+											end
+										 ),
+
+					FastlaneCore::ConfigItem.new(key: :output_path,
+					                        env_name: "FIREBASE_OUTPUT_PATH",
+					                     description: "Path for the downloaded config",
+					                        optional: false,
+					                   default_value: "./"),
+
+					FastlaneCore::ConfigItem.new(key: :output_name,
+					                        env_name: "FIREBASE_OUTPUT_NAME",
+					                     description: "Name of the downloaded file",
+					                        optional: true)
+				]	
+			end
+
+			def self.is_supported?(platform)
+				# Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+				# See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+				#
+				# [:ios, :mac, :android].include?(platform)
+				true
+			end
+		end
+	end
+end

data/lib/fastlane/plugin/firebase_management_api/actions/firebase_download_config_action.rb

@@ -0,0 +1,122 @@
+module Fastlane
+	module Actions
+		class FirebaseManagementDownloadConfigAction < Action
+
+			def self.run(params)
+				manager = FirebaseManagement::Manager.new
+
+				# login
+				api = nil
+				if params[:service_account_json_path] != nil then
+					api = manager.serviceAccountLogin(params[:service_account_json_path])
+				elsif params[:email] != nil && params[:client_secret_json_path] != nil then
+					api = manager.userLogin(params[:email], params[:client_secret_json_path])
+				else
+					UI.error "You must define service_account_json_path or email with client_secret_json_path."
+					return nil
+				end
+
+				# select project
+				project_id = params[:project_id] || manager.select_project(nil)["projectId"]
+
+				# select type
+				type = params[:type].to_sym
+
+				# select app
+				app_id = params[:app_id] || manager.select_app(project_id, nil, type)["appId"]
+
+				# download
+				case type
+				when :ios
+					config = api.download_ios_config_file(project_id, app_id)
+				when :android
+					config = api.download_android_config_file(project_id, app_id)
+				end
+				
+				path = File.join(params[:output_path], params[:output_name] || config["configFilename"])
+
+				decode_base64_content = Base64.decode64(config["configFileContents"]) 
+				File.open(path, "wb") do |f|
+					f.write(decode_base64_content)
+				end 
+
+				UI.success "Successfuly saved config at #{path}"
+
+				return nil
+			end
+
+			def self.description
+				"Download configuration file for Firebase app"
+			end
+
+			def self.authors
+				["Ackee, s.r.o."]
+			end
+
+			def self.return_value
+				# If your method provides a return value, you can describe here what it does
+			end
+
+			def self.details
+				# Optional:
+				"Firebase plugin helps you list your projects, create applications and download configuration files."
+			end
+
+			def self.available_options
+				[
+					FastlaneCore::ConfigItem.new(key: :email,
+											env_name: "FIREBASE_EMAIL",
+										 description: "User's email to identify stored credentials",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :client_secret_json_path,
+											env_name: "FIREBASE_CLIENT_SECRET_JSON_PATH",
+										 description: "Path to client secret json file",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :service_account_json_path,
+					                        env_name: "FIREBASE_SERVICE_ACCOUNT_JSON_PATH",
+					                     description: "Path to service account json key",
+					                        optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :project_id,
+					                        env_name: "FIREBASE_PROJECT_ID",
+					                     description: "Project id",
+					                        optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :app_id,
+					                        env_name: "FIREBASE_APP_ID",
+					                     description: "Project app id",
+					                        optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :type,
+											env_name: "FIREBASE_TYPE",
+										 description: "Type of client (ios, android)",
+											verify_block: proc do |value|
+												types = [:ios, :android]
+												UI.user_error!("Type must be in #{types}") unless types.include?(value.to_sym)
+											end
+										 ),
+					FastlaneCore::ConfigItem.new(key: :output_path,
+					                        env_name: "FIREBASE_OUTPUT_PATH",
+					                     description: "Path for the downloaded config",
+					                        optional: false,
+					                   default_value: "./"),
+					
+					FastlaneCore::ConfigItem.new(key: :output_name,
+					                        env_name: "FIREBASE_OUTPUT_NAME",
+					                     description: "Name of the downloaded file",
+					                        optional: true)
+				]
+			end
+
+			def self.is_supported?(platform)
+				# Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+				# See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+				#
+				# [:ios, :mac, :android].include?(platform)
+				true
+			end
+		end
+	end
+end

data/lib/fastlane/plugin/firebase_management_api/actions/firebase_list_action.rb

@@ -0,0 +1,92 @@
+module Fastlane
+	module Actions
+		class FirebaseManagementListAction < Action
+
+			def self.run(params)
+				manager = FirebaseManagement::Manager.new
+
+				# login
+				api = nil
+				if params[:service_account_json_path] != nil then
+					api = manager.serviceAccountLogin(params[:service_account_json_path])
+				elsif params[:email] != nil && params[:client_secret_json_path] != nil then
+					api = manager.userLogin(params[:email], params[:client_secret_json_path])
+				else
+					UI.error "You must define service_account_json_path or email with client_secret_json_path."
+					return nil
+				end
+
+				# download list of projects
+				projects = api.project_list()
+
+				# create formatted output
+				projects.each_with_index { |p, i| 
+					UI.message "#{i+1}. #{p["displayName"]} (#{p["projectId"]})" 
+					
+					ios_apps = api.ios_app_list(p["projectId"])
+					if !ios_apps.empty? then
+						UI.message "  iOS"
+						ios_apps.sort {|left, right| left["appId"] <=> right["appId"] }.each_with_index { |app, j|
+							UI.message "  - #{app["displayName"] || app["bundleId"]} (#{app["appId"]})" 
+						}
+					end
+
+					android_apps = api.android_app_list(p["projectId"])
+					if !android_apps.empty? then
+						UI.message "  Android"
+						android_apps.sort {|left, right| left["appId"] <=> right["appId"] }.each_with_index { |app, j|
+							UI.message "  - #{app["displayName"] || app["packageName"]} (#{app["appId"]})" 
+						}
+					end
+				}
+
+				return nil
+			end
+
+			def self.description
+				"List all Firebase projects and their apps"
+			end
+
+			def self.authors
+				["Ackee, s.r.o."]
+			end
+
+			def self.return_value
+				# If your method provides a return value, you can describe here what it does
+			end
+
+			def self.details
+				# Optional:
+				"Firebase plugin helps you list your projects, create applications and download configuration files."
+			end
+
+			def self.available_options
+				[
+					FastlaneCore::ConfigItem.new(key: :email,
+											env_name: "FIREBASE_EMAIL",
+										 description: "User's email to identify stored credentials",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :client_secret_json_path,
+											env_name: "FIREBASE_CLIENT_SECRET_JSON_PATH",
+										 description: "Path to client secret json file",
+											optional: true),
+
+					FastlaneCore::ConfigItem.new(key: :service_account_json_path,
+											env_name: "FIREBASE_SERVICE_ACCOUNT_JSON_PATH",
+										 description: "Path to service account json key",
+											optional: true
+					)
+				]
+			end
+
+			def self.is_supported?(platform)
+				# Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+				# See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+				#
+				# [:ios, :mac, :android].include?(platform)
+				true
+			end
+		end
+	end
+end

data/lib/fastlane/plugin/firebase_management_api/helper/firebase_management_helper.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class FirebaseManagementHelper
+      # class methods that you define here become available in your action
+      # as `Helper::FirebaseManagementHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the firebase_management plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_management_api/lib/api.rb

@@ -0,0 +1,147 @@
+module Fastlane
+	module FirebaseManagement
+		class Api 
+			class LoginError < StandardError 
+			end
+
+			class BadRequestError < StandardError
+				attr_reader :code
+				
+				def initialize(msg, code)
+					@code = code
+					super(msg)
+				end
+			end
+
+			require 'googleauth'
+			require 'httparty'
+
+			def initialize(access_token)
+				@base_url = "https://firebase.googleapis.com"
+				@authorization_headers = {
+					'Authorization' => 'Bearer ' + access_token
+				}
+			end
+
+			def request_json(path, method = :get, parameters = Hash.new, headers = Hash.new)
+				begin
+					if method == :get then
+						response = HTTParty.get("#{@base_url}/#{path}", headers: headers.merge(@authorization_headers), format: :plain)
+					elsif method == :post then
+						headers['Content-Type'] = 'application/json'
+						response = HTTParty.post("#{@base_url}/#{path}", headers: headers.merge(@authorization_headers), body: parameters.to_json, format: :plain)
+					end
+
+					case response.code
+						when 400...600
+							UI.crash! response
+						else
+							JSON.parse(response)
+					end
+
+				rescue HTTParty::Error => e
+					UI.crash! e.response.body
+				rescue StandardError => e
+					UI.crash! e
+				end
+			end
+
+			def project_list
+				UI.verbose "Retrieving project list"
+				json = request_json("v1beta1/projects")
+				projects = json["results"] || []
+				UI.verbose "Found #{projects.count} projects"
+				projects
+			end
+					
+                        def ios_app_list(project_id, params = nil)
+                                UI.verbose "Retrieving app list for project #{project_id}"
+
+                                apps = []
+                                pageToken = nil
+                                loop do
+                                        url = "v1beta1/projects/#{project_id}/iosApps" + (pageToken ? "?pageToken=#{pageToken}" : "")
+                                        json = request_json(url)
+                                        apps.concat(json["apps"] || [])
+                                        pageToken = json["nextPageToken"]
+                                        break if !pageToken
+                                end
+                                UI.verbose "Found #{apps.count} apps"
+                                apps
+                        end
+
+                        def android_app_list(project_id)
+                                UI.verbose "Retrieving app list for project #{project_id}"
+                                apps = []
+                                pageToken = nil
+                                loop do
+                                        url = "v1beta1/projects/#{project_id}/androidApps" + (pageToken ? "?pageToken=#{pageToken}" : "")
+                                        json = request_json(url)
+                                        apps.concat(json["apps"] || [])
+                                        pageToken = json["nextPageToken"]
+                                        break if !pageToken
+                                end
+                                UI.verbose "Found #{apps.count} apps"
+                                apps
+                        end
+
+			def add_ios_app(project_id, bundle_id, app_name)
+				parameters = {
+					"bundleId" => bundle_id,
+					"displayName" => app_name || ""
+				}
+				
+				request_json("v1beta1/projects/#{project_id}/iosApps", :post, parameters)
+			end
+
+			def add_android_app(project_id, package_name, app_name)
+				parameters = {
+					"packageName" => package_name,
+					"displayName" => app_name || ""
+				}
+
+				request_json("v1beta1/projects/#{project_id}/androidApps", :post, parameters)
+			end
+
+			def upload_sha(project_id, app_id, sha_hash, cert_type)
+				UI.verbose "Uploading sha"
+				parameters = {
+					"shaHash" => sha_hash,
+					"certType" => cert_type,
+				}
+
+				json = request_json("v1beta1/projects/#{project_id}/androidApps/#{app_id}/sha", :post, parameters)
+				UI.verbose "Successfuly uploaded sha"
+				json
+			end
+
+			def upload_certificate(project_number, client_id, type, certificate_value, certificate_password)
+				
+				prefix = type == :development ? "debug" : "prod"
+
+				parameters = {
+					"#{prefix}ApnsCertificate" => { 
+						"certificateValue" => certificate_value,
+						"apnsPassword" => certificate_password 
+					}
+				}
+
+				json = request_json("v1/projects/#{project_number}/clients/#{client_id}:setApnsCertificate", :post, parameters)
+			end
+
+			def download_ios_config_file(project_id, app_id)
+				UI.verbose "Downloading config file"
+				json = request_json("v1beta1/projects/#{project_id}/iosApps/#{app_id}/config")
+				UI.verbose "Successfuly downloaded #{json["configFilename"]}"
+				json
+			end
+
+			def download_android_config_file(project_id, app_id)
+				UI.verbose "Downloading config file"
+				json = request_json("v1beta1/projects/#{project_id}/androidApps/#{app_id}/config")
+				UI.verbose "Successfuly downloaded #{json["configFilename"]}"
+				json
+			end
+		end
+	end
+end

data/lib/fastlane/plugin/firebase_management_api/lib/commands_generator.rb

@@ -0,0 +1,41 @@
+require 'commander'
+require 'fastlane/version'
+
+
+module FirebaseManagement
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'firebase'
+      program :version, Fastlane::VERSION
+      program :description, 'CLI for \'PEM\' - Automatically generate and renew your push notification profiles'
+      program :help, 'Author', 'Felix Krause <pem@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/PEM'
+      program :help_formatter, :compact
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+
+      command :list do |c|
+        c.syntax = 'fastlane firebase list'
+        c.description = 'Lists all projects in your firebase'
+
+        FastlaneCore::CommanderGenerator.new.generate(Firebase::Options.available_options, command: c)
+
+        c.action do |args, options|
+          Firebase.config = FastlaneCore::Configuration.create(Firebase::Options.available_options, options.__hash__)
+          #Firebase::Manager.start
+        end
+      end
+
+      default_command :list
+
+      run!
+    end
+  end
+end

data/lib/fastlane/plugin/firebase_management_api/lib/manager.rb

@@ -0,0 +1,99 @@
+module Fastlane
+	module FirebaseManagement
+		class Manager
+
+			require 'googleauth'
+			require 'googleauth/stores/file_token_store'
+
+			def userLogin(email, client_secrets_path)
+
+				system 'mkdir -p ~/.google'
+
+				oob_uri = "urn:ietf:wg:oauth:2.0:oob"
+
+				scopes = [
+					'https://www.googleapis.com/auth/firebase',
+					'https://www.googleapis.com/auth/cloud-platform'
+				]
+				client_id = Google::Auth::ClientId.from_file(client_secrets_path)
+				token_store = Google::Auth::Stores::FileTokenStore.new(:file => File.expand_path("~/.google/tokens.yaml"))
+				authorizer = Google::Auth::UserAuthorizer.new(client_id, scopes, token_store)
+
+				credentials = authorizer.get_credentials(email)
+				if credentials.nil?
+				  url = authorizer.get_authorization_url(base_url: oob_uri)
+				  UI.message "Open #{url} in your browser and enter the resulting code."
+
+				  code = Fastlane::Actions::PromptAction.run(text: "Code: ")
+
+				  credentials = authorizer.get_and_store_credentials_from_code(user_id: email, code: code, base_url: oob_uri)
+				end
+				
+				token = credentials.fetch_access_token!["access_token"]
+				@api = FirebaseManagement::Api.new(token)
+				@api
+			end
+
+			def serviceAccountLogin(jsonPath)
+				scope = 'https://www.googleapis.com/auth/firebase https://www.googleapis.com/auth/cloud-platform'
+
+				authorizer = Google::Auth::ServiceAccountCredentials.make_creds(
+					json_key_io: File.open(jsonPath),
+					scope: scope
+				)
+
+				token = authorizer.fetch_access_token!["access_token"]
+				@api = FirebaseManagement::Api.new(token)
+				@api
+			end
+
+			def select_project(project_id)
+
+				projects = @api.project_list()
+				
+				if projects.count == 0 then
+					UI.user_error! "No projects exist under the account"
+					return
+				end
+
+				if project = projects.select {|p| p["projectId"] == project_id }.first then
+					project
+				else 
+					options = projects.map { |p| "#{p["displayName"]} (#{p["projectId"]})" }
+					index = select_index("Select project:", options)
+					projects[index]
+				end
+			end
+
+			def select_app(project_id, app_id, type)
+
+				case type
+				when :ios
+					apps = @api.ios_app_list(project_id)
+				when :android
+					apps = @api.android_app_list(project_id)
+				end
+
+				if apps.empty? then
+					UI.user_error! "Project has no #{type} apps"
+					return
+				end
+
+				apps = apps.sort {|left, right| left["appId"] <=> right["appId"] }
+
+				if app = apps.select {|a| a["appId"] == app_id }.first then
+					app
+				else
+					options = apps.map { |a| "#{a["displayName"] || a["bundleId"] || a["packageName"]} (#{a["appId"]})" }
+					index = select_index("Select app:", options)
+					apps[index]
+				end
+			end
+
+			def select_index(text, options)
+				selected = UI.select(text, options)
+				return options.index(selected)
+			end 
+		end
+	end
+end 

data/lib/fastlane/plugin/firebase_management_api/lib/options.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module FirebaseManagement
+	class Options
+		def self.available_options
+			[
+				FastlaneCore::ConfigItem.new(
+					key: :username,
+					env_name: "FIREBASE_USERNAME",
+					description: "Username for the google account"
+				)
+			]
+		end
+	end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module FirebaseManagement
+    VERSION = "1.1.1"
+  end
+end

data/lib/fastlane/plugin/firebase_management_api.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/firebase_management_api/version'
+
+module Fastlane
+  module FirebaseManagement
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper,lib}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::FirebaseManagement.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-firebase_management_api
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Abdelrahman Eldesoky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.108.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.108.0
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: abdelrhman.m.eldesoky@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/firebase_management_api.rb
+- lib/fastlane/plugin/firebase_management_api/actions/firebase_add_app_action.rb
+- lib/fastlane/plugin/firebase_management_api/actions/firebase_add_app_sha_action.rb
+- lib/fastlane/plugin/firebase_management_api/actions/firebase_download_config_action.rb
+- lib/fastlane/plugin/firebase_management_api/actions/firebase_list_action.rb
+- lib/fastlane/plugin/firebase_management_api/helper/firebase_management_helper.rb
+- lib/fastlane/plugin/firebase_management_api/lib/api.rb
+- lib/fastlane/plugin/firebase_management_api/lib/commands_generator.rb
+- lib/fastlane/plugin/firebase_management_api/lib/manager.rb
+- lib/fastlane/plugin/firebase_management_api/lib/options.rb
+- lib/fastlane/plugin/firebase_management_api/version.rb
+homepage: https://github.com/morecreative-dev/fastlane-plugin-firebase_management_api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Unofficial tool to access Firebase project settings
+test_files: []