fastlane-plugin-sapfire 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bdfb427e29ec64079d6c3a1331150a804195515abbc9a912ddee60ef702fb41
-  data.tar.gz: 7e7c780539d1764e6e69c9d1a1772b78240b8befafd5c0c8b391d9470505e915
+  metadata.gz: 1acba89a24594d75771baf331f21ee7edb48214dd46a7ac3d156a9cb69cb916d
+  data.tar.gz: '083e0a2bf42c6b47e5cd25498fce324ca8f148ad8731488971fca1fd105ab3f7'
 SHA512:
-  metadata.gz: 884d81bcc44c1c460b24e002e949c03cbd23183ec3c6750a1404f06d4ced9cdff3db6a3aed44e154bacab7ceab4624e44ca2097984c594952bac1f1b450c4128
-  data.tar.gz: 3aec682d1d9832129eae53ee8327ac4097b0f158950c7f6d0385a99c3e978af07be452d106fef132df5cbd6571a1becea813b42b94c5512b42148c4b562f84b1
+  metadata.gz: 0f6132a34df4a89c0e1d36e8a64c6fe51210741e762e9fa14f48d752e34823a2079f5a26fa1b8e77f9473bdb11c051f1d4023ed171dd5b6e64df7c35627c78ae
+  data.tar.gz: ea7ec418dc4687a371f58b64edfbcbc72511e801bbb26836c3d1d3590802cc557110e3e365562110642613ec62c35a2d44f440014cdfce8210a3a187f9fc873d

data/README.md

@@ -34,9 +34,13 @@ but also can be used independently via command-line interface.
 **Microsoft Store** is a digital distribution platform for Windows.
 
 ## Getting started
-To get started working with plugin, add it to your `fastlane/Pluginfile`:
+To get started working with plugin, add it to your project by running:
+```shell
+fastlane add_plugin sapfire
+```
+Or, if you want to pick the latest commit from the repository, add this to `fastlane/Pluginfile`:
 ```ruby
-gem "fastlane-plugin-sapfire", git: "https://github.com/fastlane/fastlane-plugin-sapfire" 
+gem "fastlane-plugin-sapfire", git: "https://github.com/fastlane/fastlane-plugin-sapfire.git" 
 ```
 
 ## Usage

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

@@ -2,10 +2,15 @@ require "uri"
 require "net/http"
 require "json"
 require "fastlane/action"
+require_relative "../helper/ms_credentials"
 
 module Fastlane
   module Actions
     class AssociateMsStoreAction < Action
+      @token = ""
+      @vsapi_host = ""
+      @vsapi_endpoint = ""
+
       XML_NAME = "Package.StoreAssociation.xml".freeze
 
       def self.run(params)
@@ -14,10 +19,11 @@ module Fastlane
         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)
+          acquire_authorization_token
+          acquire_vsapi_location
+          ms_developer_info = developer_info
+          ms_app_info = app_info(params[:app_id])
+          create_xml(params[:manifest], ms_developer_info, ms_app_info)
 
           UI.message("#{XML_NAME} successfully created")
         rescue StandardError => ex
@@ -26,50 +32,46 @@ module Fastlane
       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}")
+        UI.message("Set identity name: #{app_info.identity}")
 
         begin
           identity_entry = appxmanifest_xml.elements["Package"]
                                            .elements["Identity"]
-          identity_entry.attributes["Name"] = app_identity
-          identity_entry.attributes["Publisher"] = publisher
+          identity_entry.attributes["Name"] = app_info.identity
+          identity_entry.attributes["Publisher"] = developer_info.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
+          properties_entry.elements["DisplayName"].text = app_info.names[0] unless app_info.names.empty?
+          properties_entry.elements["PublisherDisplayName"].text = developer_info.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}")
+        UI.message("Set publisher data: #{developer_info.publisher}")
+        UI.message("Set publisher display name: #{developer_info.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_args = {
           "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 = document.add_element("StoreAssociation", xmlns_args)
+        store_association.add_element("Publisher").text = developer_info.publisher
+        store_association.add_element("PublisherDisplayName").text = developer_info.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
+        product_reserved_info.add_element("MainPackageIdentityName").text = app_info.identity
 
         reserved_names = product_reserved_info.add_element("ReservedNames")
-        app_names.each do |x|
+        app_info.names.each do |x|
           reserved_names.add_element("ReservedName").text = x
         end
 
@@ -96,72 +98,61 @@ module Fastlane
         file.close
       end
 
-      def self.get_developer_info(token)
+      def self.developer_info
         UI.message("Obtaining developer info ...")
 
         headers = {
-          "Authorization": "Bearer #{token}",
+          "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)
+        connection = Faraday.new(@vsapi_host)
 
         begin
-          data = JSON.parse(response.body)
+          response = connection.get("#{@vsapi_endpoint}/developer", query, headers)
+
+          if response.status == 200
+            data = JSON.parse(response.body)
+            developer_info = DeveloperInfo.new(data["PublisherDisplayName"], data["Publisher"])
 
-          if response.code == "200"
             UI.message("Developer info was obtained")
-            return {
-              display_name: data["PublisherDisplayName"],
-              publisher: data["Publisher"]
-            }
+
+            return developer_info
           end
 
-          UI.user_error!("Request returned the error: #{response.code}")
+          UI.user_error!("Request returned the error: #{response.status}")
         rescue StandardError => ex
           UI.user_error!("Developer info request failed: #{ex}")
         end
       end
 
-      def self.get_app_info(token, app_id)
+      def self.app_info(app_id)
         UI.message("Obtaining application info ...")
 
         headers = {
-          "Authorization": "Bearer #{token}",
+          "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)
+        connection = Faraday.new(@vsapi_host)
 
         begin
-          data = JSON.parse(response.body)
+          response = connection.get("#{@vsapi_endpoint}/applications", query, headers)
+
+          if response.status == 200
+            data = JSON.parse(response.body)
+            product = data["Products"].find { |x| x["LandingUrl"].include?(app_id) }
+            app_info = AppInfo.new(product["MainPackageIdentityName"], product["ReservedNames"])
 
-          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"]
-            }
+            return app_info
           end
 
           UI.user_error!("Request returned the error: #{response.code}")
@@ -173,40 +164,33 @@ module Fastlane
       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]
-
+        ms_credentials = Helper.ms_credentials
         body = {
-          client_id: client_id,
-          client_secret: client_secret,
+          client_id: ms_credentials.client_id,
+          client_secret: ms_credentials.client_secret,
           client_info: 1,
           grant_type: "password",
-          scope: "https://management.azure.com/.default offline_access openid profile",
-          username: username,
-          password: password
+          scope: "https://graph.windows.net/.default offline_access openid profile",
+          username: ms_credentials.username,
+          password: ms_credentials.password
         }
         headers = {
-          "x-anchormailbox": "upn:#{username}",
+          "x-anchormailbox": "upn:#{ms_credentials.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)
+        connection = Faraday.new("https://login.microsoftonline.com")
         request_body = URI.encode_www_form(body)
-        response = https.request(request, request_body)
 
         begin
+          response = connection.post("/#{ms_credentials.tenant_id}/oauth2/v2.0/token", request_body, headers)
           data = JSON.parse(response.body)
 
-          if response.code == "200"
+          if response.status == 200
+            @token = data["access_token"]
             UI.message("Authorization token was obtained")
-            return data["access_token"]
+
+            return
           end
 
           error = data["error"]
@@ -218,6 +202,34 @@ module Fastlane
         end
       end
 
+      def self.acquire_vsapi_location
+        query = {
+          LinkId: "875315" # VS API constant
+        }
+        connection = Faraday.new("https://go.microsoft.com")
+
+        begin
+          response = connection.get("/fwlink", query)
+
+          if response.status == 302
+            raise "'Location' header isn't presented" unless response.headers.include?("Location")
+
+            location = response.headers["Location"]
+            uri = URI(location)
+            @vsapi_host = "#{uri.scheme}://#{uri.host}"
+            @vsapi_endpoint = uri.path
+
+            UI.message("VS API endpoint: #{location}")
+
+            return
+          end
+
+          UI.user_error!("Request returned the error: #{response.status}")
+        rescue StandardError => ex
+          UI.user_error!("Failed to get VS API endpoint location: #{ex}")
+        end
+      end
+
       def self.description
         "Makes a local app manifest needed for Microsoft Store association"
       end
@@ -268,5 +280,23 @@ module Fastlane
         :project
       end
     end
+
+    class DeveloperInfo
+      attr_reader :display_name, :publisher
+
+      def initialize(display_name, publisher)
+        @display_name = display_name
+        @publisher = publisher
+      end
+    end
+
+    class AppInfo
+      attr_reader :identity, :names
+
+      def initialize(identity, names)
+        @identity = identity
+        @names = names
+      end
+    end
   end
 end

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

@@ -1,22 +1,19 @@
 require "fastlane/action"
+require_relative "../helper/ms_credentials"
 
 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
+      SF_MS_CREDENTIALS = :SF_MS_CREDENTIALS
     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]
+        Helper.ms_credentials.username = params[:username]
+        Helper.ms_credentials.password = params[:password]
+        Helper.ms_credentials.tenant_id = params[:tenant_id]
+        Helper.ms_credentials.client_id = params[:client_id]
+        Helper.ms_credentials.client_secret = params[:client_secret]
 
         UI.success("Credentials for Azure AD account is successfully saved for further actions")
       end

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

@@ -1,4 +1,5 @@
 require "fastlane/action"
+require_relative "../helper/ms_credentials"
 require_relative "../helper/ms_devcenter_helper"
 require_relative "../msbuild/options"
 
@@ -8,18 +9,38 @@ module Fastlane
       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]
+        ms_credentials = Helper.ms_credentials
         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)
+        auth_token = Helper::MsDevCenterHelper.acquire_authorization_token(ms_credentials.tenant_id,
+                                                                           ms_credentials.client_id,
+                                                                           ms_credentials.client_secret,
+                                                                           timeout)
         UI.message("Authorization token was obtained")
 
         UI.message("Creating submission for app #{app_id} ...")
+        pending_submission = Helper::MsDevCenterHelper.non_published_submission(app_id, auth_token, timeout)
+
+        unless pending_submission.nil?
+          submission_id = pending_submission["id"]
+
+          if params.values.include?(:remove_pending_submission) &&
+             [true].include?(params[:remove_pending_submission])
+            UI.message("Pending submission #{submission_id} were found and scheduled for deletion due to 'remove_pending_submission' argument set to 'true'")
+            Helper::MsDevCenterHelper.remove_submission(app_id, submission_id, auth_token, timeout)
+            UI.message("Pending submission deleted")
+          else
+            UI.user_error!([
+              "There is a pending submission #{submission_id} has already been created.",
+              "You need to either proceed it or remove before creating a new one.",
+              "Set 'remove_pending_submission' argument to 'true' to do that automatically."
+            ].join(" "))
+          end
+        end
+
         submission_obj = Helper::MsDevCenterHelper.create_submission(app_id, auth_token, timeout)
         submission_id = submission_obj["id"]
         UI.message("Submission #{submission_id} created")
@@ -46,7 +67,6 @@ module Fastlane
            [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
@@ -127,6 +147,13 @@ module Fastlane
             default_value: false,
             type: Fastlane::Boolean
           ),
+          FastlaneCore::ConfigItem.new(
+            key: :remove_pending_submission,
+            description: "If set to true, the pending submission halts - a new one will be created automatically",
+            optional: true,
+            default_value: false,
+            type: Fastlane::Boolean
+          ),
           FastlaneCore::ConfigItem.new(
             key: :path,
             env_name: "SF_PACKAGE",
@@ -156,8 +183,8 @@ module Fastlane
       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")
+        File.delete(zip_path) if File.exist?(zip_path)
 
         Zip::File.open(zip_path, create: true) do |file|
           file.add(File.basename(package_path), package_path)
@@ -181,7 +208,14 @@ module Fastlane
           "minimumSystemRam": "None"
         }
 
-        submission_obj[key] = [] if submission_obj[key].empty?
+        if submission_obj[key].empty?
+          submission_obj[key] = []
+        else
+          submission_obj[key].each do |existing_package|
+            existing_package["fileStatus"] = "PendingDelete"
+          end
+        end
+
         submission_obj[key].append(package)
         submission_obj
       end

