fastlane-plugin-appcircle_testing_distribution 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ceb1940fa8c0d58e985bded6be73f61f64afb0599e852c52431811159af01212
-  data.tar.gz: 130705717aba452336764a57fe29a5c14c29b648e8d528e1ce3edae406e66359
+  metadata.gz: 213b75b8d9c150a9206153fa4bb835277992aac5ba70544ac201337a53eae712
+  data.tar.gz: 6dc6d2d960d77b3b7db6976b58aeefc17e0cfb3164bc52d137779a2f7765ae36
 SHA512:
-  metadata.gz: c1537e66400a4f57df3553ce8ef8fcadc89bee630557aa2eed668e7862e32327f391e0e6c280a7b01d7b9568ce3e3677608d771f089a4eb9aeb79f9ee0792405
-  data.tar.gz: f39fbbe473f79aceeac915a63fdbe9a638eb56a91172b8c7403d34367d95883a31e32f78cafb4fdb9ef3526108b534c4efb58a449f740ea906264aed08e4fb4b
+  metadata.gz: 3ec4a590c5418d685a2f2c7fa9b2618bf09d91d3a6bcc26252d1ec6e164b4d39a756065f0b35d886f79e75e04c0ea40a797c9de9c373ab35c9b3e3b920fdbabe
+  data.tar.gz: 0e980015ac5ee5f865da4262a1d7bd090f2c2d5cb8ce4e761ff8e8e718d61ea8822bb8c47295f1f45342d28bfaa2204923dcea78853b081a013ab21fca6aece7

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 Guven Karanfil <guven.karanfil@smartface.io>
+Copyright (c) 2024 Appcircle, Inc. <info@appcircle.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,4 @@
-## Appcircle Testing Distribution
+# Appcircle Testing Distribution
 
 [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-appcircle_testing_distribution)
 
@@ -13,7 +13,7 @@ Testing distribution is the process of distributing test builds to designated te
 ## Benefits of Using Testing Distribution
 
 1. **Simplified Binary Distribution**.
-   - **Skip Traditional Stores:** Share .xcarchive .IPA, APK, AAB, Zip, files directly, avoiding the need to use App Store TestFlight or Google Play Internal Testing.
+   - **Skip Traditional Stores:** Share IPA, APK, AAB files directly, avoiding the need to use App Store TestFlight or Google Play Internal Testing.
 2. **Streamlined Workflow:**
    - **Automated Processes:** Platforms like Appcircle automate the distribution process, saving time and reducing manual effort.
    - **Seamless Integration:** Integrates smoothly with existing DevOps pipelines, enabling efficient build and distribution workflows.
@@ -38,24 +38,11 @@ Testing distribution is the process of distributing test builds to designated te
 
 Overall, using testing distribution in mobile DevOps significantly enhances the efficiency, security, and effectiveness of the software development process, leading to better products and faster delivery times.
 
-## System Requirements
+<!-- ## Testing Distribution
 
-**Compatible Agents:**
+In order to share your builds with testers, you can create testing distribution profiles and assign testing groups to the profiles.
 
