fastlane-plugin-appcenter 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 156b2b0f457a0ad05bd0abe5d232e4e960d36190002882545734f8a150e9284c
-  data.tar.gz: bff39320edca4e3337db294afb2d498aa249ec24320e1b77f170645af804f086
+  metadata.gz: 9440d71c43f62ccae7c488cbd00b0aeef150abfa8ec5910e650a1c35d6087e20
+  data.tar.gz: 04ee877a3a4bd5835c5134b7354e9385ffcb98aeb53b6d39caa8d70d5fe3bc0a
 SHA512:
-  metadata.gz: 64cc092929a5189a4b5b610b329c2708aebbd4c7e586114d0a80be10d3b5267637d068713e8719a22a87fb8ff196ffd7ddc69aa09b8139d45f19fa410b4385d4
-  data.tar.gz: 6af5dbf4e3d3e44c8c0e1eddcda88779723f49eeda41f493eeed7ba6956864eef591bff5b1c35eaf1175efd4705907b8e28044d4a5ea07c34b88cf9b38c8dcff
+  metadata.gz: 7a3529b0ed5e6ff582daeea5dceb8c1af8cd78dd80a94cf7bfd1fb86518b71da5c6891d82de7acadcf6e22b2456ce5f9b50c871941db5d2c356d44592cbe7d4c
+  data.tar.gz: e980942bf5addbf026fd42c5ccbb276806584c748f69cb4d97d23b77a127526bc9ac8028afbf96183c915037cc24f6872a1968643ed48884fbcd95f590db09e7

data/README.md

@@ -36,9 +36,12 @@ The action parameters `api_token` and `owner_name` can also be omitted when thei
 - `APPCENTER_APP_NAME` - App name. If there is no app with such name, you will be prompted to create one
 - `APPCENTER_DISTRIBUTE_APK` - Build release path for android build
 - `APPCENTER_DISTRIBUTE_IPA` - Build release path for ios build
-- `APPCENTER_DISTRIBUTE_DSYM` - Path to your symbols file. For iOS provide path to app.dSYM.zip
+- `APPCENTER_DISTRIBUTE_DSYM` - Path to your symbols (app.dSYM.zip) file 
 - `APPCENTER_DISTRIBUTE_UPLOAD_DSYM_ONLY` - Flag to upload only the dSYM file to App Center