data/lib/fastlane/plugin/sapfire/helper/ms_credentials.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  module Helper
+    class MsCredentials
+      attr_writer :username, :password, :tenant_id, :client_id, :client_secret
+
+      def username
+        check_value("username", @username)
+        @username
+      end
+
+      def password
+        check_value("password", @password)
+        @password
+      end
+
+      def tenant_id
+        check_value("tenant_id", @tenant_id)
+        @tenant_id
+      end
+
+      def client_id
+        check_value("client_id", @client_id)
+        @client_id
+      end
+
+      def client_secret
+        check_value("client_secret", @client_secret)
+        @client_secret
+      end
+
+      def check_value(name, value)
+        raise "Microsoft credential variable hasn't been set: #{name}. You must call ms_credentials action before." if
+          value.nil? || value.empty?
+      end
+
+      private(:check_value)
+    end
+
+    class << self
+      attr_accessor :ms_credentials
+    end
+
+    self.ms_credentials = MsCredentials.new
+
+    private_class_method(:ms_credentials=)
+  end
+end

data/lib/fastlane/plugin/sapfire/helper/ms_devcenter_helper.rb

@@ -53,19 +53,24 @@ module Fastlane
         url_data = parse_upload_url(url)
         url_data[:query]["comp"] = "block"
         url_data[:query]["blockid"] = id
-
         connection = Faraday.new(url_data[:host])
-        response = connection.put(url_data[:path]) do |req|
-          req.headers = headers
-          req.params = url_data[:query]
-          req.body = bytes
-          req.options.timeout = timeout if timeout.positive?
-        end
 
-        return true if response.status == 201
+        begin
+          response = connection.put(url_data[:path]) do |req|
+            req.headers = headers
+            req.params = url_data[:query]
+            req.body = bytes
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          return true if response.status == 201
+
+          error = response.body.to_s
+          UI.error("Upload request failed.\nCode: #{response.status}\nError: #{error}")
+        rescue StandardError => ex
+          UI.error("Upload request failed: #{ex}")
+        end
 
-        error = response.body.to_s
-        UI.error("Upload request failed.\nCode: #{response.status}\nError: #{error}")
         false
       end
 
@@ -81,18 +86,23 @@ module Fastlane
 
         url_data = parse_upload_url(url)
         url_data[:query]["comp"] = "blocklist"
-
         connection = Faraday.new(url_data[:host])
-        response = connection.put(url_data[:path]) do |req|
-          req.params = url_data[:query]
-          req.body = document.to_s
-          req.options.timeout = timeout if timeout.positive?
-        end
 
-        return true if response.status == 201
+        begin
+          response = connection.put(url_data[:path]) do |req|
+            req.params = url_data[:query]
+            req.body = document.to_s
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          return true if response.status == 201
+
+          error = response.body.to_s
+          UI.error("Upload block list request failed.\nCode: #{response.status}\nError: #{error}")
+        rescue StandardError => ex
+          UI.error("Upload block list request failed: #{ex}")
+        end
 
-        error = response.body.to_s
-        UI.error("Upload block list request failed.\nCode: #{response.status}\nError: #{error}")
         false
       end
 
@@ -100,16 +110,17 @@ module Fastlane
         check_app_id(app_id)
 
         connection = Faraday.new(HOST)
-        response = connection.get("/#{API_VERSION}/#{API_ROOT}/#{app_id}") do |req|
-          req.headers = build_headers(auth_token)
-          req.options.timeout = timeout if timeout.positive?
-        end
 
         begin
+          response = connection.get("/#{API_VERSION}/#{API_ROOT}/#{app_id}") do |req|
+            req.headers = build_headers(auth_token)
+            req.options.timeout = timeout if timeout.positive?
+          end
           data = JSON.parse(response.body)
+
           return data if response.status == 200
 
-          UI.user_error!("Request returned the error.\nCode: #{response.status}")
+          UI.user_error!("Getting app request returned the error.\nCode: #{response.status}")
         rescue StandardError => ex
           UI.user_error!("Getting app info process failed: #{ex}")
         end
@@ -117,27 +128,22 @@ module Fastlane
 
       def self.create_submission(app_id, auth_token, timeout = 0)
         check_app_id(app_id)
