fastlane-plugin-appcircle_enterprise_app_store 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d8856c9fc564231df28f4de8dfa86c654b63e39953c16985425944abf4a41f6
+  data.tar.gz: 9ac3b5154d041cc5c973de767f8fb22812e85078e37bcb1d8f649aad7bee4d38
+SHA512:
+  metadata.gz: cb5cf60eb158cb46a539f6cf55032b8b8f952dfe1011ffa95773b53fa5bdbda668515adf00a0edbfea1b64f9200089218b8d20b4498a3af67f5160fcf6c62ed2
+  data.tar.gz: a1c96695801bb0eb112926c3201799881731d4fa51c4aaff5d908d767d1532ecc4355f143859674766faabe3d3660bf749c74abced9e0726d12cb82532feec15

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Guven Karanfil <guven.karanfil@smartface.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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+## Appcircle Enterprise App Store
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-appcircle_enterprise_store)
+
+Appcircle Enterprise Mobile App Store is your own mobile app store for providing access to in-house apps with a customizable mobile storefront.
+
+- **Customizable Storefront:** Distribute your in-house apps with a fully customizable mobile storefront.
+- **Secure Distribution:** Everything you need for secure, streamlined distribution of your in-house apps.
+- **No MDM Required:** Allows distribution of B2B and B2E applications without the need for an MDM solution and enrollment.
+
+Learn more about [Appcircle Enterprise App Store](https://appcircle.io/enterprise-app-store?utm_source=fastlane&utm_medium=plugin&utm_campaign=enterprise_app_store).
+
+## What Sets Apart Appcircle Enterprise Mobile App Store
+
+1. **Direct File Sharing:**
+   - **Skip Traditional Stores:** Share .IPA, APK, or AAB files directly, avoiding the need to wait for Apple App Store or Google Play approvals.
+2. **Flexible Sharing Options:**
+   - **Beta and Live Modes:** Share your app in ‘beta’ mode for testing new features or identifying bugs, or in ‘live’ mode for stable versions. This flexibility helps maintain the development lifecycle without interruptions.
+3. **Enhanced Security:**
+   - **Secure Authentication:** Access the Enterprise Mobile App Store with extra secure authentication using Enterprise Authentication Methods.
+   - **Controlled Access:** Ensure that only authorized users can access the app store and its contents.
+4. **Customizable Mobile Storefront:**
+   - **Tailored Experience:** Provide a customizable mobile storefront for your in-house apps, ensuring a tailored experience that aligns with your brand and user needs.
+5. **No MDM Requirement:**
+   - **Simplified Distribution:** Distribute B2B and B2E applications without the need for a Mobile Device Management (MDM) solution or enrollment, reducing complexity and costs.
+6. **Streamlined Workflow:**
+   - **Seamless Integration:** Integrates smoothly with your existing workflow, making it easy to manage and distribute apps within your organization.
+   - **Efficient Management:** Track and manage applications, versions, testers, and teams effectively, ensuring a smooth distribution process.
+
+These features make the Appcircle Enterprise Mobile App Store a powerful tool for securely and efficiently distributing in-house applications, offering flexibility, enhanced security, and a streamlined workflow.
+
+## System Requirements
+
+**Compatible Agents:**
+
+- macOS 14.2, 14.5
+
+**Supported Version:**
+
+- Fastlane 2.222.0
+- Ruby 3.2.2
+
+Note: We currently support **Appcircle Cloud**, with **self-hosted** support planned in our roadmap.
+
+![Enterprise App Store Dashboard](https://cdn.appcircle.io/docs/assets/entstore-profilelist.png)
+
+### Generating/Managing the Personal API Tokens
+
+To generate a Personal API Token:
+
+1. Go to the My Organization screen (second option at the bottom left).
+2. 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>)
+
+### Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `appcircle_enterprise_app_store`, add it to your project by running:
+
+```bash
+fastlane add_plugin appcircle_enterprise_app_store
+```
+
+After adding the plugin to your project, configure your Fastfile as follows:
+
+```yml
+  lane :distribute_app_store do
+    appcircle_enterprise_app_store(
+      personalAPIToken: "$(AC_PERSONAL_API_TOKEN)",
+      appPath: "$(APP_PATH)",
+      summary: "$(SUMMARY)",
+      releaseNotes: "$(RELEASE_NOTE)",
+      publishType: "$(PUBLISH_TYPE)" # Assign the appropriate number based on the status: None (0), Beta (1), Live (2)
+    )
+  end
+```
+
+- `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.
+- `appPath`: Indicates the file path to the application that will be uploaded to Appcircle Testing Distribution Profile.
+- `releaseNote`: Contains the details of changes, updates, and improvements made in the current version of the app being published.
+- `Summary`: Used to provide a brief overview of the version of the app that is about to be published.
+- `publishType`: Specifies the publishing status as either none, beta, or live, and must be assigned the values "0", "1", or "2" accordingly.
+
+**Ensure that this action is added after build steps have been completed.**
+
+**If two workflows start simultaneously, the last workflow to reach the publish step will be the up-to-date version on the Enterprise App Store. If these workflows building the same package version, the first publish will be successful, while later deployments with the same version will fail.**
+
+### Leveraging Environment Variables
+
+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.
+
+If you would like to learn more about this extension and how to utilize it in your projects, please [contact us](https://appcircle.io/contact?utm_source=fastlane&utm_medium=plugin&utm_campaign=enterprise_app_store)
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+### Reference
+
+For more detailed instructions and support, visit the [Appcircle Enterprise App Store documentation](https://appcircle.io/enterprise-app-store).

data/lib/fastlane/plugin/appcircle_enterprise_app_store/actions/appcircle_enterprise_app_store_action.rb

@@ -0,0 +1,192 @@
+require 'fastlane/action'
+require 'net/http'
+require 'uri'
+require 'json'
+
+require 'fastlane/action'
+require_relative '../helper/appcircle_enterprise_app_store_helper'
+
+require_relative '../helper/auth_service'
+require_relative '../helper/upload_service'
+
+module Fastlane
+  module Actions
+    class AppcircleEnterpriseAppStoreAction < Action
+      @@apiToken = nil
+
+      def self.run(params)
+        personalAPIToken = params[:personalAPIToken]
+        appPath = params[:appPath]
+        summary = params[:summary]
+        releaseNotes = params[:releaseNotes]
+        publishType = params[:publishType]
+
+        valid_extensions = ['.apk', '.ipa']
+
+        file_extension = File.extname(appPath).downcase
+        unless valid_extensions.include?(file_extension)
+          raise "Invalid file extension: #{file_extension}. For Android, use .apk. For iOS, use .ipa."
+        end
+
+        if personalAPIToken.nil?
+          raise UI.error("Please provide Personal API Token to authenticate connections to Appcircle services")
+        elsif appPath.nil?
+          raise UI.error("Please 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")
+        elsif summary.nil?
+          raise UI.error("Please provide a summary for the application to be published. This summary will be displayed in the Appcircle Enterprise App Store")
+        elsif releaseNotes.nil?
+          raise UI.error("Please provide release notes for the application to be published. These notes will be displayed in the Appcircle Enterprise App Store")
+        elsif publishType.nil?
+          raise UI.error("Please specify the publish type for the application. This can be 0: None, 1: Beta, 2: Live. Default is 0: None. For more information, provide the number of the publish type")
+        elsif publishType != "0" && publishType != "1" && publishType != "2"
+          raise UI.error("Please provide a valid publish type. This can be 0: None, 1: Beta, 2: Live. Default is 0: None. For more information, provide the number of the publish type")
+        end
+
+
+        self.ac_login(personalAPIToken)
+        self.uploadToProfile(appPath, summary, releaseNotes, publishType)
+      end
+
+
+      def self.ac_login(accessToken)
+        begin
+          user = AuthService.get_ac_token(pat: accessToken)
+          UI.success("Login is successful.")
+          @@apiToken = user.accessToken
+        rescue => e
+          UI.error("Login failed: #{e.message}")
+          raise e
+        end
+      end
+
+
+      def self.checkTaskStatus(taskId)
+        uri = URI.parse("https://api.appcircle.io/task/v1/tasks/#{taskId}")
+        timeout = 1
+        
+        response = self.send_request(uri, @@apiToken)
+        if response.is_a?(Net::HTTPSuccess)
+          stateValue = JSON.parse(response.body)["stateValue"]
+          if stateValue == 1
+            sleep(1)
+            return checkTaskStatus(taskId)
+          end
+          if stateValue == 3
+            return true
+          else
+            taskStatus = {
+              0 => "Unknown",
+              1 => "Begin",
+              2 => "Canceled",
+              3 => 'Completed',
+            }
+            raise UI.error("#{taskId} id upload request failed with status #{taskStatus[stateValue]}.")
+          end
+        else
+          "Upload failed with response code #{response.code} and message '#{response.message}'"
+          raise
+        end
+      end
+
+
+      def self.uploadToProfile(appPath, summary, releaseNotes, publishType)
+        response = UploadService.upload_artifact(token: @@apiToken, app: appPath)
+        result = self.checkTaskStatus(response["taskId"])
+
+        if result
+          profileId = UploadService.getProfileId(authToken: @@apiToken)
+          appVersions = UploadService.getAppVersions(auth_token: @@apiToken, entProfileId: profileId)
+          appVersionId = UploadService.getVersionId(versionList: appVersions)
+          if publishType != "0"
+            self.publishToStore(profileId, appVersionId, summary, releaseNotes, publishType)
+          end
+          UI.success("#{appPath} uploaded to the Appcircle Enterprise Store successfully")
+        end
+      end
+
+      def self.publishToStore(entProfileId, entVersionId, summary, releaseNote, publishType)
+        begin
+          options = {
+            auth_token: @@apiToken,
+            ent_profile_id: entProfileId,
+            ent_version_id: entVersionId,
+            summary: summary,
+            release_notes: releaseNote,
+            publish_type: publishType
+          }
+          response = UploadService.publishVersion(options)
+        rescue => e
+          UI.error("App could not publish at Enterprise App Store. #{e&.response}")
+          raise e
+        end
+      end
+
+      def self.send_request(uri, access_token)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request["Authorization"] = "Bearer #{access_token}"
+        http.request(request)
+      end
+
+      def self.description
+        "Efficiently publish your apps to Appcircle Enterprise Store"
+      end
+
+      def self.authors
+        ["Guven Karanfil"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Appcircle Enterprise Mobile App Store is your own mobile app store for providing access to in-house apps with a customizable mobile storefront"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :personalAPIToken,
+                                  env_name: "AC_PERSONAL_API_TOKEN",
+                               description: "Provide Personal API Token to authenticate Appcircle services",
+                                  optional: false,
+                                      type: String),
+
+          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",
+                                  optional: false,
+                                      type: String),                            
+
+          FastlaneCore::ConfigItem.new(key: :summary,
+                                  env_name: "AC_SUMMARY",
+                               description: "Provide a summary for the application to be published. This summary will be displayed in the Appcircle Enterprise App Store",
+                                  optional: false,
+                                      type: String),
+
+          FastlaneCore::ConfigItem.new(key: :releaseNotes,
+                                  env_name: "AC_RELEASE_NOTES",
+                               description: "Provide release notes for the application to be published. These notes will be displayed in the Appcircle Enterprise App Store",
+                                  optional: false,
+                                      type: String),
+
+          FastlaneCore::ConfigItem.new(key: :publishType,
+                                  env_name: "AC_PUBLISH_TYPE",
+                               description: "Specify the publish type for the application. This can be 0: None, 1: Beta, 2: Live. Default is 0: None. For more information, provide the number of the publish type",
+                                  optional: false,
+                                      type: String),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/appcircle_enterprise_app_store/helper/appcircle_enterprise_app_store_helper.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class AppcircleEnterpriseAppStoreHelper
+      # class methods that you define here become available in your action
+      # as `Helper::AppcircleEnterpriseAppStoreHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the appcircle_enterprise_app_store plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/appcircle_enterprise_app_store/helper/auth_service.rb

@@ -0,0 +1,49 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+require 'json'
+
+
+class UserResponse
+  attr_accessor :accessToken
+
+  def initialize(accessToken:)
+    @accessToken = accessToken
+  end
+end
+
+module AuthService
+  def self.get_ac_token(pat:)
+    endpoint_url = 'https://auth.appcircle.io/auth/v2/token'
+    uri = URI(endpoint_url)
+
+    # Create HTTP request
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = 'application/x-www-form-urlencoded'
+    request['Accept'] = 'application/json'
+    
+    # Encode parameters
+    params = { pat: pat }
+    request.body = URI.encode_www_form(params)
+
+    # 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)
+
+      user = UserResponse.new(
+        accessToken: response_data['access_token']
+      )
+
+      return user
+    else
+      raise "HTTP Request failed (#{response.code} #{response.message})"
+    end
+  end
+end

data/lib/fastlane/plugin/appcircle_enterprise_app_store/helper/upload_service.rb

@@ -0,0 +1,110 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'rest-client'
+
+BASE_URL = "https://api.appcircle.io"
+
+
+module UploadService
+  def self.upload_artifact(token:, app:)
+    url = "https://api.appcircle.io/store/v2/profiles/app-versions"
+    headers = {
+      Authorization: "Bearer #{token}",
+      content_type: :multipart
+    }
+    payload = {
+      File: File.new(app, 'rb')
+    }
+  
+    begin
+      response = RestClient.post(url, payload, headers)
+      JSON.parse(response.body) rescue response.body
+    rescue RestClient::ExceptionWithResponse => e
+      raise e
+    rescue StandardError => e
+      raise e
+    end
+  end
+
+  def self.getAppVersions(auth_token:, entProfileId:)
+    url = "#{BASE_URL}/store/v2/profiles/#{entProfileId}/app-versions"
+
+    # Set up the headers with authentication
+    headers = {
+      Authorization: "Bearer #{auth_token}",
+      accept: 'application/json'
+    }
+
+    begin
+      response = RestClient.get(url, headers)
+      parsed_response = JSON.parse(response.body)
+
+      parsed_response
+    rescue RestClient::ExceptionWithResponse => e
+      raise e
+    rescue StandardError => e
+      raise e
+    end
+  end
+
+  def self.getVersionId(versionList:)
+    begin
+      if versionList.is_a?(Array) && !versionList.empty?
+        return versionList[0]["id"]
+      else
+        return nil
+      end
+    rescue => e
+      puts "An error occurred while getting app versions: #{e.message}"
+      raise e
+    end
+  end
+
+  def self.publishVersion(options)
+    endpoint = "store/v2/profiles/#{options[:ent_profile_id]}/app-versions/#{options[:ent_version_id]}?action=publish"
+    url = "#{BASE_URL}/#{endpoint}"
+
+    payload = {
+      summary: options[:summary],
+      releaseNotes: options[:release_notes],
+      publishType: options[:publish_type]
+    }
+
+    headers = {
+      'Content-Type': 'application/json',
+      'Authorization': "Bearer #{options[:auth_token]}"
+    }
+
+    response = RestClient.patch(url, payload.to_json, headers)
+    JSON.parse(response.body)
+  rescue RestClient::ExceptionWithResponse => e
+    raise e
+  end
+
+  def self.getEntProfiles(authToken:)
+    url = "#{BASE_URL}/store/v2/profiles?Sort=desc"
+    headers = {
+      Authorization: "Bearer #{authToken}",
+      accept: 'application/json'
+    }
+
+    begin
+      response = RestClient.get(url, headers)
+      parsed_response = JSON.parse(response.body)
+
+      parsed_response
+    rescue RestClient::ExceptionWithResponse => e
+      raise e
+    rescue StandardError => e
+      raise e
+    end
+  end
+
+  def self.getProfileId(authToken:)
+    profiles = self.getEntProfiles(authToken: authToken)
+    sortedProfiles = profiles.sort_by { |profile| DateTime.parse(profile["lastBinaryReceivedDate"]) }.reverse
+
+    return sortedProfiles[0]['id']
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module AppcircleEnterpriseAppStore
+    VERSION = "0.0.1"
+  end
+end

data/lib/fastlane/plugin/appcircle_enterprise_app_store.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/appcircle_enterprise_app_store/version'
+
+module Fastlane
+  module AppcircleEnterpriseAppStore
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::AppcircleEnterpriseAppStore.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-appcircle_enterprise_app_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- appcircleio
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email: cloud@appcircle.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/appcircle_enterprise_app_store.rb
+- lib/fastlane/plugin/appcircle_enterprise_app_store/actions/appcircle_enterprise_app_store_action.rb
+- lib/fastlane/plugin/appcircle_enterprise_app_store/helper/appcircle_enterprise_app_store_helper.rb
+- lib/fastlane/plugin/appcircle_enterprise_app_store/helper/auth_service.rb
+- lib/fastlane/plugin/appcircle_enterprise_app_store/helper/upload_service.rb
+- lib/fastlane/plugin/appcircle_enterprise_app_store/version.rb
+homepage: https://github.com/appcircleio/fastlane-plugin-appcircle_enterprise_app_store
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'false'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Efficiently publish your apps to Appcircle Enterprise Store
+test_files: []