fastlane-plugin-sapfire 1.0.0

data/lib/fastlane/plugin/sapfire/actions/ensure_dotnet_version_action.rb

@@ -0,0 +1,123 @@
+require "open3"
+require_relative "../helper/sapfire_helper"
+
+module Fastlane
+  module Actions
+    class EnsureDotnetVersionAction < Action
+      def self.run(params)
+        UI.user_error!("Can't find dotnet") unless Helper::SapfireHelper.dotnet_specified?
+
+        dotnet_path = Actions.lane_context[SharedValues::SF_DOTNET_PATH]
+        cmd = "\"#{dotnet_path}\" --list-sdks"
+
+        UI.command(cmd)
+        stdin, stdout = Open3.popen2(cmd)
+        output = stdout.read
+        stdin.close
+        stdout.close
+
+        versions = output.split("\n")
+        available_versions = []
+        current_version = nil
+        required_version = nil
+        found = false
+
+        begin
+          required_version = Gem::Version.new(params[:version])
+        rescue ArgumentError => ex
+          UI.user_error!("Invalid version number provided, make sure it's valid: #{ex}")
+        end
+
+        required_version_numbers = required_version.to_s.split(".")
+
+        versions.each do |value|
+          path_bracket_index = value.index("[")
+
+          begin
+            ver_number = value[0..path_bracket_index - 1].strip
+            current_version = Gem::Version.new(ver_number)
+            available_versions.append(current_version.to_s)
+          rescue ArgumentError => ex
+            UI.user_error!("Can't parse the version entry from dotnet output: #{ex}")
+          end
+
+          if params[:strict]
+            next unless current_version == required_version
+
+            success(required_version)
+          else
+            current_version_numbers = current_version.to_s.split(".")
+            all_correct = true
+
+            required_version_numbers.each_with_index do |required_version_number, index|
+              current_version_number = current_version_numbers[index]
+              next if required_version_number == current_version_number
+
+              all_correct = false
+              break
+            end
+
+            next unless all_correct
+
+            success(current_version)
+          end
+
+          found = true
+          break
+        end
+
+        error(required_version, available_versions) unless found
+      end
+
+      def self.success(version)
+        UI.success("Required .NET version has found: #{version}")
+      end
+
+      def self.error(version, available_versions)
+        str = [
+          "Required .NET version hasn't been found: #{version}",
+          "Available versions: #{available_versions}"
+        ].join("\n")
+
+        UI.user_error!(str)
+      end
+
+      def self.description
+        "Ensures the right version of .NET is installed and can be used"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :version,
+            description: ".NET version to verify that is installed",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("The version of .NET to check is empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :strict,
+            description: "Should the version be verified strictly (all 3 version numbers), or matching only the given version numbers (i.e. 6.0 == 6.0.x)",
+            optional: true,
+            default_value: true,
+            type: Boolean
+          )
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions/ms_credentials_action.rb

@@ -0,0 +1,91 @@
+require "fastlane/action"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SF_MS_USERNAME = :SF_MS_USERNAME
+      SF_MS_PASSWORD = :SF_MS_PASSWORD
+      SF_MS_TENANT_ID = :SF_MS_TENANT_ID
+      SF_MS_CLIENT_ID = :SF_MS_CLIENT_ID
+      SF_MS_CLIENT_SECRET = :SF_MS_CLIENT_SECRET
+    end
+
+    class MsCredentialsAction < Action
+      def self.run(params)
+        Actions.lane_context[SharedValues::SF_MS_USERNAME] = params[:username]
+        Actions.lane_context[SharedValues::SF_MS_PASSWORD] = params[:password]
+        Actions.lane_context[SharedValues::SF_MS_TENANT_ID] = params[:tenant_id]
+        Actions.lane_context[SharedValues::SF_MS_CLIENT_ID] = params[:client_id]
+        Actions.lane_context[SharedValues::SF_MS_CLIENT_SECRET] = params[:client_secret]
+
+        UI.success("Credentials for Azure AD account is successfully saved for further actions")
+      end
+
+      def self.description
+        "Sets Azure AD account credentials"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:windows].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :username,
+            description: "The username of Azure AD account",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Microsoft username can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :password,
+            description: "The password of Azure AD account",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Microsoft password can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :tenant_id,
+            description: "The unique identifier of the Azure AD instance",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Tenant ID can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :client_id,
+            description: "The ID of an application that would be associate to get working with Microsoft account",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Client ID can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :client_secret,
+            description: "The unique secret string of an application that can be generated in Microsoft Partner Center",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Client secret string can't be empty") unless value && !value.empty?
+            end
+          )
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions/msbuild_action.rb