-- macOS 14.2, 14.5
-
-**Supported Version:**
-
-- Fastlane 2.222.0
-- Ruby 3.2.2
-
-Note: Currently, plugins are only compatible to use with **Appcircle Cloud**. **Self-hosted** support will be available in future releases.
-
-## Testing Distribution
-
-In order to share your builds with testers, you can create distribution profiles and assign testing groups to the distribution profiles.
-
-![Distribution Profile](<https://cdn.appcircle.io/docs/assets/image%20(152).png>)
+![Testing Distribution Profile](<https://cdn.appcircle.io/docs/assets/image%20(152).png>)
 
 ## Generating/Managing the Personal API Tokens
 
@@ -65,11 +52,11 @@ To generate a Personal API Token, follow these steps:
 2. You'll find the Personal API Token section in the top right corner.
 3. Press the "Generate Token" button to generate your first token.
 
-![Token Generation](<https://cdn.appcircle.io/docs/assets/image%20(164).png>)
+![Token Generation](<https://cdn.appcircle.io/docs/assets/image%20(164).png>) -->
 
 ## Getting Started with the Extension: Usage Guide
 
-To share your builds with testers, you can create distribution profiles and assign testing groups to these profiles.
+To share your builds with testers, you can create testing distribution profiles and assign testing groups to these profiles.
 
 This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-appcircle_testing_distribution`, add it to your project by running:
 
@@ -77,31 +64,59 @@ This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To
 fastlane add_plugin appcircle_testing_distribution
 ```
 
-```yml
+```ruby
   appcircle_testing_distribution(
-    personalAPIToken: "$(AC_PERSONAL_API_TOKEN)",
-    profileName: "$(AC_PROFILE_NAME)",
-    createProfileIfNotExists: Boolean,
-    appPath: "$(AC_APP_PATH)",
-    message: "$(AC_MESSAGE)",
+    personalAPIToken: ENV["AC_PERSONAL_API_TOKEN"],
+    personalAccessKey: ENV["AC_PERSONAL_ACCESS_KEY"],
+    subOrganizationName: ENV["AC_SUB_ORGANIZATION_NAME"],
+    profileName: ENV["AC_PROFILE_NAME"],
+    createProfileIfNotExists: ENV["AC_CREATE_PROFILE_IF_NOT_EXISTS"] == "true",
+    profileCreationSettings: {
+      authType: ENV["AC_PROFILE_AUTH_TYPE"],
+      username: ENV["AC_PROFILE_USERNAME"],
+      password: ENV["AC_PROFILE_PASSWORD"],
+      testingGroupNames: ENV["AC_PROFILE_TESTING_GROUP_NAMES"]
+    },
+    appPath: ENV["AC_APP_PATH"],
+    message: ENV["AC_MESSAGE"]
   )
 ```
 
-- `personalAPIToken`: The Appcircle Personal API token is utilized to authenticate and secure access to Appcircle services, ensuring that only authorized users can perform actions within the platform.
-- `profileName`: Specifies the profile that will be used for uploading the app.
-- `createProfileIfNotExists`: Ensures that a user profile is automatically created if it does not already exist; if the profile name already exists, the app will be uploaded to that existing profile instead.
-- `appPath`: Indicates the file path to the application that will be uploaded to Appcircle Testing Distribution Profile.
-- `message`: Your message to testers, ensuring they receive important updates and information regarding the application.
+### Authentication
 
-### Leveraging Environment Variables
+Provide **either** `personalAPIToken` **or** `personalAccessKey` — not both. If neither is provided, or both are provided at the same time, the plugin fails fast with a descriptive error.
 
-Utilize environment variables seamlessly by substituting the parameters with `$(VARIABLE_NAME)` in your task inputs. The extension automatically retrieves values from the specified environment variables within your pipeline.
+- `personalAPIToken`: The Appcircle Personal API token used to authenticate and authorize access to Appcircle services within this plugin.
+- `personalAccessKey`: Alternative authentication method using a Personal Access Key. Use this if your organization provisions access keys instead of API tokens.
 
-**Ensure that this action is added after build steps have been completed.**
+> **Note:** `subOrganizationName` is currently supported only when authenticating with `personalAPIToken`. When used together with `personalAccessKey`, the sub-organization switch is skipped with a warning.
 
-**If multiple workflows start simultaneously, the order in which versions are shared in the Testing Distribution is determined by the execution order of the publish step. The version that completes its build and triggers the publish plugin first will be shared first, followed by the others in sequence.**
+### Other parameters
 
-Efficiently distribute test binaries or beta versions using Appcircle, featuring seamless IPA and APK distribution capabilities. Streamline your testing process with our versatile tool designed to optimize your distribution workflow. If you need support or more information, please [contact us](https://appcircle.io/contact?utm_source=fastlane&utm_medium=plugin&utm_campaign=testing_distribution)
+- `subOrganizationName` (optional): Required when the Root Organization's `personalAPIToken` is used, and you want to create the profile under a sub-organization. In this case, provide the name of the sub-organization in this field. If you directly used the sub-organization's `personalAPIToken`, this parameter is not needed.
+- `profileName`: Specifies the profile that will be used for uploading the app.
+- `createProfileIfNotExists` (optional): Ensures that a testing distribution profile is automatically created if it does not already exist; if the profile name already exists, the app will be uploaded to that existing profile instead.
+- `profileCreationSettings` (optional): If `createProfileIfNotExists` is `true` and a new profile being created, the profile will be configured with these settings.
+  - `authType`: Authentication type of the profile. `none`: None, `static`: Static Username and Password, `ldap`: LDAP Login, `sso`: SSO Login.
+  - `username`: The username for the profile if authentication type set to `static` (Static Username and Password).
+  - `password`: The password for the profile if authentication type set to `static` (Static Username and Password).
+  - `testingGroupNames`: Uploaded versions will be automatically shared with these testing groups. Example format: `group1, group2, group3`.
+- `appPath`: Indicates the file path to the application package that will be uploaded to Appcircle Testing Distribution Profile.
+- `message`: Your message to testers, ensuring they receive important updates and information regarding the application.
+
+## Further Details
+
+For more information please refer to the documentation.
+
+- [Setting Up Appcircle Testing Distribution Plugin](https://docs.appcircle.io/marketplace/fastlane/testing-distribution)
+  - [Discover Action](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#discover-action)
+  - [System Requirements](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#system-requirements)
+  - [User Permission Requirements](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#user-permission-requirements)
+  - [How to Add the Appcircle Distribute Action to Your Pipeline](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#how-to-add-the-appcircle-distribute-action-to-your-pipeline)
+  - [CLI Usage](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#cli-usage)
+  - [Distributing to Sub-Organizations](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#distributing-to-sub-organizations)
+  - [Leveraging Environment Variables](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#leveraging-environment-variables)
+- [References](https://docs.appcircle.io/marketplace/fastlane/testing-distribution#references)
 
 ## Issues and Feedback
 
@@ -110,9 +125,3 @@ For any other issues and feedback about this plugin, please submit it to this re
 ## Troubleshooting
 
 If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
-
-## Reference
-
-- For details on generating an Appcircle Personal API Token, visit [Generating/Managing Personal API Tokens](https://docs.appcircle.io/appcircle-api/api-authentication#generatingmanaging-the-personal-api-tokens?utm_source=fastlane&utm_medium=plugin&utm_campaign=testing_distribution)
-
-- To create or learn more about Appcircle testing and distribution profiles, please refer to [Creating or Selecting a Distribution Profile](https://docs.appcircle.io/distribute/create-or-select-a-distribution-profile?utm_source=fastlane&utm_medium=plugin&utm_campaign=testing_distribution)

data/lib/fastlane/plugin/appcircle_testing_distribution/actions/appcircle_testing_distribution_action.rb

@@ -10,74 +10,145 @@ require_relative '../helper/TDUploadService'
 module Fastlane
   module Actions
     class AppcircleTestingDistributionAction < Action
+      VALID_EXTENSIONS = ['.apk', '.aab', '.ipa']
+      AUTH_TYPE_MAPPING = {
+        'none' => 1, # None
+        'static' => 3, # Static Username and Password
+        'ldap' => 4, # LDAP Login
+        'sso' => 5 # SSO Login
+      }
+      
       def self.run(params)
         personalAPIToken = params[:personalAPIToken]
         personalAccessKey = params[:personalAccessKey]
+        subOrganizationName = params[:subOrganizationName]
         profileName = params[:profileName]
+        createProfileIfNotExists = params[:createProfileIfNotExists] || false
+        #
+        profileCreationSettings = params[:profileCreationSettings]
+        profileAuthType = profileCreationSettings&.dig(:authType)
+        profileUsername = profileCreationSettings&.dig(:username)
+        profilePassword = profileCreationSettings&.dig(:password)
+        profileTestingGroupNames= profileCreationSettings&.dig(:testingGroupNames)
+        #
         appPath = params[:appPath]
         message = params[:message]
-        createProfileIfNotExists = params[:createProfileIfNotExists]
 
-        valid_extensions = ['.apk', '.aab', '.ipa', '.zip']
-
-        file_extension = File.extname(appPath).downcase
-        unless valid_extensions.include?(file_extension)
-          UI.user_error!("Invalid file extension: #{file_extension}. For Android, use .apk or .aab. For iOS, use .ipa or .zip(.xcarchive).")
-        end
+        profileAuthType = AUTH_TYPE_MAPPING[profileAuthType] # map input to API values
 
+        # Validate auth input (either-or, not both, not none)
         if personalAPIToken.nil? && personalAccessKey.nil?
-          UI.user_error!("Either Personal API Token or Personal Access Key is required to authenticate connections to Appcircle services. Please provide a valid access token or access key")
+          UI.user_error!("Either Personal API Token or Personal Access Key is required to authenticate connections to Appcircle services. Please provide a valid access token or access key.")
         elsif !personalAPIToken.nil? && !personalAccessKey.nil?
-          UI.user_error!("Personal API Token and Personal Access Key cannot be used together. Please provide only one authentication method")
-        elsif profileName.nil?
-          UI.user_error!("Distribution profile name is required to distribute applications. Please provide a distribution profile name")
-        elsif appPath.nil?
-          UI.user_error!("Application file path is required to distribute applications. Please provide a valid application file path")
-        elsif message.nil?
-          UI.user_error!("Message field is required. Please provide a valid message")
+          UI.user_error!("Personal API Token and Personal Access Key cannot be used together. Please provide only one authentication method.")
         end
 
+        # Auth
+        authToken = self.ac_login(personal_api_token: personalAPIToken,
+                                  personal_access_key: personalAccessKey,
+                                  sub_organization_name: subOrganizationName)
 
-        authToken = self.ac_login(personalAPIToken, personalAccessKey)
+        # Get or create profile
+        profileId = self.ac_get_or_create_profile(authToken, profileName, createProfileIfNotExists, profileCreationSettings, profileAuthType, profileUsername, profilePassword, profileTestingGroupNames)
 
-        profileId = TDUploadService.get_profile_id(authToken, profileName, createProfileIfNotExists)
-        self.ac_upload(authToken, appPath, profileId, message)
+        # Upload package
+        self.ac_upload(authToken, appPath, profileId, profileName, message)
       end
 
-      def self.ac_login(personalAPIToken, personalAccessKey)
+      def self.ac_login(personal_api_token:, personal_access_key:, sub_organization_name:)
         begin
-          if personalAccessKey
-            user = TDAuthService.get_ac_token_with_personal_access_key(personal_access_key: personalAccessKey)
+          token = ''
+
+          if personal_access_key
+            user = TDAuthService.get_ac_token_with_personal_access_key(personal_access_key: personal_access_key)
           else
-            user = TDAuthService.get_ac_token(pat: personalAPIToken)
+            user = TDAuthService.get_ac_token(pat: personal_api_token)
           end
           UI.success("Login is successful.")
-          return user.accessToken
+          token = user.accessToken
+
+          if sub_organization_name
+            if personal_access_key
+              UI.important("Warning: subOrganizationName is currently only supported with personalAPIToken auth. Ignoring sub-organization switch for Personal Access Key login.")
+            else
+              organization_id = TDAuthService.get_organization_id(access_token: token, name: sub_organization_name)
+              user = TDAuthService.get_ac_token(pat: personal_api_token, sub_organization_id: organization_id)
+              UI.message("Switched to sub-organization: #{sub_organization_name}")
+              token = user.accessToken
+            end
+          end
+
+          return token
+
         rescue => e
-          UI.user_error!("Login failed: #{e.message}")
+          UI.user_error!("Login failed: \"#{e.message}\".")
         end
       end
-      
+
+      def self.ac_get_or_create_profile(authToken, profileName, createProfileIfNotExists, profileCreationSettings, profileAuthType, profileUsername, profilePassword, profileTestingGroupNames)
+        begin
+          profileId = TDUploadService.get_profile_id(authToken, profileName)
+
+          if profileId
+            UI.message("Profile '#{profileName}' found with ID: #{profileId}.")
+            UI.important("Warning: Profile '#{profileName}' already exists, so the provided profile creation settings will be ignored. To update the profile settings, please use the Appcircle web interface.") if profileCreationSettings
+
+          elsif profileId.nil? && !createProfileIfNotExists
+            UI.user_error!("Error: Profile '#{profileName}' not found. The option 'createProfileIfNotExists' is set to false, so a new profile was not created. To automatically create a new profile when it doesn't exist, set 'createProfileIfNotExists' to true.")
+          elsif profileId.nil? && createProfileIfNotExists
+            UI.message("Profile '#{profileName}' not found. Creating the new profile...")
+            profileId = TDUploadService.create_profile(authToken, profileName, profileAuthType, profileUsername, profilePassword, profileTestingGroupNames)
+          end
+
+          return profileId
+          
+        rescue => e
+          UI.user_error!("Couldn't get the profile: \"#{e.message}\".")
+        end
+      end
+
+      def self.ac_upload(token, appPath, profileID, profileName, message)
+        begin
+          UI.message("Upload started.")
+          response = TDUploadService.upload_artifact(token: token, message: message, app: appPath, dist_profile_id: profileID)
+          result = self.checkTaskStatus(token, response['taskId'])
+
+          if result
+            UI.success("#{appPath} uploaded to profile '#{profileName}' successfully  🎉")
+          end
+        rescue => e
+          status_code = e.respond_to?(:response) && e.response ? e.response.code : 'unknown'
+          UI.user_error!("Upload failed with status code '#{status_code}', with message \"#{e.message}\".")
+        end
+      end
+
       def self.checkTaskStatus(authToken, taskId)
         uri = URI.parse("https://api.appcircle.io/task/v1/tasks/#{taskId}")
-        timeout = 1
         
-        response = self.send_request(uri, authToken)
-        if response.is_a?(Net::HTTPSuccess)
-          stateValue = JSON.parse(response.body)["stateValue"]
-          
-          if stateValue == 1
-            sleep(1)
-            return checkTaskStatus(authToken, taskId)
-          end
-          if stateValue == 3
-            return true
+        check_interval = 1
+        # timeout = 2 * 60 * 60 # 2 hours in seconds
+        # start_time = Time.now
+      
+        loop do
+          response = self.send_request(uri, authToken)
+          if response.is_a?(Net::HTTPSuccess)
+            stateValue = JSON.parse(response.body)["stateValue"]
+      
+            if stateValue == 1
+              sleep(check_interval)
+            elsif stateValue == 3
+              return true
+            else
+              UI.error("Task Id #{taskId} failed with state value #{stateValue}.")
+              UI.user_error!("Upload could not be completed successfully.")
+            end
           else
-            UI.error("Task Id #{taskId} failed with state value #{stateValue}")
-            raise "Upload could not completed successfully"
+            UI.user_error!("Upload failed with response code #{response.code} and message '#{response.message}'.")
           end
-        else
-          raise "Upload failed with response code #{response.code} and message '#{response.message}'"
+
+          # if Time.now - start_time > timeout
+          #   UI.user_error!("Task Id #{taskId} timed out after 2 hours.")
+          # end
         end
       end
 
@@ -89,20 +160,6 @@ module Fastlane
         http.request(request)
       end
 
-      def self.ac_upload(token, appPath, profileID, message)
-        begin
-          response = TDUploadService.upload_artifact(token: token, message: message, app: appPath, dist_profile_id: profileID)
-          result = self.checkTaskStatus(token, response['taskId'])
-
-          if result
-            UI.success("#{appPath} Uploaded to profile id #{profileID} successfully  🎉")
-          end
-        rescue => e
-          status_code = e.respond_to?(:response) && e.response ? e.response.code : 'unknown'
-          UI.user_error!("Upload failed with status code #{status_code}, with message '#{e.message}'")
-        end
-      end
-
       def self.description
         "Efficiently distribute application builds to users or testing groups using Appcircle's robust platform."
       end
@@ -117,7 +174,7 @@ module Fastlane
 
       def self.details
         # Optional:
-        "Appcircle simplifies the distribution of builds to test teams with an extensive platform for managing and tracking applications, versions, testers, and teams. Appcircle integrates with enterprise authentication mechanisms such as LDAP and SSO, ensuring secure distribution of testing packages. Learn more about Appcircle testing distribution"
+        "Appcircle simplifies the distribution of builds to test teams with an extensive platform for managing and tracking applications, versions, testers, and teams. Appcircle integrates with enterprise authentication mechanisms such as LDAP and SSO, ensuring secure distribution of testing packages. Learn more about Appcircle testing distribution."
       end
 
       def self.available_options
@@ -127,36 +184,80 @@ module Fastlane
                                        description: "Provide Personal API Token to authenticate connections to Appcircle services (alternative to personalAccessKey)",
                                        optional: true,
                                        type: String),
-          
+
           FastlaneCore::ConfigItem.new(key: :personalAccessKey,
                                        env_name: "AC_PERSONAL_ACCESS_KEY",
                                        description: "Provide Personal Access Key to authenticate connections to Appcircle services (alternative to personalAPIToken)",
                                        optional: true,
                                        type: String),
-          
+
+          FastlaneCore::ConfigItem.new(key: :subOrganizationName,
+                                       env_name: "AC_SUB_ORGANIZATION_NAME",
+                                       description: "Optional: Sub-organization name for app distribution. Profiles will be created under root organization if not provided",
+                                       optional: true,
+                                       type: String),
+
           FastlaneCore::ConfigItem.new(key: :profileName,
                                        env_name: "AC_PROFILE_NAME",
-                                       description: "Enter the profile name of the Appcircle distribution profile. This name uniquely identifies the profile under which your applications will be distributed",
+                                       description: "Enter the profile name of the Appcircle testing distribution profile. This name uniquely identifies the profile under which your applications will be distributed",
                                        optional: false,
-                                       type: String),
-          
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Profile name cannot be empty. Please provide a testing distribution profile name.") unless value && !value.empty?
+                                       end),
+
           FastlaneCore::ConfigItem.new(key: :createProfileIfNotExists,
                                        env_name: "AC_CREATE_PROFILE_IF_NOT_EXISTS",
-                                       description: "If the profile does not exist, create a new profile with the given name",
+                                       description: "Optional: If the profile does not exist, create a new profile with the given name",
                                        optional: true,
                                        type: Boolean),
 
+          FastlaneCore::ConfigItem.new(key: :profileCreationSettings,
+                                       description: "Optional: Profile creation settings for the testing distribution profile",
+                                       optional: true,
+                                       type: Hash,
+                                       verify_block: proc do |value|
+                                         # Parse and Validate
+                                         if value[:authType] && !value[:authType].empty?
+                                           UI.user_error!("Invalid authType: '#{value[:authType]}'. Options: 'none' (None), 'static' (Static Username and Password), 'ldap' (LDAP Login), 'sso' (SSO Login).") unless AUTH_TYPE_MAPPING.key?(value[:authType])
+
+                                           if value[:authType] == 'static'
+                                             UI.user_error!("username must be a String and at least 6 characters long.") unless value[:username].kind_of?(String) && value[:username].length >= 6
+                                             UI.user_error!("password must be a String and at least 6 characters long.") unless value[:password].kind_of?(String) && value[:password].length >= 6
+                                           else
+                                             value[:username] = nil
+                                             value[:password] = nil
+                                           end
+                                         end
+
+                                         if value[:testingGroupNames] && !value[:testingGroupNames].empty?
+                                           value[:testingGroupNames] = value[:testingGroupNames].to_s.split(",").map(&:strip)
+                                           UI.user_error!("testingGroupNames must be a string array. Ex: 'group1, group2, group3'.") unless value[:testingGroupNames].kind_of?(Array)
+                                         end
+                                       end),
+
           FastlaneCore::ConfigItem.new(key: :appPath,
                                        env_name: "AC_APP_PATH",
-                                       description: "Specify the path to your application file. For iOS, this can be a .ipa or .xcarchive file path. For Android, specify the .apk or .appbundle file path",
+                                       description: "Specify the path to your application file. For iOS, this can be a .ipa file path. For Android, specify the .apk or .aab file path",
                                        optional: false,
-                                       type: String),
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Application file path cannot be empty. Please provide a valid application file path.") unless value && !value.empty?
+
+                                         file_extension = File.extname(value).downcase
+                                         unless VALID_EXTENSIONS.include?(file_extension)
+                                           UI.user_error!("Invalid file extension: '#{file_extension}'. For Android, use .apk or .aab. For iOS, use .ipa.")
+                                         end
+                                       end),
 
           FastlaneCore::ConfigItem.new(key: :message,
                                        env_name: "AC_MESSAGE",
-                                       description: "Optional message to include with the distribution to provide additional information to testers or users receiving the build",
+                                       description: "Message to include with the distribution to provide additional information to testers or users receiving the build",
                                        optional: false,
-                                       type: String)
+                                       type: String,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Message field cannot be empty. Please provide a message.") unless value && !value.empty?
+                                       end)
         ]
       end
 

data/lib/fastlane/plugin/appcircle_testing_distribution/helper/TDAuthService.rb

@@ -13,7 +13,7 @@ class UserResponse
 end
 
 module TDAuthService
-  def self.get_ac_token(pat:)
+  def self.get_ac_token(pat:, sub_organization_id: nil)
     endpoint_url = 'https://auth.appcircle.io/auth/v2/token'
     uri = URI(endpoint_url)
 
@@ -24,6 +24,7 @@ module TDAuthService
     
     # Encode parameters
     params = { pat: pat }
+    params[:subOrganizationId] = sub_organization_id if sub_organization_id
     request.body = URI.encode_www_form(params)
 
     # Make the HTTP request
@@ -31,8 +32,6 @@ module TDAuthService
       http.request(request)
     end
 
-    
-
     # Check response
     if response.is_a?(Net::HTTPSuccess)
       response_data = JSON.parse(response.body)
@@ -43,7 +42,35 @@ module TDAuthService
 
       return user
     else
-      raise "HTTP Request failed (#{response.code} #{response.message})"
+      raise "Error: (#{response.code} #{response.message})."
+    end
+  end
+
+  def self.get_organization_id(access_token:, name:)
+    endpoint_url = 'https://api.appcircle.io/identity/v1/organizations'
+    uri = URI(endpoint_url)
+
+    # Create HTTP request
+    request = Net::HTTP::Get.new(uri)
+    request['Authorization'] = "Bearer #{access_token}"
+    request['Accept'] = 'application/json'
+
+    # Make the HTTP request
+    response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      http.request(request)
+    end
+
+    # Check response
+    if response.is_a?(Net::HTTPSuccess)
+      response_data = JSON.parse(response.body)
+      organizations = response_data['data']
+      organization = organizations.find { |org| org['name'] == name }
+
+      raise "Organization with name '#{name}' not found" unless organization
+      return organization['id']
+
+    else
+      raise "Error: (#{response.code} #{response.message})"
     end
   end
 
@@ -55,7 +82,7 @@ module TDAuthService
     request = Net::HTTP::Post.new(uri)
     request.content_type = 'application/x-www-form-urlencoded'
     request['Accept'] = 'application/json'
-    
+
     # Encode parameters
     params = { 'personal-access-key' => personal_access_key }
     request.body = URI.encode_www_form(params)
@@ -75,7 +102,7 @@ module TDAuthService
 
       return user
     else
-      raise "HTTP Request failed (#{response.code} #{response.message})"
+      raise "Error: (#{response.code} #{response.message})."
     end
   end
 end

data/lib/fastlane/plugin/appcircle_testing_distribution/helper/TDUploadService.rb

@@ -6,20 +6,80 @@ require 'rest-client'
 BASE_URL = "https://api.appcircle.io"
 
 module TDUploadService
+  UI = FastlaneCore::UI
+
   def self.upload_artifact(token:, message:, app:, dist_profile_id:)
-    url = "https://api.appcircle.io/distribution/v2/profiles/#{dist_profile_id}/app-versions"
+    file_path = app
+    file_name = File.basename(file_path)
+    file_size = File.size(file_path)
+
+    upload_info_url = "#{BASE_URL}/distribution/v1/profiles/#{dist_profile_id}/app-versions"
     headers = {
       Authorization: "Bearer #{token}",
-      content_type: :multipart # multipart/form-data
-    }
-    payload = {
-      Message: message,
-      File: File.new(app, 'rb')
+      accept: 'application/json'
     }
-  
+
+    uri = URI(upload_info_url)
+    uri.query = URI.encode_www_form({
+      action: 'uploadInformation',
+      fileName: file_name,
+      fileSize: file_size
+    })
+
     begin
-      response = RestClient.post(url, payload, headers)
-      JSON.parse(response.body) rescue response.body
+      UI.message("Getting file upload information...")
+      response = RestClient.get(uri.to_s, headers)
+      upload_info = JSON.parse(response.body)
+      if response.code.between?(200, 299)
+        UI.success("File upload information retrieved successfully with status code: #{response.code}")
+      else
+        UI.error("Failed to retrieve file upload information with status code: #{response.code}")
+        raise "Failed to retrieve file upload information."
+      end
+      file_id = upload_info['fileId']
+      upload_url = upload_info['uploadUrl']
+
+      file_content = File.binread(file_path)
+      UI.message("Uploading file to Appcircle...")
+      response = RestClient.put(
+        upload_url,
+        file_content,
+        { content_type: 'application/octet-stream' }
+      )
+      if response.code.between?(200, 299)
+        UI.success("File upload finished successfully with status code: #{response.code}")
+      else
+        UI.error("File upload failed with status code: #{response.code}")
+        raise "File upload failed."
+      end
+
+      commit_url = "#{BASE_URL}/distribution/v1/profiles/#{dist_profile_id}/app-versions"
+      uri = URI(commit_url)
+      uri.query = URI.encode_www_form({ action: 'commitFileUpload' })
+
+      commit_payload = {
+        fileId: file_id,
+        fileName: file_name,
+        message: message
+      }.to_json
+
+      commit_headers = {
+        Authorization: "Bearer #{token}",
+        content_type: :json,
+        accept: 'application/json'
+      }
+
+      UI.message("Committing file upload...")
+      commit_response = RestClient.post(uri.to_s, commit_payload, commit_headers)
+      if commit_response.code.between?(200, 299)
+        result = JSON.parse(commit_response.body)
+        UI.success("Commit successful with status code: #{commit_response.code}")
+      else
+        UI.error("Commit failed with status code: #{commit_response.code}")
+        raise "Commit failed with status code: #{commit_response.code}"
+      end
+
+      return result
     rescue RestClient::ExceptionWithResponse => e
       raise e
     rescue StandardError => e
@@ -38,9 +98,26 @@ module TDUploadService
   
     begin
       response = RestClient.get(url, headers)
-      parsed_response = JSON.parse(response.body)
+      JSON.parse(response.body)
+    rescue RestClient::ExceptionWithResponse => e
+      raise e
+    rescue StandardError => e
+      raise e
+    end
+  end
+
+  def self.get_testing_groups(auth_token:)
+    url = "#{BASE_URL}/distribution/v2/testing-groups"
   
-      parsed_response
+    # Set up the headers with authentication
+    headers = {
+      Authorization: "Bearer #{auth_token}",
+      accept: 'application/json'
+    }
+  
+    begin
+      response = RestClient.get(url, headers)
+      JSON.parse(response.body)
     rescue RestClient::ExceptionWithResponse => e
       raise e
     rescue StandardError => e
@@ -69,7 +146,40 @@ module TDUploadService
     end
   end
 
-  def self.get_profile_id(authToken, profileName, createProfileIfNotExists)
+  def self.update_distribution_profile(profile_id:, auth_type:, username:, password:, testing_group_ids:, auth_token:)
+    url = "#{BASE_URL}/distribution/v2/profiles/#{profile_id}"
+    headers = {
+      Authorization: "Bearer #{auth_token}",
+      content_type: :json,
+      accept: 'application/json-patch+json'
+    }
+
+    ### Construct the payload
+    payload = {}
+
+    settings_payload = {
+        authenticationType: auth_type,
+        username: username,
+        password: password
+    }.compact
+
+    payload[:settings] = settings_payload unless settings_payload.empty?
+    payload[:testingGroupIds] = testing_group_ids unless testing_group_ids&.empty?
+
+    payload = payload.compact.to_json
+    ###
+
+    begin
+      response = RestClient.patch(url, payload, headers)
+      JSON.parse(response.body)
+    rescue RestClient::ExceptionWithResponse => e
+      raise e
+    rescue StandardError => e
+      raise e
+    end
+  end
+
+  def self.get_profile_id(authToken, profileName)
     profileId = nil
 
     begin
@@ -77,27 +187,75 @@ module TDUploadService
       profiles.each do |profile|
         if profile["name"] == profileName
           profileId = profile['id']
+          break
         end
       end
     rescue => e
-      raise "Something went wrong while fetching profiles: #{e.message}"
-    end
-      
-    if profileId.nil? && !createProfileIfNotExists
-      raise "Error: The test profile '#{profileName}' could not be found. The option 'createProfileIfNotExists' is set to false, so no new profile was created. To automatically create a new profile if it doesn't exist, set 'createProfileIfNotExists' to true."
+      raise "Something went wrong while fetching profiles: #{e.message}."
     end
 
-    if profileId.nil? && createProfileIfNotExists
-      begin
-        puts "The test profile '#{profileName}' could not be found. A new profile is being created..."
-        new_profile = TDUploadService.create_distribution_profile(name: profileName, auth_token: authToken)
-        if new_profile.nil?
-          raise "Error: The new profile could not be created."
+    return profileId
+  end
+
+  def self.get_testing_group_ids(authToken, testingGroupNames)
+    testingGroupIds = []
+    remainingGroupNames = Set.new(testingGroupNames)
+
+    begin
+      groups = TDUploadService.get_testing_groups(auth_token: authToken)
+
+      groups.each do |group|
+        if remainingGroupNames.include?(group["name"])
+          testingGroupIds.push(group['id'])
+          remainingGroupNames.delete(group["name"])
         end
-        profileId = new_profile['id']
-      rescue => e
-        raise "Something went wrong while creating a new profile: #{e.message}"
       end
+    rescue => e
+      raise "Something went wrong while fetching testing groups: #{e.message}."
+    end
+
+    raise "Following testing groups couldn't be found: '#{remainingGroupNames.to_a.join(', ')}'. Aborting profile creation..." unless remainingGroupNames.empty?
+
+    return testingGroupIds
+  end
+
+  def self.create_profile(authToken, profileName, profileAuthType, profileUsername, profilePassword, profileTestingGroupNames)
+    # Get testing group IDs
+    if !profileTestingGroupNames&.empty?
+      profileTestingGroupIds = TDUploadService.get_testing_group_ids(authToken, profileTestingGroupNames)
+    end
+    
+    # Create
+    begin
+      new_profile = TDUploadService.create_distribution_profile(
+        name: profileName,
+        auth_token: authToken
+      )
+      if new_profile.nil?
+        raise "Error: The new profile could not be created."
+      end
+      profileId = new_profile['id']
+    rescue => e
+      raise "Something went wrong while creating a new profile: #{e.message}."
+    end
+
+    # Configure
+    begin
+      Fastlane::UI.message("Configuring the profile...")
+      configured_profile = TDUploadService.update_distribution_profile(
+        profile_id: profileId,
+        auth_type: profileAuthType,
+        username: profileUsername,
+        password: profilePassword,
+        testing_group_ids: profileTestingGroupIds,
+        auth_token: authToken
+      )
+      if configured_profile.nil?
+        raise "Error: The new profile could not be configured."
+      end
+      profileId = configured_profile['id'] # Should be the same as before
+    rescue => e
+      raise "Something went wrong while configuring the new profile: #{e.message}."
     end
 
     return profileId

data/lib/fastlane/plugin/appcircle_testing_distribution/helper/appcircle_testing_distribution_helper.rb

@@ -8,9 +8,6 @@ module Fastlane
       # class methods that you define here become available in your action
       # as `Helper::AppcircleTestingDistributionHelper.your_method`
       #
-      def self.show_message
-        UI.message("Hello from the appcircle_testing_distribution plugin helper!")
-      end
     end
   end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module AppcircleTestingDistribution
-    VERSION = "0.4.1"
+    VERSION = "0.4.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-appcircle_testing_distribution
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - appcircleio
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-25 00:00:00.000000000 Z
+date: 2026-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -32,8 +32,6 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- images/PAT.png
-- images/distribution-start.png
 - images/extension-icon.png
 - lib/fastlane/plugin/appcircle_testing_distribution.rb
 - lib/fastlane/plugin/appcircle_testing_distribution/actions/appcircle_testing_distribution_action.rb
@@ -45,7 +43,7 @@ homepage: https://github.com/appcircleio/fastlane_plugin_appcircle_testing_distr
 licenses:
 - MIT
 metadata:
-  rubygems_mfa_required: 'true'
+  rubygems_mfa_required: 'false'
 post_install_message:
 rdoc_options: []
 require_paths: