fastlane-plugin-appcenter 1.7.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0cf08880b9ba588e79b23dd385311f4d5a194246
-  data.tar.gz: fe26549362f32bbd22293bc8110e432a7a94118a
+SHA256:
+  metadata.gz: 63dc35fc59b2bd98c82d21b139557a0ce06fbdd137367391435cee95d119045d
+  data.tar.gz: 2aa31b4b0d0091f35a0953c89ddbe69bfc0ca6d4b05193a3654455ff1bdd27b3
 SHA512:
-  metadata.gz: 6ffd559816032b4c385ead27b89419541746a106e63713aeef51282d1a74950dd27eaff4d1daf59db58ccfd33a3d4efa9f3a1f9ffbefc836ed82af2d7579dcf4
-  data.tar.gz: 80b0cb6d8016fa35400e0ae7c1e7d1dfd9ac2e07cc3b6a96decb26917bf6c5988ab9a7f2fb407e4ee96e8303cd716dd6fc020785f6a2aa06f8167681f7d18e6f
+  metadata.gz: aa2bf15c7177cbaaa9108e1d151e82a3f145467359765caa064e1d11462554de7b018263ccf023805dab4afe52d138aa055f9657af2ab8d3e91e01149807cb2e
+  data.tar.gz: 1089271e589573573bf89a528ab0c97f562cf2ba3136276dcdf52fc2806f7229af9128b9c16419c011a88d1bb1fb11aa556131107d381de2141e99f98bc076d8

data/README.md

@@ -21,6 +21,8 @@ With [App Center](https://appcenter.ms) you can continuously build, test, releas
 
 `appcenter_upload` allows you to upload and [distribute](https://docs.microsoft.com/en-us/appcenter/distribution/uploading) apps to your testers on App Center as well as to upload .dSYM files to [collect detailed crash reports](https://docs.microsoft.com/en-us/appcenter/crashes/ios) in App Center.
 
+`appcenter_fetch_version_number` allows you to obtain the latest version number (short or full) for an app. This is useful for tasks such as getting the latest version of an app so that an increment action can take place on CI, or checking that an upload has been successful.
+
 ## Usage
 
 To get started, first, [obtain an API token](https://appcenter.ms/settings/apitokens) in App Center. The API Token is used to authenticate with the App Center API in each call.
@@ -29,7 +31,6 @@ To get started, first, [obtain an API token](https://appcenter.ms/settings/apito
 appcenter_fetch_devices(
   api_token: "<appcenter token>",
   owner_name: "<appcenter account name of the owner of the app (username or organization URL name)>",
-  owner_type: "user", # Default is user - set to organization for appcenter organizations
   app_name: "<appcenter app name>",
   destinations: "*", # Default is 'Collaborators', use '*' for all distribution groups
   devices_file: "devices.txt" # Default. If you customize, the extension must be .txt
@@ -47,6 +48,21 @@ appcenter_upload(
 )
 ```
 
+```ruby
+appcenter_fetch_version_number(
+  api_token: "<appcenter token>",
+  owner_name: "<appcenter account name of the owner of the app (username or organization URL name)>",
+  app_name: "<appcenter app name (as seen in app URL)>",
+  version: "a specific version to get the last release for" # optional, don't set this value to get the last upload of all versions
+)
+```
+
+The `appcenter_fetch_version_number` returns a hash that contains the id, the version number, and the build number. The version corresponds to the `short_version` and the build number to the `version` known by App Center for a given release:
+```ruby
+{"id"=>1, "version"=>"1.0.0", "build_number"=>"1.0.0.1234"} # iOS apps contain the full version plus build number due to the way that Apple use CFBundleVersion for this value
+{"id"=>588, "version"=>"1.2.0", "build_number"=>"1615"}
+```
+
 ### Help
 
 Once installed, information and help for an action can be printed out with this command:
@@ -74,7 +90,6 @@ Here is the list of all existing parameters:
 | Key & Env Var | Description |
 |-----------------|--------------------|
 | `api_token` <br/> `APPCENTER_API_TOKEN` | API Token for App Center |
-| `owner_type` <br/> `APPCENTER_OWNER_TYPE` | Owner type, either 'user' or 'organization' (default: `user`) |
 | `owner_name` <br/> `APPCENTER_OWNER_NAME` | Owner name, as found in the App's URL in App Center |
 | `destinations` <br/> `APPCENTER_DISTRIBUTE_DESTINATIONS` | Comma separated list of distribution group names. Default is 'Collaborators', use '*' for all distribution groups |
 | `devices_file` <br/> `FL_REGISTER_DEVICES_FILE` | File to save the devices list to. Same environment variable as _fastlane_'s `register_devices` action |
@@ -88,7 +103,7 @@ Here is the list of all existing parameters:
 | `owner_name` <br/> `APPCENTER_OWNER_NAME` | Owner name as found in the App's URL in App Center |
 | `app_name` <br/> `APPCENTER_APP_NAME` | App name as found in the App's URL in App Center. If there is no app with such name, you will be prompted to create one |
 | `app_display_name` <br/> `APPCENTER_APP_DISPLAY_NAME` | App display name to use when creating a new app |
-| `app_os` <br/> `APPCENTER_APP_OS` | App OS. Used for new app creation, if app 'app_name' was not found |
+| `app_os` <br/> `APPCENTER_APP_OS` | App OS can be Android, iOS, macOS, Windows, Custom. Used for new app creation, if app 'app_name' was not found |
 | `app_platform` <br/> `APPCENTER_APP_PLATFORM` | App Platform. Used for new app creation, if app 'app_name' was not found |
 | `file` <br/> `APPCENTER_DISTRIBUTE_FILE` | File path to the release build to publish |
 | `upload_build_only` <br/> `APPCENTER_DISTRIBUTE_UPLOAD_BUILD_ONLY` | Flag to upload only the build to App Center. Skips uploading symbols or mapping (default: `false`) |
@@ -96,7 +111,7 @@ Here is the list of all existing parameters:
 | `upload_dsym_only` <br/> `APPCENTER_DISTRIBUTE_UPLOAD_DSYM_ONLY` | Flag to upload only the dSYM file to App Center (default: `false`) |
 | `mapping` <br/> `APPCENTER_DISTRIBUTE_ANDROID_MAPPING` | Path to your Android mapping.txt |
 | `upload_mapping_only` <br/> `APPCENTER_DISTRIBUTE_UPLOAD_ANDROID_MAPPING_ONLY` | Flag to upload only the mapping.txt file to App Center (default: `false`) |
-| `destinations` <br/> `APPCENTER_DISTRIBUTE_DESTINATIONS` | Comma separated list of destination names. Both distribution groups and stores are supported. All names are required to be of the same destination type (default: `Collaborators`) |
+| `destinations` <br/> `APPCENTER_DISTRIBUTE_DESTINATIONS` | Comma separated list of destination names, use '*' for all distribution groups if destination type is 'group'. Both distribution groups and stores are supported. All names are required to be of the same destination type (default: `Collaborators`) |
 | `destination_type` <br/> `APPCENTER_DISTRIBUTE_DESTINATION_TYPE` | Destination type of distribution destination. 'group' and 'store' are supported (default: `group`) |
 | `mandatory_update` <br/> `APPCENTER_DISTRIBUTE_MANDATORY_UPDATE` | Require users to update to this release. Ignored if destination type is 'store' (default: `false`) |
 | `notify_testers` <br/> `APPCENTER_DISTRIBUTE_NOTIFY_TESTERS` | Send email notification about release. Ignored if destination type is 'store' (default: `false`) |
@@ -105,10 +120,18 @@ Here is the list of all existing parameters:
 | `release_notes_link` <br/> `APPCENTER_DISTRIBUTE_RELEASE_NOTES_LINK` | Additional release notes link |
 | `build_number` <br/> `APPCENTER_DISTRIBUTE_BUILD_NUMBER` | The build number, required for macOS .pkg and .dmg builds, as well as Android ProGuard `mapping.txt` when using `upload_mapping_only` |
 | `version` <br/> `APPCENTER_DISTRIBUTE_VERSION` | The build version, required for .pkg, .dmg, .zip and .msi builds, as well as Android ProGuard `mapping.txt` when using `upload_mapping_only` |
-| `timeout` <br/> `APPCENTER_DISTRIBUTE_TIMEOUT` | Request timeout in seconds |
+| `timeout` <br/> `APPCENTER_DISTRIBUTE_TIMEOUT` | Request timeout in seconds applied to individual HTTP requests. Some commands use multiple HTTP requests, large file uploads are also split in multiple HTTP requests |
 | `dsa_signature` <br/> `APPCENTER_DISTRIBUTE_DSA_SIGNATURE` | DSA signature of the macOS or Windows release for Sparkle update feed |
 | `strict` <br/> `APPCENTER_STRICT_MODE` | Strict mode, set to 'true' to fail early in case a potential error was detected |
 
+#### `appcenter_fetch_version_number`
+
+| Key & Env Var | Description |
+|-----------------|--------------------|
+| `api_token` <br/> `APPCENTER_API_TOKEN` | API Token for App Center |
+| `owner_name` <br/> `APPCENTER_OWNER_NAME` | Owner name, as found in the App's URL in App Center |
+| `app_name` <br/> `APPCENTER_APP_NAME` | App name as found in the App's URL in App Center. If there is no app with such name, you will be prompted to create one |
+| `version` <br/> `APPCENTER_APP_VERSION` | App version to get the last release for instead of the last release of all versions |
 
 ## Example
 
@@ -162,4 +185,4 @@ Check out [SECURITY.md](SECURITY.md) for any security concern with this project.
 
 ## Contact
 
-We're on Twitter as [@vsappcenter](https://www.twitter.com/vsappcenter). Additionally you can reach out to us on the [App Center](https://appcenter.ms/apps) portal by using the blue Intercom button on the bottom right to start a conversation.
+We're on Twitter as [@vsappcenter](https://www.twitter.com/vsappcenter). Additionally you can reach out to us on the [App Center](https://appcenter.ms/apps) portal. Open the "?" menu on the top right corner of screen, then use "Contact support" to file a support ticket. Our support team is there to answer your questions and help you solve your problems. 

data/lib/fastlane/plugin/appcenter/actions/appcenter_fetch_version_number.rb

@@ -0,0 +1,103 @@
+require "json"
+require "net/http"
+require "fastlane_core/ui/ui"
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Actions
+    class AppcenterFetchVersionNumberAction < Action
+      def self.description
+        "Fetches the latest version number of an app or the last build number of a version from App Center"
+      end
+
+      def self.authors
+        ["jspargo", "ShopKeep", "Qutaibah"]
+      end
+
+      def self.run(params)
+        api_token = params[:api_token]
+        app_name = params[:app_name]
+        owner_name = params[:owner_name]
+        version = params[:version]
+
+        releases = Helper::AppcenterHelper.fetch_releases(
+          api_token: api_token,
+          owner_name: owner_name,
+          app_name: app_name,
+        )
+
+        UI.abort_with_message!("No versions found for '#{app_name}' owned by #{owner_name}") unless releases
+
+        sorted_releases = releases
+
+        if version.nil?
+          sorted_releases = releases.sort_by { |release| release["id"] }
+        else
+          sorted_releases = releases.select { |release| release["short_version"] == version }.sort_by { |release| release["id"] }
+        end
+
+        latest_release = sorted_releases.last
+
+        if latest_release.nil?
+          if version.nil?
+            UI.user_error!("This app has no releases yet")
+            return nil
+          end
+          UI.user_error!("The provided version (#{version}) has no releases yet")
+          return nil
+        end
+
+        return {
+                 "id" => latest_release["id"],
+                 "version" => latest_release["short_version"],
+                 "build_number" => latest_release["version"],
+               }
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "APPCENTER_API_TOKEN",
+                                       description: "API Token for App Center Access",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API token for App Center given, pass using `api_token: 'token'`") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :owner_name,
+                                       env_name: "APPCENTER_OWNER_NAME",
+                                       description: "Name of the owner of the application on App Center",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No owner name for App Center given, pass using `owner_name: 'owner name'`") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :app_name,
+                                       env_name: "APPCENTER_APP_NAME",
+                                       description: "Name of the application on App Center",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No app name for App Center given, pass using `app_name: 'app name'`") unless value && !value.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "APPCENTER_APP_VERSION",
+                                       description: "The version to get the latest release for",
+                                       optional: true,
+                                       type: String),
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.get_apps(api_token)
+        host_uri = URI.parse("https://api.appcenter.ms")
+        http = Net::HTTP.new(host_uri.host, host_uri.port)
+        http.use_ssl = true
+        apps_request = Net::HTTP::Get.new("/v0.1/apps")
+        apps_request["X-API-Token"] = api_token
+        apps_response = http.request(apps_request)
+        return [] unless apps_response.kind_of?(Net::HTTPOK)
+        return JSON.parse(apps_response.body)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/appcenter/actions/appcenter_upload_action.rb

@@ -9,6 +9,23 @@ module Fastlane
           windows: %w(.appx .appxbundle .appxupload .msix .msixbundle .msixupload .zip .msi),
           custom: %w(.zip)
       }
+      CONTENT_TYPES = {
+          apk: "application/vnd.android.package-archive",
+          aab: "application/vnd.android.package-archive",
+          msi: "application/x-msi",
+          plist: "application/xml",
+          aetx: "application/c-x509-ca-cert",
+          cer: "application/pkix-cert",
+          xap: "application/x-silverlight-app",
+          appx: "application/x-appx",
+          appxbundle: "application/x-appxbundle",
+          appxupload: "application/x-appxupload",
+          appxsym: "application/x-appxupload",
+          msix: "application/x-msix",
+          msixbundle: "application/x-msixbundle",
+          msixupload: "application/x-msixupload",
+          msixsym: "application/x-msixupload",
+      }
       ALL_SUPPORTED_EXTENSIONS = SUPPORTED_EXTENSIONS.values.flatten.sort!.uniq!
       STORE_ONLY_EXTENSIONS = %w(.aab)
       STORE_SUPPORTED_EXTENSIONS = %w(.aab .apk .ipa)
@@ -22,6 +39,13 @@ module Fastlane
     end
 
     class AppcenterUploadAction < Action
+      def self.is_apple_build(file)
+        return false unless file
+
+        file_ext = Helper::AppcenterHelper.file_extname_full(file)
+        ((Constants::SUPPORTED_EXTENSIONS[:ios] + Constants::SUPPORTED_EXTENSIONS[:mac])).include? file_ext
+      end
+
       # run whole upload process for dSYM files
       def self.run_dsym_upload(params)
         values = params.values
@@ -35,8 +59,9 @@ module Fastlane
 
         dsym_path = nil
         if dsym
-          # we can use dsym parameter only if build file is ipa
-          dsym_path = dsym if !file || File.extname(file) == '.ipa'
+          # we can use dsym parameter for all apple builds
+          self.optional_error("dsym parameter can only be used with Apple builds (ios, mac)") unless !file || self.is_apple_build(file)
+          dsym_path = dsym
         else
           # if dsym is not set, but build is ipa - check default path
           if file && File.exist?(file) && File.extname(file) == '.ipa'
@@ -145,6 +170,7 @@ module Fastlane
           self.optional_error("Can't distribute #{file_ext} to groups, please use `destination_type: 'store'`") if Constants::STORE_ONLY_EXTENSIONS.include? file_ext
         else
           self.optional_error("Can't distribute #{file_ext} to stores, please use `destination_type: 'group'`") unless Constants::STORE_SUPPORTED_EXTENSIONS.include? file_ext
+          UI.user_error!("The combination of `destinations: '*'` and `destination_type: 'store'` is invalid, please use `destination_type: 'group'` or explicitly specify the destinations") if destinations == "*"
         end
 
         release_upload_body = nil
@@ -171,27 +197,57 @@ module Fastlane
             File.delete zip_file
           end
           UI.message("Creating zip archive: #{zip_file}")
-          file = Actions::ZipAction.run(path: file, output_path: zip_file)
+          file = Actions::ZipAction.run(path: file, output_path: zip_file, symlinks: true)
         end
 
         UI.message("Starting release upload...")
         upload_details = Helper::AppcenterHelper.create_release_upload(api_token, owner_name, app_name, release_upload_body)
         if upload_details
-          upload_id = upload_details['upload_id']
-          upload_url = upload_details['upload_url']
+          upload_id = upload_details['id']
+          
+          UI.message("Setting Metadata...")
+          content_type = Constants::CONTENT_TYPES[File.extname(file)&.delete('.').downcase.to_sym] || "application/octet-stream"
+          set_metadata_url = "#{upload_details['upload_domain']}/upload/set_metadata/#{upload_details['package_asset_id']}?file_name=#{File.basename(file)}&file_size=#{File.size(file)}&token=#{upload_details['url_encoded_token']}&content_type=#{content_type}"
+          chunk_size = Helper::AppcenterHelper.set_release_upload_metadata(set_metadata_url, api_token, owner_name, app_name, upload_id, timeout)
+          UI.abort_with_message!("Upload aborted") unless chunk_size
 
           UI.message("Uploading release binary...")
-          uploaded = Helper::AppcenterHelper.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, timeout)
+          upload_url = "#{upload_details['upload_domain']}/upload/upload_chunk/#{upload_details['package_asset_id']}?token=#{upload_details['url_encoded_token']}"
+          uploaded = Helper::AppcenterHelper.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, content_type, chunk_size, timeout)
+          UI.abort_with_message!("Upload aborted") unless uploaded
+
+          UI.message("Finishing release...")
+          finish_url = "#{upload_details['upload_domain']}/upload/finished/#{upload_details['package_asset_id']}?token=#{upload_details['url_encoded_token']}"
+          finished = Helper::AppcenterHelper.finish_release_upload(finish_url, api_token, owner_name, app_name, upload_id, timeout)
+          UI.abort_with_message!("Upload aborted") unless finished
 
-          if uploaded
-            release_id = uploaded['release_id']
+          UI.message("Waiting for release to be ready...")
+          release_status_url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases/#{upload_id}"
+          release_id = Helper::AppcenterHelper.poll_for_release_id(api_token, release_status_url)
+
+          if release_id.is_a? Integer
             release_url = Helper::AppcenterHelper.get_release_url(owner_type, owner_name, app_name, release_id)
             UI.message("Release '#{release_id}' committed: #{release_url}")
 
             release = Helper::AppcenterHelper.update_release(api_token, owner_name, app_name, release_id, release_notes)
             Helper::AppcenterHelper.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature)
 
-            destinations_array = destinations.split(',')
+            destinations_array = []
+            if destinations == '*'
+              UI.message("Looking up all distribution groups for #{owner_name}/#{app_name}")
+              distribution_groups = Helper::AppcenterHelper.fetch_distribution_groups(
+                api_token: api_token,
+                owner_name: owner_name,
+                app_name: app_name
+              )
+
+              UI.abort_with_message!("Failed to list distribution groups for #{owner_name}/#{app_name}") unless distribution_groups
+              
+              destinations_array = distribution_groups.map {|h| h['name'] }
+            else
+              destinations_array = destinations.split(',').map(&:strip)
+            end
+            
             destinations_array.each do |destination_name|
               destination = Helper::AppcenterHelper.get_destination(api_token, owner_name, app_name, destination_type, destination_name)
               if destination
@@ -228,10 +284,11 @@ module Fastlane
         app_platform = params[:app_platform]
 
         platforms = {
-          Android: %w[Java React-Native Xamarin],
-          iOS: %w[Objective-C-Swift React-Native Xamarin],
+          Android: %w[Java React-Native Xamarin Unity],
+          iOS: %w[Objective-C-Swift React-Native Xamarin Unity],
           macOS: %w[Objective-C-Swift],
-          Windows: %w[UWP WPF WinForms Unity]
+          Windows: %w[UWP WPF WinForms Unity],
+          Custom: %w[Custom]
         }
 
         begin
@@ -260,6 +317,30 @@ module Fastlane
         end
       end
 
+      def self.add_app_to_distribution_group_if_needed(params)
+        return unless params[:destination_type] == 'group' && params[:owner_type] == 'organization' && params[:destinations] != '*'
+
+        app_distribution_groups = Helper::AppcenterHelper.fetch_distribution_groups(
+          api_token: params[:api_token],
+          owner_name: params[:owner_name],
+          app_name: params[:app_name]
+        )
+
+        group_names = app_distribution_groups.map { |g| g['name'] }
+        destination_names = params[:destinations].split(',').map(&:strip)
+
+        destination_names.each do |destination_name|
+          unless group_names.include? destination_name
+            Helper::AppcenterHelper.add_new_app_to_distribution_group(
+              api_token: params[:api_token],
+              owner_name: params[:owner_name],
+              app_name: params[:app_name],
+              destination_name: destination_name
+            )
+          end
+        end
+      end
+
       def self.run(params)
         values = params.values
         upload_build_only = params[:upload_build_only]
@@ -270,10 +351,10 @@ module Fastlane
 
         # if app found or successfully created
         if self.get_or_create_app(params)
+          self.add_app_to_distribution_group_if_needed(params)
           release = self.run_release_upload(params) unless upload_dsym_only || upload_mapping_only
           params[:version] = release['short_version'] if release
           params[:build_number] = release['version'] if release
-
           self.run_dsym_upload(params) unless upload_mapping_only || upload_build_only
           self.run_mapping_upload(params) unless upload_dsym_only || upload_build_only
         end
@@ -344,7 +425,7 @@ module Fastlane
 
           FastlaneCore::ConfigItem.new(key: :app_os,
                                   env_name: "APPCENTER_APP_OS",
-                               description: "App OS. Used for new app creation, if app 'app_name' was not found",
+                               description: "App OS can be Android, iOS, macOS, Windows, Custom. Used for new app creation, if app 'app_name' was not found",
                                   optional: true,
                                       type: String),
 
@@ -424,7 +505,7 @@ module Fastlane
                                   self.optional_error("Extension not supported: '#{file_ext}'. Supported formats for platform '#{platform}': #{accepted_formats.join ' '}") unless accepted_formats.include? file_ext
                                 end
                               end),
-          
+
           FastlaneCore::ConfigItem.new(key: :upload_build_only,
                                   env_name: "APPCENTER_DISTRIBUTE_UPLOAD_BUILD_ONLY",
                                description: "Flag to upload only the build to App Center. Skips uploading symbols or mapping",
@@ -460,6 +541,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :mapping,
                                   env_name: "APPCENTER_DISTRIBUTE_ANDROID_MAPPING",
                                description: "Path to your Android mapping.txt",
+                               default_value: (defined? SharedValues::GRADLE_MAPPING_TXT_OUTPUT_PATH) && Actions.lane_context[SharedValues::GRADLE_MAPPING_TXT_OUTPUT_PATH] || nil,
                                   optional: true,
                                       type: String,
                               verify_block: proc do |value|
@@ -489,12 +571,11 @@ module Fastlane
 
           FastlaneCore::ConfigItem.new(key: :destinations,
                                   env_name: "APPCENTER_DISTRIBUTE_DESTINATIONS",
-                               description: "Comma separated list of destination names. Both distribution groups and stores are supported. All names are required to be of the same destination type",
+                               description: "Comma separated list of destination names, use '*' for all distribution groups if destination type is 'group'. Both distribution groups and stores are supported. All names are required to be of the same destination type",
                              default_value: Actions.lane_context[SharedValues::APPCENTER_DISTRIBUTE_DESTINATIONS] || "Collaborators",
                                   optional: true,
                                       type: String),
 
-
           FastlaneCore::ConfigItem.new(key: :destination_type,
                                   env_name: "APPCENTER_DISTRIBUTE_DESTINATION_TYPE",
                                description: "Destination type of distribution destination. 'group' and 'store' are supported",
@@ -553,7 +634,7 @@ module Fastlane
 
           FastlaneCore::ConfigItem.new(key: :timeout,
                                        env_name: "APPCENTER_DISTRIBUTE_TIMEOUT",
-                                       description: "Request timeout in seconds",
+                                       description: "Request timeout in seconds applied to individual HTTP requests. Some commands use multiple HTTP requests, large file uploads are also split in multiple HTTP requests",
                                        optional: true,
                                        type: Integer),
 
@@ -608,6 +689,16 @@ module Fastlane
             release_notes: "release notes",
             notify_testers: false
           )',
+          'appcenter_upload(
+            api_token: "...",
+            owner_name: "appcenter_owner",
+            app_name: "testing_ios_app",
+            file: "./app-release.ipa",
+            destinations: "*",
+            destination_type: "group",
+            release_notes: "release notes",
+            notify_testers: false
+          )',
           'appcenter_upload(
             api_token: "...",
             owner_name: "appcenter_owner",

data/lib/fastlane/plugin/appcenter/helper/appcenter_helper.rb

@@ -1,7 +1,22 @@
+class File
+  def each_chunk(chunk_size)
+    yield read(chunk_size) until eof?
+  end
+end
+
 module Fastlane
   module Helper
     class AppcenterHelper
 
+      # Time to wait between 2 status polls in seconds
+      RELEASE_UPLOAD_STATUS_POLL_INTERVAL = 1
+
+      # Maximum number of retries for a request
+      MAX_REQUEST_RETRIES = 2
+
+      # Delay between retries in seconds
+      REQUEST_RETRY_INTERVAL = 5
+
       # basic utility method to check file types that App Center will accept,
       # accounting for file types that can and should be zip-compressed
       # before they are uploaded
@@ -18,10 +33,16 @@ module Fastlane
         require 'faraday'
         require 'faraday_middleware'
 
+        default_api_url = "https://api.appcenter.ms"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          default_api_url = "https://api-gateway-core-integration.dev.avalanch.es"
+        end
         options = {
-          url: upload_url || ENV.fetch('APPCENTER_UPLOAD_URL', "https://api.appcenter.ms")
+          url: upload_url || default_api_url
         }
 
+        UI.message("DEBUG: BASE URL #{options[:url]}") if ENV['DEBUG']
+
         Faraday.new(options) do |builder|
           if upload_url
             builder.request :multipart unless dsym
@@ -41,16 +62,20 @@ module Fastlane
       # upload_url
       def self.create_release_upload(api_token, owner_name, app_name, body)
         connection = self.connection
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases"
+        body ||= {}
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/release_uploads") do |req|
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body: #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = body.nil? && {} || body
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -59,7 +84,7 @@ module Fastlane
           UI.error("Not found, invalid owner or application name")
           false
         when 500...600
-          UI.crash!("Internal Service Error, please try again later")
+          UI.abort_with_message!("Internal Service Error, please try again later")
         else
           UI.error("Error #{response.status}: #{response.body}")
           false
@@ -74,20 +99,27 @@ module Fastlane
       def self.create_mapping_upload(api_token, owner_name, app_name, file_name, build_number, version)
         connection = self.connection
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads"
+        body = {
+          symbol_type: "AndroidProguard",
+          file_name: file_name,
+          build: build_number,
+          version: version,
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            symbol_type: "AndroidProguard",
-            file_name: file_name,
-            build: build_number,
-            version: version,
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -109,17 +141,24 @@ module Fastlane
       def self.create_dsym_upload(api_token, owner_name, app_name)
         connection = self.connection
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads"
+        body = {
+          symbol_type: 'Apple'
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            symbol_type: 'Apple'
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -137,17 +176,24 @@ module Fastlane
       def self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, status)
         connection = self.connection
 
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}"
+        body = {
+          status: status
+        }
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.patch(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "status" => status
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -164,6 +210,9 @@ module Fastlane
       def self.upload_symbol(api_token, owner_name, app_name, symbol, symbol_type, symbol_upload_id, upload_url)
         connection = self.connection(upload_url, true)
 
+        UI.message("DEBUG: PUT #{upload_url}") if ENV['DEBUG']
+        UI.message("DEBUG: PUT body <data>\n") if ENV['DEBUG']
+
         response = connection.put do |req|
           req.headers['x-ms-blob-type'] = "BlockBlob"
           req.headers['Content-Length'] = File.size(symbol).to_s
@@ -171,77 +220,183 @@ module Fastlane
           req.body = Faraday::UploadIO.new(symbol, 'application/octet-stream') if symbol && File.exist?(symbol)
         end
 
-        logType = "dSYM" if (symbol_type == "Apple")
-        logType = "mapping" if (symbol_type == "Android")
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+        log_type = "dSYM" if symbol_type == "Apple"
+        log_type = "mapping" if symbol_type == "Android"
 
         case response.status
         when 200...300
           self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'committed')
-          UI.success("#{logType} uploaded")
+          UI.success("#{log_type} uploaded")
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         else
-          UI.error("Error uploading #{logType} #{response.status}: #{response.body}")
+          UI.error("Error uploading #{log_type} #{response.status}: #{response.body}")
           self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'aborted')
-          UI.error("#{logType} upload aborted")
+          UI.error("#{log_type} upload aborted")
           false
         end
       end
 
-      # upload binary for specified upload_url
-      # if succeed, then commits the release
-      # otherwise aborts
-      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, timeout)
-        connection = self.connection(upload_url)
+      # sets metadata for new upload in App Center
+      # returns:
+      # chunk size
+      def self.set_release_upload_metadata(set_metadata_url, api_token, owner_name, app_name, upload_id, timeout)
+        connection = self.connection(set_metadata_url)
+
+        UI.message("DEBUG: POST #{set_metadata_url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body <data>\n") if ENV['DEBUG']
+        response = connection.post do |req|
+          req.options.timeout = timeout
+          req.headers['internal-request-source'] = "fastlane"
+        end
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
 
-        options = {}
-        options[:upload_id] = upload_id
-        # ipa field is used for .apk, .aab and .ipa files
-        options[:ipa] = Faraday::UploadIO.new(file, 'application/octet-stream') if file && File.exist?(file)
+        case response.status
+        when 200...300
+          chunk_size = response.body['chunk_size']
+          unless chunk_size.is_a? Integer
+            UI.error("Set metadata didn't return chunk size: #{response.status}: #{response.body}")
+            false
+          else
+            UI.message("Metadata set")
+            chunk_size
+          end
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        else
+          UI.error("Error setting metadata: #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # Verifies a successful upload to App Center
+      # returns:
+      # successful upload response body.
+      def self.finish_release_upload(finish_url, api_token, owner_name, app_name, upload_id, timeout)
+        connection = self.connection(finish_url)
 
+        UI.message("DEBUG: POST #{finish_url}") if ENV['DEBUG']
         response = connection.post do |req|
           req.options.timeout = timeout
           req.headers['internal-request-source'] = "fastlane"
-          req.body = options
         end
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
 
         case response.status
         when 200...300
-          UI.message("Binary uploaded")
-          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'committed')
+          if response.body['error'] == false
+            UI.message("Upload finished")
+            self.update_release_upload(api_token, owner_name, app_name, upload_id, 'uploadFinished')
+          else
+            UI.error("Error finishing upload: #{response.body['message']}")
+            false
+          end
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         else
-          UI.error("Error uploading binary #{response.status}: #{response.body}")
-          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'aborted')
-          UI.error("Release aborted")
+          UI.error("Error finishing upload: #{response.status}: #{response.body}")
           false
         end
       end
 
+      # upload binary for specified upload_url
+      # if succeed, then commits the release
+      # otherwise aborts
+      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, content_type, chunk_size, timeout)
+        block_number = 1
+
+        File.open(file).each_chunk(chunk_size) do |chunk|
+          upload_chunk_url = "#{upload_url}&block_number=#{block_number}"
+          retries = 0
+
+          while retries <= MAX_REQUEST_RETRIES
+            begin
+              connection = self.connection(upload_chunk_url, true)
+
+              UI.message("DEBUG: POST #{upload_chunk_url}") if ENV['DEBUG']
+              UI.message("DEBUG: POST body <data>\n") if ENV['DEBUG']
+              response = connection.post do |req|
+                req.options.timeout = timeout
+                req.headers['internal-request-source'] = "fastlane"
+                req.headers['Content-Length'] = chunk.length.to_s
+                req.headers['Content-Type'] = 'application/octet-stream'
+                req.body = chunk
+              end
+              UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+              status = response.status
+              message = response.body
+            rescue Faraday::Error => e
+
+              # Low level HTTP errors, we will retry them
+              status = 0
+              message = e.message
+            end
+
+            case status
+            when 200...300
+              if response.body['error'] == false
+                UI.message("Chunk uploaded")
+                block_number += 1
+                break
+              else
+                UI.error("Error uploading binary #{response.body['message']}")
+                return false
+              end
+            when 401
+              UI.user_error!("Auth Error, provided invalid token")
+              return false
+            when 400...407, 409...428, 430...499
+              UI.user_error!("Client error: #{response.status}: #{response.body}")
+              return false
+            else
+              if retries < MAX_REQUEST_RETRIES
+                UI.message("DEBUG: Retryable error uploading binary #{status}: #{message}")
+                retries += 1
+                sleep(REQUEST_RETRY_INTERVAL)
+              else
+                UI.error("Error uploading binary #{status}: #{message}")
+                return false
+              end
+            end
+          end
+        end
+        UI.message("Binary uploaded")
+      end
+
       # Commits or aborts the upload process for a release
       def self.update_release_upload(api_token, owner_name, app_name, upload_id, status)
         connection = self.connection
 
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/release_uploads/#{upload_id}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases/#{upload_id}"
+        body = {
+          upload_status: status,
+          id: upload_id
+        }
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.patch(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "status" => status
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         when 500...600
-          UI.crash!("Internal Service Error, please try again later")
+          UI.abort_with_message!("Internal Service Error, please try again later")
         else
           UI.error("Error #{response.status}: #{response.body}")
           false
@@ -251,15 +406,21 @@ module Fastlane
       # get existing release
       def self.get_release(api_token, owner_name, app_name, release_id)
         connection = self.connection
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
+
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           release = response.body
-          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
           release
         when 404
           UI.error("Not found, invalid release url")
@@ -273,19 +434,58 @@ module Fastlane
         end
       end
 
+      # Polls the upload for a release id. When a release is uploaded, we have to check
+      # for a successful extraction before we can continue.
+      # returns:
+      # release_distinct_id
+      def self.poll_for_release_id(api_token, url)
+        connection = self.connection
+
+        while true
+          UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
+
+          UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+          case response.status
+          when 200...300
+            case response.body['upload_status']
+            when "readyToBePublished"
+              return response.body['release_distinct_id']
+            when "error"
+              UI.error("Error fetching release: #{response.body['error_details']}")
+              return false
+            else
+              sleep(RELEASE_UPLOAD_STATUS_POLL_INTERVAL)
+            end
+          else
+            UI.error("Error fetching information about release #{response.status}: #{response.body}")
+            return false
+          end
+        end
+      end
+
       # get distribution group or store
       def self.get_destination(api_token, owner_name, app_name, destination_type, destination_name)
         connection = self.connection
 
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}/distribution_#{destination_type}s/#{ERB::Util.url_encode(destination_name)}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/distribution_#{destination_type}s/#{ERB::Util.url_encode(destination_name)}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           destination = response.body
-          UI.message("DEBUG: received #{destination_type} #{JSON.pretty_generate(destination)}") if ENV['DEBUG']
           destination
         when 404
           UI.error("Not found, invalid distribution #{destination_type} name")
@@ -303,14 +503,22 @@ module Fastlane
       def self.update_release(api_token, owner_name, app_name, release_id, release_notes = '')
         connection = self.connection
 
-        response = connection.put("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+        body = {
+          release_notes: release_notes
+        }
+
+        UI.message("DEBUG: PUT #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PUT body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.put(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            release_notes: release_notes
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           # get full release info
@@ -319,8 +527,6 @@ module Fastlane
 
           download_url = release['download_url']
 
-          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
-
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_BUILD_INFORMATION] = release
 
@@ -343,19 +549,25 @@ module Fastlane
       def self.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature)
         return if dsa_signature.to_s == ''
 
-        release_metadata = {
-          dsa_signature: dsa_signature
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+        body = {
+          metadata: {
+            dsa_signature: dsa_signature
+          }
         }
 
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
         connection = self.connection
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
+        response = connection.patch(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            metadata: release_metadata
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           UI.message("Release Metadata was successfully updated for release '#{release_id}'")
@@ -370,25 +582,32 @@ module Fastlane
           false
         end
       end
-      
+
       # add release to distribution group or store
       def self.add_to_destination(api_token, owner_name, app_name, release_id, destination_type, destination_id, mandatory_update = false, notify_testers = false)
         connection = self.connection
 
-        UI.message("DEBUG: getting #{release_id}") if ENV['DEBUG']
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}/#{destination_type}s"
+        body = {
+          id: destination_id
+        }
 
-        body = { "id" => destination_id }
         if destination_type == "group"
           body["mandatory_update"] = mandatory_update
           body["notify_testers"] = notify_testers
         end
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}/#{destination_type}s") do |req|
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
           req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           # get full release info
@@ -397,8 +616,6 @@ module Fastlane
 
           download_url = release['download_url']
 
-          UI.message("DEBUG: received release #{JSON.pretty_generate(release)}") if ENV['DEBUG']
-
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_BUILD_INFORMATION] = release
 
@@ -421,11 +638,17 @@ module Fastlane
       def self.get_app(api_token, owner_name, app_name)
         connection = self.connection
 
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
@@ -446,23 +669,28 @@ module Fastlane
       def self.create_app(api_token, owner_type, owner_name, app_name, app_display_name, os, platform)
         connection = self.connection
 
-        endpoint = owner_type == "user" ? "v0.1/apps" : "v0.1/orgs/#{owner_name}/apps"
+        url = owner_type == "user" ? "v0.1/apps" : "v0.1/orgs/#{owner_name}/apps"
+        body = {
+          display_name: app_display_name,
+          name: app_name,
+          os: os,
+          platform: platform
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
 
-        response = connection.post(endpoint) do |req|
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "display_name" => app_display_name,
-            "name" => app_name,
-            "os" => os,
-            "platform" => platform
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           created = response.body
-          UI.message("DEBUG: #{JSON.pretty_generate(created)}") if ENV['DEBUG']
           UI.success("Created #{os}/#{platform} app with name \"#{created['name']}\" and display name \"#{created['display_name']}\" for #{owner_type} \"#{owner_name}\"")
           true
         when 401
@@ -477,16 +705,19 @@ module Fastlane
       def self.fetch_distribution_groups(api_token:, owner_name:, app_name:)
         connection = self.connection
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups"
 
-        response = connection.get(endpoint) do |req|
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -503,16 +734,19 @@ module Fastlane
       def self.fetch_devices(api_token:, owner_name:, app_name:, distribution_group:)
         connection = self.connection(nil, false, true)
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups/#{ERB::Util.url_encode(distribution_group)}/devices/download_devices_list"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups/#{ERB::Util.url_encode(distribution_group)}/devices/download_devices_list"
 
-        response = connection.get(endpoint) do |req|
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{response.body.inspect}") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -526,17 +760,87 @@ module Fastlane
         end
       end
 
-      # Note: This does not support testing environment (INT)
+      def self.fetch_releases(api_token:, owner_name:, app_name:)
+        connection = self.connection(nil, false, true)
+
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/releases"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+        end
+
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+        case response.status
+        when 200...300
+          JSON.parse(response.body)
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        when 404
+          UI.error("Not found, invalid owner or application name")
+          false
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
       def self.get_release_url(owner_type, owner_name, app_name, release_id)
         owner_path = owner_type == "user" ? "users/#{owner_name}" : "orgs/#{owner_name}"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          return "https://portal-server-core-integration.dev.avalanch.es/#{owner_path}/apps/#{app_name}/distribute/releases/#{release_id}"
+        end
+
         return "https://appcenter.ms/#{owner_path}/apps/#{app_name}/distribute/releases/#{release_id}"
       end
 
-      # Note: This does not support testing environment (INT)
       def self.get_install_url(owner_type, owner_name, app_name)
         owner_path = owner_type == "user" ? "users/#{owner_name}" : "orgs/#{owner_name}"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          return "https://install.portal-server-core-integration.dev.avalanch.es/#{owner_path}/apps/#{app_name}"
+        end
+
         return "https://install.appcenter.ms/#{owner_path}/apps/#{app_name}"
       end
+
+      # add new created app to existing distribution group
+      def self.add_new_app_to_distribution_group(api_token:, owner_name:, app_name:, destination_name:)
+        url = URI.escape("/v0.1/orgs/#{owner_name}/distribution_groups/#{destination_name}/apps")
+        body = {
+          apps: [
+            { name: app_name }
+          ]
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = body
+        end
+
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+        case response.status
+        when 200...300
+          created = response.body
+          UI.success("Added new app #{app_name} to distribution group #{destination_name}")
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+        when 404
+          UI.error("Not found, invalid distribution group name #{destination_name}")
+        when 409
+          UI.success("App already added to distribution group #{destination_name}")
+        else
+          UI.error("Error adding app to distribution group #{response.status}: #{response.body}")
+        end
+      end
     end
   end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Appcenter
-    VERSION = "1.7.0"
+    VERSION = "1.10.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-appcenter
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Microsoft Corporation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-15 00:00:00.000000000 Z
+date: 2020-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.77.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.77.0
+- !ruby/object:Gem::Dependency
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -118,6 +132,7 @@ files:
 - README.md
 - lib/fastlane/plugin/appcenter.rb
 - lib/fastlane/plugin/appcenter/actions/appcenter_fetch_devices_action.rb
+- lib/fastlane/plugin/appcenter/actions/appcenter_fetch_version_number.rb
 - lib/fastlane/plugin/appcenter/actions/appcenter_upload_action.rb
 - lib/fastlane/plugin/appcenter/helper/appcenter_helper.rb
 - lib/fastlane/plugin/appcenter/version.rb
@@ -140,8 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Fastlane plugin for App Center