@@ -0,0 +1,45 @@
+require "fastlane/action"
+require_relative "../msbuild/options"
+require_relative "../msbuild/module"
+require_relative "../actions_base/msbuild_action_base"
+
+module Fastlane
+  module Actions
+    class MsbuildAction < MsbuildActionBase
+      def self.run(params)
+        Msbuild.config.certificate = nil
+        Msbuild.config.certificate_password = nil
+        Msbuild.config.certificate_thumbprint = nil
+        Msbuild.config.build_type = Msbuild::BuildType::GENERIC
+
+        super(params)
+      end
+
+      def self.description
+        "Executes MSBuild to build the application"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.rejected_options
+        %i[
+          appx_output_path
+          appx_output_name
+          appx_bundle_platforms
+          build_mode
+          skip_codesigning
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions/msbuild_select_action.rb

@@ -0,0 +1,53 @@
+require "fastlane/action"
+require_relative "../msbuild/module"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SF_MSBUILD_PATH = :SF_MSBUILD_PATH
+      SF_MSBUILD_TYPE = :SF_MSBUILD_TYPE
+    end
+
+    class MsbuildSelectAction < Action
+      def self.run(params)
+        path = (params || []).first.to_s
+        path = File.expand_path(path)
+
+        UI.user_error!("File '#{path}' doesn't exist") unless File.exist?(path)
+        UI.user_error!("Path to MSBuild executable or library required") if
+          path.empty? || (!path.end_with?("MSBuild.exe") && !path.end_with?("MSBuild.dll"))
+
+        Actions.lane_context[SharedValues::SF_MSBUILD_PATH] = path
+        Actions.lane_context[SharedValues::SF_MSBUILD_TYPE] = if path.end_with?("MSBuild.exe")
+                                                                Msbuild::MsbuildType::EXE
+                                                              else
+                                                                Msbuild::MsbuildType::LIBRARY
+                                                              end
+
+        UI.message("Setting MSBuild executable to '#{path}' for all next build steps")
+      end
+
+      def self.description
+        "Changes the MSBuild executable to use. Useful if you have multiple installed versions."
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'msbuild_select("/cygdrive/c/Program\ Files/Microsoft\ Visual\ Studio/2022/Community/Msbuild/Current/Bin/MSBuild.exe")'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions/nuget_pack_action.rb

@@ -0,0 +1,46 @@
+require "fastlane/action"
+require_relative "../msbuild/options"
+require_relative "../msbuild/module"
+require_relative "../actions_base/msbuild_action_base"
+
+module Fastlane
+  module Actions
+    class NugetPackAction < MsbuildActionBase
+      def self.run(params)
+        Msbuild.config.certificate = nil
+        Msbuild.config.certificate_password = nil
+        Msbuild.config.certificate_thumbprint = nil
+        Msbuild.config.build_type = Msbuild::BuildType::NUGET
+
+        super(params)
+      end
+
+      def self.description
+        "Executes MSBuild to create a NuGet package"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.rejected_options
+        %i[
+          restore
+          appx_output_path
+          appx_output_name
+          appx_bundle_platforms
+          build_mode
+          skip_codesigning
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions/update_uwp_signing_settings_action.rb

@@ -0,0 +1,73 @@
+require "fastlane/action"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SF_CERTIFICATE_PATH = :SF_CERTIFICATE_PATH
+      SF_CERTIFICATE_PASSWORD = :SF_CERTIFICATE_PASSWORD
+      SF_CERTIFICATE_THUMBPRINT = :SF_CERTIFICATE_THUMBPRINT
+    end
+
+    class UpdateUwpSigningSettingsAction < Action
+      def self.run(params)
+        path = params[:certificate]
+
+        Actions.lane_context[SharedValues::SF_CERTIFICATE_PATH] = path
+        Actions.lane_context[SharedValues::SF_CERTIFICATE_PASSWORD] = params[:password]
+        Actions.lane_context[SharedValues::SF_CERTIFICATE_THUMBPRINT] = params[:thumbprint]
+
+        UI.message("Setting signing certificate to '#{path}' for all next build steps")
+      end
+
+      def self.description
+        "Configures UWP package signing settings. Works only on 'windows' platform. Values that would be set in this action will be applied to all next actions."
+      end
+
+      def self.details
+        "Works only on `windows` platform"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:windows].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :certificate,
+            description: "Path to the certificate to use",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Path to certificate is invalid") unless value && !value.empty?
+              UI.user_error!("The provided path doesn't point to PFX-file") unless
+                File.exist?(File.expand_path(value)) && value.end_with?(".pfx")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :password,
+            description: "The password for the private key in the certificate",
+            optional: true,
+            default_value: "",
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :thumbprint,
+            description: "This value must match the thumbprint in the signing certificate or be an empty string",
+            optional: true,
+            default_value: "",
+            type: String
+          )
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions/upload_ms_store_action.rb

@@ -0,0 +1,218 @@
+require "fastlane/action"
+require_relative "../helper/ms_devcenter_helper"
+require_relative "../msbuild/options"
+
+module Fastlane
+  module Actions
+    class UploadMsStoreAction < Action
+      DEFAULT_TIMEOUT = 300
+
+      def self.run(params)
+        tenant_id = Actions.lane_context[SharedValues::SF_MS_TENANT_ID]
+        client_id = Actions.lane_context[SharedValues::SF_MS_CLIENT_ID]
+        client_secret = Actions.lane_context[SharedValues::SF_MS_CLIENT_SECRET]
+        app_id = params[:app_id]
+        path = params[:path]
+        timeout = params.values.include?(:timeout) && params[:timeout].positive? ? params[:timeout] : DEFAULT_TIMEOUT
+
+        UI.message("Acquiring authorization token for DevCenter ...")
+        auth_token = Helper::MsDevCenterHelper.acquire_authorization_token(tenant_id, client_id, client_secret, timeout)
+        UI.message("Authorization token was obtained")
+
+        UI.message("Creating submission for app #{app_id} ...")
+        submission_obj = Helper::MsDevCenterHelper.create_submission(app_id, auth_token, timeout)
+        submission_id = submission_obj["id"]
+        UI.message("Submission #{submission_id} created")
+
+        UI.message("Prepare ZIP blob for upload ...")
+        zip_path = create_blob_zip(File.expand_path(path))
+        UI.success("Blob is ready")
+
+        UI.message("Uploading ZIP blob ...")
+        Helper::MsDevCenterHelper.upload_blob(submission_obj["fileUploadUrl"], zip_path, timeout)
+        UI.success("ZIP blob uploaded successfully")
+
+        submission_obj = prepare_empty_submission(submission_obj)
+        submission_obj = add_package_to_submission(submission_obj, File.basename(path))
+
+        UI.message("Updating submission data ...")
+        Helper::MsDevCenterHelper.update_submission(app_id, submission_obj, auth_token, timeout)
+        UI.message("Updated successfully")
+
+        UI.message("Committing ...")
+        Helper::MsDevCenterHelper.commit_submission(app_id, submission_id, auth_token, timeout)
+
+        if params.values.include?(:skip_waiting_for_build_processing) &&
+           [true].include?(params[:skip_waiting_for_build_processing])
+          UI.success("Submission passed, but build processing were skipped. Check the Dev Center page.")
+          return
+
+        end
+
+        status = false
+        data = nil
+        until status
+          UI.message("Waiting for the submission to change the status - this may take a few minutes")
+          data = Helper::MsDevCenterHelper.get_submission_status(app_id, submission_id, auth_token, timeout)
+          status = data["status"] != "CommitStarted"
+          sleep(30) unless status
+        end
+
+        if data["status"] == "CommitFailed"
+          errors = data["statusDetails"]["errors"]
+          if errors.length == 1 && errors[0]["code"] == "InvalidState"
+            UI.important(
+              [
+                "All submission operations passed correctly, but there are some things that you need to proceed using DevCenter.",
+                "Message: #{errors[0]["details"]}"
+              ].join("\n")
+            )
+            return
+          end
+
+          errors.each do |error|
+            UI.error("Error code: #{error["code"]}\nMessage: #{error["details"]}")
+          end
+
+          UI.user_error!("Submission failed")
+        end
+
+        UI.success("Submission passed. Check the DevCenter page.")
+      end
+
+      def self.description
+        "Uploads new binary to Microsoft Partner Center"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:windows].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :timeout,
+            description: "The timeout for pushing to a server in seconds",
+            optional: true,
+            default_value: 0,
+            type: Integer
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :app_id,
+            description: "The Microsoft Store ID of an application",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("The Microsoft Store ID can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :skip_waiting_for_build_processing,
+            description: "If set to true, the action will only commit the submission and skip the remaining build validation",
+            optional: true,
+            default_value: false,
+            type: Fastlane::Boolean
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :path,
+            description: "The file path to the package to be uploaded",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Path to UWP package is invalid") unless value && !value.empty?
+
+              format_valid = false
+              Msbuild::Options::PACKAGE_FORMATS.each do |extension|
+                if value.end_with?(extension)
+                  format_valid = true
+                  break
+                end
+              end
+
+              UI.user_error!("The provided path doesn't point to UWP file") unless
+                File.exist?(File.expand_path(value)) && format_valid
+            end
+          )
+        ]
+      end
+
+      def self.category
+        :production
+      end
+
+      def self.create_blob_zip(package_path)
+        File.delete(File.join(File.dirname(package_path), "blob.zip"))
+        zip_path = File.join(File.dirname(package_path), "blob.zip")
+
+        Zip::File.open(zip_path, create: true) do |file|
+          file.add(File.basename(package_path), package_path)
+
+          screenshot_path = File.join(Helper::SapfireHelper.root_plugin_location, "assets", "ms_example_screenshot.png")
+          file.add("ms_example_screenshot.png", File.expand_path(screenshot_path))
+        end
+
+        zip_path
+      end
+
+      def self.add_package_to_submission(submission_obj, file_name)
+        check_submission(submission_obj)
+        UI.user_error!("Package file name can't be null or empty") if file_name.nil? || file_name.empty?
+
+        key = "applicationPackages"
+        package = {
+          "fileName": file_name,
+          "fileStatus": "PendingUpload",
+          "minimumDirectXVersion": "None",
+          "minimumSystemRam": "None"
+        }
+
+        submission_obj[key] = [] if submission_obj[key].empty?
+        submission_obj[key].append(package)
+        submission_obj
+      end
+
+      def self.prepare_empty_submission(submission_obj)
+        check_submission(submission_obj)
+
+        submission_obj["applicationCategory"] = "UtilitiesAndTools" if submission_obj["applicationCategory"] == "NotSet"
+        submission_obj["targetPublishMode"] = "Manual"
+
+        if submission_obj["allowTargetFutureDeviceFamilies"].empty?
+          submission_obj["allowTargetFutureDeviceFamilies"] = {
+            "Desktop": false,
+            "Mobile": false,
+            "Holographic": false,
+            "Xbox": false
+          }
+        end
+
+        if submission_obj["listings"].empty?
+          submission_obj["listings"]["en-us"] = {}
+          submission_obj["listings"]["en-us"]["baseListing"] = {
+            "description": "1",
+            "privacyPolicy": "https://example.com",
+            "images": [
+              {
+                "fileName": "ms_example_screenshot.png",
+                "fileStatus": "PendingUpload",
+                "imageType": "Screenshot"
+              }
+            ]
+          }
+        end
+
+        submission_obj
+      end
+
+      def self.check_submission(submission_obj)
+        UI.user_error!("Submission data object need to be provided") if submission_obj.nil?
+      end
+
+      private_constant(:DEFAULT_TIMEOUT)
+    end
+  end
+end