-        if non_published_submission?(app_id, auth_token, timeout)
-          UI.user_error!([
-            "There is a pending submission has already been created.",
-            "You need to either proceed it or remove before creating a new one."
-          ].join(" "))
-        end
 
         connection = Faraday.new(HOST)
-        response = connection.post("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions") do |req|
-          req.headers = build_headers(auth_token)
-          req.options.timeout = timeout if timeout.positive?
-        end
 
         begin
+          response = connection.post("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions") do |req|
+            req.headers = build_headers(auth_token)
+            req.options.timeout = timeout if timeout.positive?
+          end
           data = JSON.parse(response.body)
+
           return data if response.status == 201
 
           code = data["code"]
           message = data["message"]
 
-          UI.user_error!("Request returned the error.\nCode: #{response.status} #{code}.\nDescription: #{message}")
+          UI.user_error!("Creating submission request returned the error.\nCode: #{response.status} #{code}.\nDescription: #{message}")
         rescue StandardError => ex
           UI.user_error!("Creating submission process failed: #{ex}")
         end
@@ -149,17 +155,18 @@ module Fastlane
 
         submission_id = submission_obj["id"]
         connection = Faraday.new(HOST)
-        response = connection.put("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}") do |req|
-          req.headers = build_headers(auth_token)
-          req.body = submission_obj.to_json
-          req.options.timeout = timeout if timeout.positive?
-        end
 
         begin
+          response = connection.put("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}") do |req|
+            req.headers = build_headers(auth_token)
+            req.body = submission_obj.to_json
+            req.options.timeout = timeout if timeout.positive?
+          end
           data = JSON.parse(response.body)
+
           return data if response.status == 200
 
-          UI.user_error!("Request returned the error.\nCode: #{response.status}")
+          UI.user_error!("Updating submission request returned the error.\nCode: #{response.status}")
         rescue StandardError => ex
           UI.user_error!("Updating submission process failed: #{ex}")
         end
@@ -170,29 +177,75 @@ module Fastlane
         check_submission_id(submission_id)
 
         connection = Faraday.new(HOST)
-        response = connection.post("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}/commit") do |req|
-          req.headers = build_headers(auth_token)
-          req.options.timeout = timeout if timeout.positive?
+
+        begin
+          response = connection.post("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}/commit") do |req|
+            req.headers = build_headers(auth_token)
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          UI.user_error!("Committing submission request returned the error.\nCode: #{response.status}") unless response.status == 202
+        rescue StandardError => ex
+          UI.user_error!("Committing submission process failed: #{ex}")
         end
+      end
+
+      def self.remove_submission(app_id, submission_id, auth_token, timeout = 0)
+        check_app_id(app_id)
+        check_submission_id(submission_id)
+
+        connection = Faraday.new(HOST)
 
-        UI.user_error!("Committing submission request returned the error.\nCode: #{response.status}") unless response.status == 202
+        begin
+          response = connection.delete("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}") do |req|
+            req.headers = build_headers(auth_token)
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          UI.user_error!("Deleting submission request returned the error.\nCode: #{response.status}") unless response.status == 204
+        rescue StandardError => ex
+          UI.user_error!("Deleting submission process failed: #{ex}")
+        end
       end
 
       def self.get_submission_status(app_id, submission_id, auth_token, timeout = 0)
         check_app_id(app_id)
         check_submission_id(submission_id)
 
-        connection = Faraday.new(HOST)
-        response = connection.get("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}/status") do |req|
-          req.headers = build_headers(auth_token)
-          req.options.timeout = timeout if timeout.positive?
+        response = get_submission_status_internal(app_id, submission_id, auth_token, timeout)
+
+        # Sometimes MS can return internal server error code (500) that is not directly related to uploading process.
+        # Once it happens, retry 3 times until we'll get a success response.
+        if response[:status] == 500
+          server_error_500_retry_counter = 0
+
+          until server_error_500_retry_counter < 2
+            server_error_500_retry_counter += 1
+            response = get_submission_status_internal(app_id, submission_id, auth_token, timeout)
+            break if response.nil? || response[:status] == 200
+          end
         end
 
+        return response[:data] if !response.nil? && response[:status] == 200
+
+        UI.user_error!("Submission status obtaining request returned the error.\nCode: #{response[:status]}")
+      end
+
+      def self.get_submission_status_internal(app_id, submission_id, auth_token, timeout = 0)
+        connection = Faraday.new(HOST)
+
         begin
-          data = JSON.parse(response.body)
-          return data if response.status == 200
+          response = connection.get("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}/status") do |req|
+            req.headers = build_headers(auth_token)
+            req.options.timeout = timeout if timeout.positive?
+          end
 
-          UI.user_error!("Request returned the error.\nCode: #{response.status}")
+          UI.error("Submission status obtaining request returned the error.\nCode: #{response.status}") if response.status != 200
+          data = response.status == 200 ? JSON.parse(response.body) : nil
+          {
+            "data": data,
+            "status": response.status
+          }
         rescue StandardError => ex
           UI.user_error!("Submission status obtaining process failed: #{ex}")
         end
@@ -208,31 +261,31 @@ module Fastlane
         headers = {
           "Content-Type": "application/x-www-form-urlencoded"
         }.merge(REQUEST_HEADERS)
-
         connection = Faraday.new("https://login.microsoftonline.com")
-        response = connection.post("/#{tenant_id}/oauth2/token") do |req|
-          req.headers = headers
-          req.body = body
-          req.options.timeout = timeout if timeout.positive?
-        end
 
         begin
+          response = connection.post("/#{tenant_id}/oauth2/token") do |req|
+            req.headers = headers
+            req.body = body
+            req.options.timeout = timeout if timeout.positive?
+          end
           data = JSON.parse(response.body)
+
           return data["access_token"] if response.status == 200
 
           error = data["error"]
           error_description = data["error_description"]
 
-          UI.user_error!("Request returned the error.\nCode: #{error}.\nDescription: #{error_description}")
+          UI.user_error!("Authorization request returned the error.\nCode: #{error}.\nDescription: #{error_description}")
         rescue StandardError => ex
           UI.user_error!("Authorization failed: #{ex}")
         end
       end
 
-      def self.non_published_submission?(app_id, auth_token, timeout = 0)
+      def self.non_published_submission(app_id, auth_token, timeout = 0)
         check_app_id(app_id)
         app_info = get_app_info(app_id, auth_token, timeout)
-        app_info.key?("pendingApplicationSubmission")
+        app_info["pendingApplicationSubmission"]
       end
 
       def self.build_headers(auth_token)
@@ -270,16 +323,18 @@ module Fastlane
       public_class_method(:create_submission)
       public_class_method(:update_submission)
       public_class_method(:commit_submission)
+      public_class_method(:remove_submission)
       public_class_method(:get_submission_status)
       public_class_method(:acquire_authorization_token)
+      public_class_method(:non_published_submission)
 
       private_class_method(:upload_block)
       private_class_method(:upload_block_list)
-      private_class_method(:non_published_submission?)
       private_class_method(:build_headers)
       private_class_method(:parse_upload_url)
       private_class_method(:check_app_id)
       private_class_method(:check_submission_id)
+      private_class_method(:get_submission_status_internal)
 
       private_constant(:HOST)
       private_constant(:API_VERSION)

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Sapfire
-    VERSION = "1.1.0"
+    VERSION = "1.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-sapfire
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - CheeryLee
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-05 00:00:00.000000000 Z
+date: 2024-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -145,6 +145,7 @@ files:
 - lib/fastlane/plugin/sapfire/actions/upload_ms_store_action.rb
 - lib/fastlane/plugin/sapfire/actions/upload_nuget_action.rb
 - lib/fastlane/plugin/sapfire/actions_base/msbuild_action_base.rb
+- lib/fastlane/plugin/sapfire/helper/ms_credentials.rb
 - lib/fastlane/plugin/sapfire/helper/ms_devcenter_helper.rb
 - lib/fastlane/plugin/sapfire/helper/sapfire_helper.rb
 - lib/fastlane/plugin/sapfire/msbuild/module.rb
@@ -175,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: A bunch of fastlane actions to work with MSBuild, NuGet and Microsoft Store