fastlane-plugin-sapfire 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e3383a3f917a4dba8d2c43dfdbbf597d1f29e6770d4f6f799b8fc1725a056b5
+  data.tar.gz: 69ab3275172df5edcecc365f8202f40c145d31bb690cf7a8e8a322d9499ee526
+SHA512:
+  metadata.gz: 79f0683b16c2684293d88eaa4a1b4d0327034120e4af61cc7903a28359d6eb217eceb6a5a1f1467b7dab2b38ddb20b7b5c01d1970d32ad3e402cf1a6c16a0275
+  data.tar.gz: f45c506a139c7020e5eac351b8884c46a5258a43c92968436bc36c28832cd570b461dc5d3813d9d0c3816e6999d3548d06917bc45e0e07ecdf1acfd246e36bfb

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexander Pluzhnikov
+
+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,135 @@
+<p align="center">
+    <a href="#">
+        <img src="https://raw.githubusercontent.com/CheeryLee/fastlane-plugin-sapfire/master/assets/sapfire_logo.png" height="150" />
+    </a>
+</p>
+
+# Sapfire
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![GitHub release (latest by date)](https://img.shields.io/github/v/release/CheeryLee/fastlane-plugin-sapfire?display_name=tag)
+
+<br/>
+<p align="center">An incredibly simple and fast way to automate building and deployment <b>Visual C++</b>, <b>.NET</b> and <b>UWP</b> apps</p>
+<br/>
+
+## What is it?
+_Sapfire_ is a fastlane plugin that provides a bunch of actions to work with MSBuild, NuGet and Microsoft Store app submission.
+
+**MSBuild** is a set of open-source build tools created by Microsoft. It is included with Visual Studio,
+but also can be used independently via command-line interface.
+
+**NuGet** is a package manager,  primarily used for packaging and distributing software written using the .NET.
+
+**Microsoft Store** is a digital distribution platform for Windows.
+
+## Getting started
+To get started working with plugin, add it to your `fastlane/Pluginfile`:
+```ruby
+gem "fastlane-plugin-sapfire", git: "https://github.com/fastlane/fastlane-plugin-sapfire" 
+```
+
+## Usage
+### Platform support note
+First of all it's important to denote that some of actions or their parameters (such as `msbuild` for UWP) are working
+on Windows only. Currently _fastlane_ is not officially supported on this platform. Despite this fact it's still possible to run it.
+
+Actions or parameters with such restriction contain the corresponding mark in documentation.
+
+If you want to use them, be sure that the platform name of the build lanes is **windows**:
+```ruby
+platform :windows do
+  # your lanes
+end
+```
+
+### Help
+Once installed, the information for an action can be printed out with this command:
+```shell
+fastlane action msbuild # or any action included with this plugin
+```
+
+### Actions
+Here is the list of all available actions. Read the documentation on each one by clicking on the action name.
+
+#### 🔨 Building
+
+| Argument                                                       | Description                                                       | Supported platforms |
+|----------------------------------------------------------------|-------------------------------------------------------------------|--------------------:|
+| [msbuild_select](docs/actions/msbuild_select.md)               | Changes the MSBuild executable to use                             |                 all |
+| [msbuild](docs/actions/msbuild.md)                             | Wraps all parameters and executes MSBuild                         |                 all |
+| [build_uwp_app](docs/actions/build_uwp_app.md)                 | Alias for the `msbuild` action with additional parameters for UWP |             windows |
+| [dotnet_select](docs/actions/dotnet_select.md)                 | Changes the dotnet executable to use                              |                 all |
+| [ensure_dotnet_version](docs/actions/ensure_dotnet_version.md) | Ensures the right version of .NET is installed and can be used    |                 all |
+| [associate_ms_store](docs/actions/associate_ms_store.md)       | Makes a local app manifest needed for Microsoft Store association |             windows |
+| [nuget_pack](docs/actions/nuget_pack.md)                       | Executes MSBuild to create a NuGet package                        |                 all |
+
+#### 🔑 Signing
+
+| Argument                                                                   | Description                             | Supported platforms |
+|----------------------------------------------------------------------------|-----------------------------------------|--------------------:|
+| [update_uwp_signing_settings](docs/actions/update_uwp_signing_settings.md) | Configures UWP package signing settings |             windows |
+
+#### 🔧 Testing
+
+| Argument                                               | Description                                                                 | Supported platforms |
+|--------------------------------------------------------|-----------------------------------------------------------------------------|--------------------:|
+| [app_certification](docs/actions/app_certification.md) | Runs Windows App Certification Kit to ensure your app is safe and efficient |             windows |
+
+
+#### 📦 Releasing
+
+| Argument                                           | Description                                     | Supported platforms |
+|----------------------------------------------------|-------------------------------------------------|--------------------:|
+| [upload_ms_store](docs/actions/upload_ms_store.md) | Uploads new binary to Microsoft Partner Center  |             windows |
+| [upload_nuget](docs/actions/upload_nuget.md)       | Pushes a package to the server and publishes it |                 all |
+
+#### 🔆 Misc
+
+| Argument                                         | Description                                   | Supported platforms |
+|--------------------------------------------------|-----------------------------------------------|--------------------:|
+| [ms_credentials](docs/actions/ms_credentials.md) | Sets Azure AD credentials for further actions |             windows |
+
+
+## Working with SLN solution
+In addition this plugin provides a parser module for Microsoft SLN file format.
+
+To open a solution, run this:
+
+```ruby
+require "fastlane/plugin/sapfire/sln_project/sln_project"
+
+root_block = Module.open("/cygdrive/c/Projects/My_Project.sln")
+puts root_block.projects[0] # print name of the first subproject in solution
+```
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```shell
+rake
+```
+
+To automatically fix many of the styling issues, use
+```shell
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please open a [GitHub issue](https://github.com/CheeryLee/fastlane-plugin-sapfire/issues).
+
+## 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).
+
+## License
+This project is licensed under [the MIT license](LICENSE).

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

@@ -0,0 +1,79 @@
+require "fastlane/action"
+require_relative "../helper/sapfire_helper"
+
+module Fastlane
+  module Actions
+    class AppCertificationAction < Action
+      def self.run(params)
+        path = Helper::SapfireHelper.kits_10_location
+        UI.user_error!("Can't locate Windows SDK. Ensure it's installed.") if path.empty?
+        UI.message("Windows SDK path: #{path}")
+
+        appcert_path = File.join(path, "App Certification Kit/appcert.exe")
+        UI.user_error!("Can't find appcert.exe. Check your Windows SDK installation.") unless File.exist?(appcert_path)
+
+        cmd = "\"#{appcert_path}\" reset"
+        UI.command(cmd)
+        wait_thr = run_appcert(cmd)
+        UI.user_error!("Appcert reset failed. See the log above.") unless wait_thr.value.success?
+
+        cmd = "\"#{appcert_path}\" test -appxpackagepath \"#{params[:appx_package_path]}\" -reportoutputpath \"#{params[:output_path]}\""
+        UI.command(cmd)
+        wait_thr = run_appcert(cmd)
+        UI.user_error!("Appcert checking failed. See the log above.") unless wait_thr.value.success?
+        UI.success("App checking has successfully finished. Output result saved at: #{params[:output_path]}") if wait_thr.value.success?
+      end
+
+      def self.description
+        "Runs Windows App Certification Kit to ensure your app is safe and efficient before publishing it to Microsoft Store"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:windows].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :appx_package_path,
+            description: "The full path to a UWP package",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Path to UWP package is invalid") unless value && !value.empty?
+              UI.user_error!("The provided path doesn't point to APPX-file") unless
+                File.exist?(File.expand_path(value)) && value.end_with?(".appx")
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :output_path,
+            description: "The path where to save report output XML-file",
+            optional: false,
+            type: String
+          )
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.run_appcert(cmd)
+        Open3.popen2(cmd) do |_, stdout, wait_thr|
+          until stdout.eof?
+            stdout.each do |l|
+              line = l.force_encoding("utf-8").chomp
+              puts line
+            end
+          end
+
+          wait_thr
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+require "uri"
+require "net/http"
+require "json"
+require "fastlane/action"
+
+module Fastlane
+  module Actions
+    class AssociateMsStoreAction < Action
+      XML_NAME = "Package.StoreAssociation.xml".freeze
+
+      def self.run(params)
+        FastlaneCore::PrintTable.print_values(config: params, title: "Summary for associate_ms_store")
+
+        begin
+          UI.message("Creating #{XML_NAME}...")
+
+          token = acquire_authorization_token
+          developer_info = get_developer_info(token)
+          app_info = get_app_info(token, params[:app_id])
+          create_xml(params[:manifest], developer_info, app_info)
+
+          UI.message("#{XML_NAME} successfully created")
+        rescue StandardError => ex
+          UI.user_error!("Something went wrong while associating the project: #{ex}")
+        end
+      end
+
+      def self.create_xml(manifest_path, developer_info, app_info)
+        app_identity = app_info[:identity]
+        app_names = app_info[:names]
+        publisher = developer_info[:publisher]
+        publisher_display_name = developer_info[:display_name]
+        appxmanifest_xml = get_appxmanifest_xml(manifest_path)
+
+        UI.message("Set identity name: #{app_identity}")
+
+        begin
+          identity_entry = appxmanifest_xml.elements["Package"]
+                                           .elements["Identity"]
+          identity_entry.attributes["Name"] = app_identity
+          identity_entry.attributes["Publisher"] = publisher
+
+          properties_entry = appxmanifest_xml.elements["Package"]
+                                             .elements["Properties"]
+          properties_entry.elements["DisplayName"].text = app_names[0] unless app_names.empty?
+          properties_entry.elements["PublisherDisplayName"].text = publisher_display_name
+        rescue StandardError => ex
+          UI.user_error!("Can't update app manifest: #{ex}")
+        end
+
+        save_xml(appxmanifest_xml, manifest_path)
+
+        UI.message("Set publisher data: #{publisher}")
+        UI.message("Set publisher display name: #{publisher_display_name}")
+
+        document = REXML::Document.new
+        document.xml_decl.version = "1.0"
+        document.xml_decl.encoding = "utf-8"
+
+        store_association = document.add_element("StoreAssociation", {
+          "xmlns" => "http://schemas.microsoft.com/appx/2010/storeassociation"
+        })
+        store_association.add_element("Publisher").text = publisher
+        store_association.add_element("PublisherDisplayName").text = publisher_display_name
+        store_association.add_element("DeveloperAccountType").text = "WSA"
+        store_association.add_element("GeneratePackageHash").text = "http://www.w3.org/2001/04/xmlenc#sha256"
+
+        product_reserved_info = store_association.add_element("ProductReservedInfo")
+        product_reserved_info.add_element("MainPackageIdentityName").text = app_identity
+
+        reserved_names = product_reserved_info.add_element("ReservedNames")
+        app_names.each do |x|
+          reserved_names.add_element("ReservedName").text = x
+        end
+
+        working_directory = File.dirname(manifest_path)
+        path = File.join(working_directory, XML_NAME)
+        save_xml(document, path)
+      end
+
+      def self.get_appxmanifest_xml(manifest_path)
+        file = File.open(manifest_path, "r")
+
+        begin
+          document = REXML::Document.new(file)
+          file.close
+          document
+        rescue REXML::ParseException => ex
+          UI.user_error!("Can't parse Package.appxmanifest: #{ex}")
+        end
+      end
+
+      def self.save_xml(document, path)
+        file = File.open(path, "w")
+        document.write(file)
+        file.close
+      end
+
+      def self.get_developer_info(token)
+        UI.message("Obtaining developer info ...")
+
+        headers = {
+          "Authorization": "Bearer #{token}",
+          "Accept": "application/json",
+          "MS-Contract-Version": "1"
+        }
+        query = {
+          setvar: "fltaad:1"
+        }
+
+        uri = URI("https://developer.microsoft.com/vsapi/developer")
+        uri.query = URI.encode_www_form(query)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        request = Net::HTTP::Get.new(uri, headers)
+        response = https.request(request)
+
+        begin
+          data = JSON.parse(response.body)
+
+          if response.code == "200"
+            UI.message("Developer info was obtained")
+            return {
+              display_name: data["PublisherDisplayName"],
+              publisher: data["Publisher"]
+            }
+          end
+
+          UI.user_error!("Request returned the error: #{response.code}")
+        rescue StandardError => ex
+          UI.user_error!("Developer info request failed: #{ex}")
+        end
+      end
+
+      def self.get_app_info(token, app_id)
+        UI.message("Obtaining application info ...")
+
+        headers = {
+          "Authorization": "Bearer #{token}",
+          "Accept": "application/json",
+          "MS-Contract-Version": "1"
+        }
+        query = {
+          setvar: "fltaad:1"
+        }
+
+        uri = URI("https://developer.microsoft.com/vsapi/applications")
+        uri.query = URI.encode_www_form(query)
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        request = Net::HTTP::Get.new(uri, headers)
+        response = https.request(request)
+
+        begin
+          data = JSON.parse(response.body)
+
+          if response.code == "200"
+            UI.message("Application info was obtained")
+
+            product = data["Products"].find { |x| x["LandingUrl"].include?(app_id) }
+            return {
+              identity: product["MainPackageIdentityName"],
+              names: product["ReservedNames"]
+            }
+          end
+
+          UI.user_error!("Request returned the error: #{response.code}")
+        rescue StandardError => ex
+          UI.user_error!("Application info request failed: #{ex}")
+        end
+      end
+
+      def self.acquire_authorization_token
+        UI.message("Acquiring authorization token ...")
+
+        username = Actions.lane_context[SharedValues::SF_MS_USERNAME]
+        password = Actions.lane_context[SharedValues::SF_MS_PASSWORD]
+        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]
+
+        body = {
+          client_id: client_id,
+          client_secret: client_secret,
+          client_info: 1,
+          grant_type: "password",
+          scope: "https://management.azure.com/.default offline_access openid profile",
+          username: username,
+          password: password
+        }
+        headers = {
+          "x-anchormailbox": "upn:#{username}",
+          "x-client-sku": "fastlane-sapfire-plugin",
+          "Accept": "application/json"
+        }
+
+        uri = URI("https://login.microsoftonline.com/#{tenant_id}/oauth2/v2.0/token")
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+        request = Net::HTTP::Post.new(uri, headers)
+        request_body = URI.encode_www_form(body)
+        response = https.request(request, request_body)
+
+        begin
+          data = JSON.parse(response.body)
+
+          if response.code == "200"
+            UI.message("Authorization token was obtained")
+            return data["access_token"]
+          end
+
+          error = data["error"]
+          error_description = data["error_description"]
+
+          UI.user_error!("Request returned the error.\nCode: #{error}.\nDescription: #{error_description}")
+        rescue StandardError => ex
+          UI.user_error!("Authorization failed: #{ex}")
+        end
+      end
+
+      def self.description
+        "Makes a local app manifest needed for Microsoft Store association"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:windows].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :manifest,
+            description: "Path to the APPX package manifest",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Path to the APPX package manifest is invalid") unless value && !value.empty?
+              UI.user_error!("The provided path doesn't point to AppxManifest-file") unless
+                File.exist?(File.expand_path(value)) && value.end_with?(".appxmanifest")
+            end
+          ),
+          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
+          )
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require "fastlane/action"
+require_relative "../actions_base/msbuild_action_base"
+
+module Fastlane
+  module Actions
+    class BuildUwpAppAction < MsbuildActionBase
+      def self.run(params)
+        Msbuild.config.certificate = Actions.lane_context[SharedValues::SF_CERTIFICATE_PATH]
+        Msbuild.config.certificate_password = Actions.lane_context[SharedValues::SF_CERTIFICATE_PASSWORD]
+        Msbuild.config.certificate_thumbprint = Actions.lane_context[SharedValues::SF_CERTIFICATE_THUMBPRINT]
+        Msbuild.config.build_type = Msbuild::BuildType::UWP
+
+        super(params)
+      end
+
+      def self.overwritten_msbuild_properties
+        props = {
+          AppxPackageDir: "appx_output_path",
+          AppxBundlePlatforms: "appx_bundle_platforms",
+          UapAppxPackageBuildMode: "build_mode",
+          AppxPackageSigningEnabled: "skip_codesigning"
+        }
+        super.merge(props)
+      end
+
+      def self.description
+        "Alias for the `msbuild` action with additional parameters for UWP"
+      end
+
+      def self.details
+        [
+          "Works only on `windows` platform.",
+          "The `:platform` value must contain the same value as `:appx_bundle_platforms` does.",
+          "If `appx_bundle_platforms` is set to be multiplatform, then any of platforms from it's list must be set in the `:platform` option"
+        ].join("\n")
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:windows].include?(platform)
+      end
+
+      def self.rejected_options
+        nil
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "fastlane/action"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SF_DOTNET_PATH = :SF_DOTNET_PATH
+    end
+
+    class DotnetSelectAction < 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 dotnet executable required") if
+          path.empty? || (!path.end_with?("dotnet") && !path.end_with?("dotnet.exe"))
+
+        Actions.lane_context[SharedValues::SF_DOTNET_PATH] = path
+
+        UI.message("Setting dotnet executable to '#{path}' for all next build steps")
+      end
+
+      def self.description
+        "Changes the dotnet executable to use"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'dotnet_select("C:/Program\ Files/dotnet/dotnet.exe")'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end