-- `APPCENTER_DISTRIBUTE_GROUP` - Comma separated list of Distribution Group names
+- `APPCENTER_DISTRIBUTE_ANDROID_MAPPING` - Path to your Android mapping.txt file 
+- `APPCENTER_DISTRIBUTE_UPLOAD_ANDROID_MAPPING_ONLY` - Flag to upload only the mapping file to App Center
+- `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 is `Collaborators`.
+- `APPCENTER_DISTRIBUTE_DESTINATION_TYPE` - Destination type of distribution destination. `group` and `store` are supported. Default is `group`
 - `APPCENTER_DISTRIBUTE_MANDATORY_UPDATE` - Require users to update to this release
 - `APPCENTER_DISTRIBUTE_NOTIFY_TESTERS` - Send email notification about release (default: `false`)
 - `APPCENTER_DISTRIBUTE_RELEASE_NOTES` - Release notes

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

@@ -45,6 +45,7 @@ module Fastlane
 
           UI.message("Starting dSYM upload...")
           
+          # TODO: this should eventually be removed once we have warned of deprecation for long enough
           if File.extname(dsym_path) == ".txt"
             file_name = File.basename(dsym_path)
             dsym_upload_details = Helper::AppcenterHelper.create_mapping_upload(api_token, owner_name, app_name, file_name ,build_number, version)
@@ -57,11 +58,37 @@ module Fastlane
             upload_url = dsym_upload_details['upload_url']
 
             UI.message("Uploading dSYM...")
-            Helper::AppcenterHelper.upload_dsym(api_token, owner_name, app_name, dsym_path, symbol_upload_id, upload_url)
+            Helper::AppcenterHelper.upload_symbol(api_token, owner_name, app_name, dsym_path, "Apple", symbol_upload_id, upload_url)
           end
         end
       end
 
+      def self.run_mapping_upload(params)
+        values = params.values
+        api_token = params[:api_token]
+        owner_name = params[:owner_name]
+        app_name = params[:app_name]
+        mapping = params[:mapping]
+        build_number = params[:build_number]
+        version = params[:version]
+
+        if mapping == nil
+          return
+        end
+
+        UI.message("Starting mapping upload...")
+        mapping_name = File.basename(mapping)
+        symbol_upload_details = Helper::AppcenterHelper.create_mapping_upload(api_token, owner_name, app_name, mapping_name, build_number, version)
+
+        if symbol_upload_details
+          symbol_upload_id = symbol_upload_details['symbol_upload_id']
+          upload_url = symbol_upload_details['upload_url']
+
+          UI.message("Uploading mapping...")
+          Helper::AppcenterHelper.upload_symbol(api_token, owner_name, app_name, mapping, "Android", symbol_upload_id, upload_url)
+        end
+      end
+
       # run whole upload process for release
       def self.run_release_upload(params)
         values = params.values
@@ -134,6 +161,9 @@ module Fastlane
         api_token = params[:api_token]
         owner_name = params[:owner_name]
         app_name = params[:app_name]
+        app_display_name = params[:app_display_name]
+        app_os = params[:app_os]
+        app_platform = params[:app_platform]
 
         platforms = {
           "Android" => ['Java', 'React-Native', 'Xamarin'],
@@ -141,28 +171,37 @@ module Fastlane
         }
 
         if Helper::AppcenterHelper.get_app(api_token, owner_name, app_name)
-          true
-        else
-          if Helper.test? || UI.confirm("App with name #{app_name} not found, create one?")
-            os = Helper.test? ? "Android" : UI.select("Select OS", ["Android", "iOS"])
-            platform = Helper.test? ? "Java" : UI.select("Select Platform", platforms[os])
+          return true
+        end
 
-            Helper::AppcenterHelper.create_app(api_token, owner_name, app_name, os, platform)
-          else
-            UI.error("Lane aborted")
-            false
-          end
+        should_create_app = !app_display_name.to_s.empty? || !app_os.to_s.empty? || !app_platform.to_s.empty?
+        
+        if Helper.test? || should_create_app || UI.confirm("App with name #{app_name} not found, create one?")
+          app_display_name = app_name if app_display_name.to_s.empty?
+          os = app_os.to_s.empty? ?
+            (Helper.test? ? "Android" : UI.select("Select OS", ["Android", "iOS"])) :
+            app_os
+          platform = app_platform.to_s.empty? ?
+            (Helper.test? ? "Java" : UI.select("Select Platform", platforms[os])) :
+            app_platform
+
+          Helper::AppcenterHelper.create_app(api_token, owner_name, app_name, app_display_name, os, platform)
+        else
+          UI.error("Lane aborted")
+          false
         end
       end
 
       def self.run(params)
         values = params.values
         upload_dsym_only = params[:upload_dsym_only]
+        upload_mapping_only = params[:upload_mapping_only]
 
         # if app found or successfully created
         if self.get_or_create_app(params)
-          self.run_release_upload(params) unless upload_dsym_only
-          self.run_dsym_upload(params)
+          self.run_release_upload(params) unless upload_dsym_only || upload_mapping_only
+          self.run_dsym_upload(params) unless upload_mapping_only
+          self.run_mapping_upload(params) unless upload_dsym_only
         end
 
         return values if Helper.test?
@@ -209,6 +248,24 @@ module Fastlane
                                 UI.user_error!("No App name given, pass using `app_name: 'app name'`") unless value && !value.empty?
                               end),
 
+          FastlaneCore::ConfigItem.new(key: :app_display_name,
+                                  env_name: "APPCENTER_APP_DISPLAY_NAME",
+                               description: "App display name to use when creating a new app",
+                                  optional: true,
+                                      type: String),
+
+          FastlaneCore::ConfigItem.new(key: :app_os,
+                                  env_name: "APPCENTER_APP_OS",
+                               description: "App OS. Used for new app creation, if app with 'app_name' name was not found",
+                                  optional: true,
+                                      type: String),
+
+          FastlaneCore::ConfigItem.new(key: :app_platform,
+                                  env_name: "APPCENTER_APP_PLATFORM",
+                               description: "App Platform. Used for new app creation, if app with 'app_name' name was not found",
+                                  optional: true,
+                                      type: String),
+
           FastlaneCore::ConfigItem.new(key: :apk,
                                   env_name: "APPCENTER_DISTRIBUTE_APK",
                                description: "Build release path for android build",
@@ -246,8 +303,10 @@ module Fastlane
                                   optional: true,
                                       type: String,
                               verify_block: proc do |value|
+                                deprecated_files = [".txt"]
                                 if value
                                   UI.user_error!("Couldn't find dSYM file at path '#{value}'") unless File.exist?(value)
+                                  UI.message("Support for *.txt has been deprecated. Please use --mapping parameter or APPCENTER_DISTRIBUTE_ANDROID_MAPPING environment variable instead.") if deprecated_files.include? File.extname(value)
                                 end
                               end),
 
@@ -258,6 +317,26 @@ module Fastlane
                                  is_string: false,
                              default_value: false),
 
+          FastlaneCore::ConfigItem.new(key: :mapping,
+                                  env_name: "APPCENTER_DISTRIBUTE_ANDROID_MAPPING",
+                               description: "Path to your Android mapping.txt",
+                                  optional: true,
+                                      type: String,
+                              verify_block: proc do |value|
+                                accepted_formats = [".txt"]
+                                if value
+                                  UI.user_error!("Couldn't find mapping file at path '#{value}'") unless File.exist?(value)
+                                  UI.user_error!("Only \"*.txt\" formats are allowed, you provided \"#{File.name(value)}\"") unless accepted_formats.include? File.extname(value)
+                                end
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :upload_mapping_only,
+                                  env_name: "APPCENTER_DISTRIBUTE_UPLOAD_ANDROID_MAPPING_ONLY",
+                               description: "Flag to upload only the mapping.txt file to App Center",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+
           FastlaneCore::ConfigItem.new(key: :group,
                                   env_name: "APPCENTER_DISTRIBUTE_GROUP",
                                description: "Comma separated list of Distribution Group names",
@@ -354,6 +433,9 @@ module Fastlane
             apk: "./app-release.apk",
             destinations: "Testers",
             destination_type: "group",
+            build_number: "3",
+            version: "1.0.0",
+            mapping: "./mapping.txt",
             release_notes: "release notes",
             notify_testers: false
           )',

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

@@ -123,8 +123,8 @@ module Fastlane
         end
       end
 
-      # committs or aborts dsym upload
-      def self.update_dsym_upload(api_token, owner_name, app_name, symbol_upload_id, status)
+      # committs or aborts symbol upload
+      def self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, status)
         connection = self.connection
 
         response = connection.patch do |req|
@@ -146,27 +146,30 @@ module Fastlane
         end
       end
 
-      # upload dSYM files to specified upload url
+      # upload symbol (dSYM or mapping) files to specified upload url
       # if succeed, then commits the upload
       # otherwise aborts
-      def self.upload_dsym(api_token, owner_name, app_name, dsym, symbol_upload_id, upload_url)
+      def self.upload_symbol(api_token, owner_name, app_name, symbol, symbol_type, symbol_upload_id, upload_url)
         connection = self.connection(upload_url, true)
 
         response = connection.put do |req|
           req.headers['x-ms-blob-type'] = "BlockBlob"
-          req.headers['Content-Length'] = File.size(dsym).to_s
+          req.headers['Content-Length'] = File.size(symbol).to_s
           req.headers['internal-request-source'] = "fastlane"
-          req.body = Faraday::UploadIO.new(dsym, 'application/octet-stream') if dsym && File.exist?(dsym)
+          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")
+
         case response.status
         when 200...300
-          self.update_dsym_upload(api_token, owner_name, app_name, symbol_upload_id, 'committed')
-          UI.success("dSYM uploaded")
+          self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'committed')
+          UI.success("#{logType} uploaded")
         else
-          UI.error("Error uploading dSYM #{response.status}: #{response.body}")
-          self.update_dsym_upload(api_token, owner_name, app_name, symbol_upload_id, 'aborted')
-          UI.error("dSYM upload aborted")
+          UI.error("Error uploading #{logType} #{response.status}: #{response.body}")
+          self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'aborted')
+          UI.error("#{logType} upload aborted")
           false
         end
       end
@@ -367,13 +370,13 @@ module Fastlane
           UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           false
         else
-          UI.error("Error #{response.status}: #{response.body}")
+          UI.error("Error getting app #{owner}/#{app_name}, #{response.status}: #{response.body}")
           false
         end
       end
 
       # returns true if app exists, false in case of 404 and error otherwise
-      def self.create_app(api_token, owner_name, app_name, os, platform)
+      def self.create_app(api_token, owner_name, app_name, app_display_name, os, platform)
         connection = self.connection
 
         response = connection.post do |req|
@@ -381,7 +384,7 @@ module Fastlane
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
           req.body = {
-            "display_name" => app_name,
+            "display_name" => app_display_name,
             "name" => app_name,
             "os" => os,
             "platform" => platform
@@ -392,7 +395,7 @@ module Fastlane
         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']}\"")
+          UI.success("Created #{os}/#{platform} app with name \"#{created['name']}\" and display name \"#{created['display_name']}\"")
           true
         else
           UI.error("Error creating app #{response.status}: #{response.body}")

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Appcenter
-    VERSION = "1.0.0"
+    VERSION = "1.0.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-appcenter
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Microsoft Corporation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-21 00:00:00.000000000 Z
+date: 2019-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler