fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/get_info_plist_value.rb

@@ -0,0 +1,78 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      GET_INFO_PLIST_VALUE_CUSTOM_VALUE = :GET_INFO_PLIST_VALUE_CUSTOM_VALUE
+    end
+
+    class GetInfoPlistValueAction < Action
+      def self.run(params)
+        require "plist"
+
+        begin
+          path = File.expand_path(params[:path])
+
+          plist = File.open(path) { |f| Plist.parse_xml(f) }
+
+          value = plist[params[:key]]
+          Actions.lane_context[SharedValues::GET_INFO_PLIST_VALUE_CUSTOM_VALUE] = value
+
+          return value
+        rescue => ex
+          UI.error(ex)
+        end
+      end
+
+      def self.description
+        "Returns value from Info.plist of your project as native Ruby data structures"
+      end
+
+      def self.details
+        "Get a value from a plist file, which can be used to fetch the app identifier and more information about your app"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :key,
+                                       env_name: "FL_GET_INFO_PLIST_PARAM_NAME",
+                                       description: "Name of parameter",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_GET_INFO_PLIST_PATH",
+                                       description: "Path to plist file you want to read",
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find plist file at path '#{value}'") unless File.exist?(value)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['GET_INFO_PLIST_VALUE_CUSTOM_VALUE', 'The value of the last plist file that was parsed']
+        ]
+      end
+
+      def self.authors
+        ["kohtenko"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'identifier = get_info_plist_value(path: "./Info.plist", key: "CFBundleIdentifier")'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_ipa_info_plist_value.rb

@@ -0,0 +1,82 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      GET_IPA_INFO_PLIST_VALUE_CUSTOM_VALUE = :GET_IPA_INFO_PLIST_VALUE_CUSTOM_VALUE
+    end
+
+    class GetIpaInfoPlistValueAction < Action
+      def self.run(params)
+        ipa = File.expand_path(params[:ipa])
+        key = params[:key]
+        plist = FastlaneCore::IpaFileAnalyser.fetch_info_plist_file(ipa)
+        value = plist[key]
+
+        Actions.lane_context[SharedValues::GET_IPA_INFO_PLIST_VALUE_CUSTOM_VALUE] = value
+
+        return value
+      rescue => ex
+        UI.error(ex)
+        UI.error("Unable to find plist file at '#{ipa}'")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Returns a value from Info.plist inside a .ipa file"
+      end
+
+      def self.details
+        "This is useful for introspecting Info.plist files for `.ipa` files that have already been built."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :key,
+                                       env_name: "FL_GET_IPA_INFO_PLIST_VALUE_KEY",
+                                       description: "Name of parameter",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: "FL_GET_IPA_INFO_PLIST_VALUE_IPA",
+                                       description: "Path to IPA",
+                                       is_string: true,
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['GET_IPA_INFO_PLIST_VALUE_CUSTOM_VALUE', 'The value of the last plist file that was parsed']
+        ]
+      end
+
+      def self.return_value
+        "Returns the value in the .ipa's Info.plist corresponding to the passed in Key"
+      end
+
+      def self.authors
+        ["johnboiles"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'get_ipa_info_plist_value(ipa: "path.ipa", key: "KEY_YOU_READ")'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_managed_play_store_publishing_rights.rb

@@ -0,0 +1,120 @@
+module Fastlane
+  module Actions
+    class GetManagedPlayStorePublishingRightsAction < Action
+      def self.run(params)
+        unless params[:json_key] || params[:json_key_data]
+          UI.important("To not be asked about this value, you can specify it using 'json_key'")
+          json_key_path = UI.input("The service account json file used to authenticate with Google: ")
+          json_key_path = File.expand_path(json_key_path)
+
+          UI.user_error!("Could not find service account json file at path '#{json_key_path}'") unless File.exist?(json_key_path)
+          params[:json_key] = json_key_path
+        end
+
+        FastlaneCore::PrintTable.print_values(
+          config: params,
+          mask_keys: [:json_key_data],
+          title: "Summary for get_managed_play_store_publishing_rights"
+        )
+
+        if (keyfile = params[:json_key])
+          json_key_data = File.open(keyfile, 'rb').read
+        else
+          json_key_data = params[:json_key_data]
+        end
+
+        # Login
+        credentials = JSON.parse(json_key_data)
+        callback_uri = 'https://fastlane.github.io/managed_google_play-callback/callback.html'
+        uri = "https://play.google.com/apps/publish/delegatePrivateApp?service_account=#{credentials['client_email']}&continueUrl=#{URI.escape(callback_uri)}"
+
+        UI.message("To obtain publishing rights for custom apps on Managed Play Store, open the following URL and log in:")
+        UI.message("")
+        UI.important(uri)
+        UI.message("([Cmd/Ctrl] + [Left click] lets you open this URL in many consoles/terminals/shells)")
+        UI.message("")
+        UI.message("After successful login you will be redirected to a page which outputs some information that is required for usage of the `create_app_on_managed_play_store` action.")
+
+        return uri
+      end
+
+      def self.description
+        "Obtain publishing rights for custom apps on Managed Google Play Store"
+      end
+
+      def self.authors
+        ["janpio"]
+      end
+
+      def self.return_value
+        "An URI to obtain publishing rights for custom apps on Managed Play Store"
+      end
+
+      def self.details
+        [
+          'If you haven\'t done so before, start by following the first two steps of Googles ["Get started with custom app publishing"](https://developers.google.com/android/work/play/custom-app-api/get-started) -> ["Preliminary setup"](https://developers.google.com/android/work/play/custom-app-api/get-started#preliminary_setup) instructions:',
+          '"[Enable the Google Play Custom App Publishing API](https://developers.google.com/android/work/play/custom-app-api/get-started#enable_the_google_play_custom_app_publishing_api)" and "[Create a service account](https://developers.google.com/android/work/play/custom-app-api/get-started#create_a_service_account)".',
+          'You need the "service account\'s private key file" to continue.',
+          'Run the action and supply the "private key file" to it as the `json_key` parameter. The command will output a URL to visit. After logging in you are redirected to a page that outputs your "Developer Account ID" - take note of that, you will need it to be able to use [`create_app_on_managed_play_store`](https://docs.fastlane.tools/actions/create_app_on_managed_play_store/).'
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'get_managed_play_store_publishing_rights(
+            json_key: "path/to/your/json/key/file"
+          )
+          # it is probably easier to execute this action directly in the command line:
+          # $ fastlane run get_managed_play_store_publishing_rights'
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :json_key,
+            env_name: "SUPPLY_JSON_KEY",
+            short_option: "-j",
+            conflicting_options: [:json_key_data],
+            optional: true, # optional until it is possible specify either json_key OR json_key_data are required
+            description: "The path to a file containing service account JSON, used to authenticate with Google",
+            code_gen_sensitive: true,
+            default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_file),
+            default_value_dynamic: true,
+            verify_block: proc do |value|
+              UI.user_error!("Could not find service account json file at path '#{File.expand_path(value)}'") unless File.exist?(File.expand_path(value))
+              UI.user_error!("'#{value}' doesn't seem to be a JSON file") unless FastlaneCore::Helper.json_file?(File.expand_path(value))
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :json_key_data,
+            env_name: "SUPPLY_JSON_KEY_DATA",
+            short_option: "-c",
+            conflicting_options: [:json_key],
+            optional: true,
+            description: "The raw service account JSON data used to authenticate with Google",
+            code_gen_sensitive: true,
+            default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_data_raw),
+            default_value_dynamic: true,
+            verify_block: proc do |value|
+              begin
+                JSON.parse(value)
+              rescue JSON::ParserError
+                UI.user_error!("Could not parse service account json: JSON::ParseError")
+              end
+            end
+          )
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_provisioning_profile.rb

@@ -0,0 +1,100 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SIGH_PROFILE_PATH = :SIGH_PROFILE_PATH
+      SIGH_PROFILE_PATHS = :SIGH_PROFILE_PATHS
+      SIGH_UDID = :SIGH_UDID # deprecated
+      SIGH_UUID = :SIGH_UUID
+      SIGH_NAME = :SIGH_NAME
+      SIGH_PROFILE_TYPE = :SIGH_PROFILE_TYPE
+    end
+
+    class GetProvisioningProfileAction < Action
+      def self.run(values)
+        require 'sigh'
+        require 'credentials_manager/appfile_config'
+
+        Sigh.config = values # we already have the finished config
+
+        path = Sigh::Manager.start
+
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATH] = path # absolute path
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATHS] ||= []
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATHS] << path
+
+        uuid = ENV["SIGH_UUID"] || ENV["SIGH_UDID"] # the UUID of the profile
+        name = ENV["SIGH_NAME"] # the name of the profile
+        Actions.lane_context[SharedValues::SIGH_UUID] = Actions.lane_context[SharedValues::SIGH_UDID] = uuid if uuid
+        Actions.lane_context[SharedValues::SIGH_NAME] = Actions.lane_context[SharedValues::SIGH_NAME] = name if name
+
+        set_profile_type(values, ENV["SIGH_PROFILE_ENTERPRISE"])
+
+        return uuid # returs uuid of profile
+      end
+
+      def self.set_profile_type(values, enterprise)
+        profile_type = "app-store"
+        profile_type = "ad-hoc" if values[:adhoc]
+        profile_type = "development" if values[:development]
+        profile_type = "developer-id" if values[:developer_id]
+        profile_type = "enterprise" if enterprise
+
+        UI.message("Setting Provisioning Profile type to '#{profile_type}'")
+
+        Actions.lane_context[SharedValues::SIGH_PROFILE_TYPE] = profile_type
+      end
+
+      def self.description
+        "Generates a provisioning profile, saving it in the current folder (via _sigh_)"
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      # rubocop:disable Lint/MissingKeysOnSharedArea
+      def self.output
+        [
+          ['SIGH_PROFILE_PATH', 'A path in which certificates, key and profile are exported'],
+          ['SIGH_PROFILE_PATHS', 'Paths in which certificates, key and profile are exported'],
+          ['SIGH_UUID', 'UUID (Universally Unique IDentifier) of a provisioning profile'],
+          ['SIGH_NAME', 'The name of the profile'],
+          ['SIGH_PROFILE_TYPE', 'The profile type, can be appstore, adhoc, development, enterprise']
+        ]
+      end
+
+      def self.return_value
+        "The UUID of the profile sigh just fetched/generated"
+      end
+
+      def self.details
+        "**Note**: It is recommended to use [match](https://docs.fastlane.tools/actions/match/) according to the [codesigning.guide](https://codesigning.guide) for generating and maintaining your provisioning profiles. Use _sigh_ directly only if you want full control over what's going on and know more about codesigning."
+      end
+
+      def self.available_options
+        require 'sigh'
+        Sigh::Options.available_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'get_provisioning_profile',
+          'sigh # alias for "get_provisioning_profile"',
+          'get_provisioning_profile(
+            adhoc: true,
+            force: true,
+            filename: "myFile.mobileprovision"
+          )'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_push_certificate.rb

@@ -0,0 +1,87 @@
+module Fastlane
+  module Actions
+    class GetPushCertificateAction < Action
+      def self.run(params)
+        require 'pem'
+        require 'pem/options'
+        require 'pem/manager'
+
+        success_block = params[:new_profile]
+
+        PEM.config = params
+
+        if Helper.test?
+          profile_path = './test.pem'
+        else
+          profile_path = PEM::Manager.start
+        end
+
+        if success_block && profile_path
+          success_block.call(File.expand_path(profile_path)) if success_block
+        end
+      end
+
+      def self.description
+        "Ensure a valid push profile is active, creating a new one if needed (via _pem_)"
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.details
+        sample = <<-SAMPLE.markdown_sample
+          ```ruby
+          get_push_certificate(
+            new_profile: proc do
+              # your upload code
+            end
+          )
+          ```
+        SAMPLE
+
+        [
+          "Additionally to the available options, you can also specify a block that only gets executed if a new profile was created. You can use it to upload the new profile to your server.",
+          "Use it like this:".markdown_preserve_newlines,
+          sample
+        ].join("\n")
+      end
+
+      def self.available_options
+        require 'pem'
+        require 'pem/options'
+
+        @options = PEM::Options.available_options
+        @options << FastlaneCore::ConfigItem.new(key: :new_profile,
+                                     description: "Block that is called if there is a new profile",
+                                     optional: true,
+                                     is_string: false)
+        @options
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'get_push_certificate',
+          'pem # alias for "get_push_certificate"',
+          'get_push_certificate(
+            force: true, # create a new profile, even if the old one is still valid
+            app_identifier: "net.sunapps.9", # optional app identifier,
+            save_private_key: true,
+            new_profile: proc do |profile_path| # this block gets called when a new profile was generated
+              puts profile_path # the absolute path to the new PEM file
+              # insert the code to upload the PEM file to the server
+            end
+          )'
+        ]
+      end
+
+      def self.category
+        :push
+      end
+    end
+  end
+end