fastlane-plugin-lazurite 0.1.0.beta.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9dc6aa238669fce3d0ca63a9dfb4e5447e4d61f73d1ea23dc84210cf36abb4b
+  data.tar.gz: 611fa67d879ad86ec9b006a3e0cad6e007aa0841265018cecc4321fe9b77e84a
+SHA512:
+  metadata.gz: 0ae50a59b5c7d41b80b1471bc65705df7a6cdc9ea6ad984c2be1c54a0302920a15f01d6cb8e5f852cb8d592982a11a007d87b00520f883aecc11dfa1051dc6e0
+  data.tar.gz: d80df8c63ccfe88954fea80b66029422e3bedd5523c7789ecf57dd817bcafb83e6e62af0c7819f1298d594a975a4c1ba76d67ae5a6469d38c25511364318e31a

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 CheeryLee
+
+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,66 @@
+# Lazurite
+
+<p align="center">
+<a href="https://opensource.org/licenses/MIT">
+  <img alt="Gem" src="https://img.shields.io/badge/License-MIT-yellow.svg">
+</a>
+<a href="https://github.com/CheeryLee/fastlane-plugin-lazurite/releases">
+  <img alt="Gem" src="https://img.shields.io/github/v/release/CheeryLee/fastlane-plugin-lazurite?display_name=tag&include_prereleases">
+</a>
+<img alt="Work in progress" src="https://img.shields.io/badge/stability-work_in_progress-lightgrey.svg">
+</p>
+
+<br/>
+<p align="center">Плагин Fastlane для работы с развертыванием Android-приложений в <b>RuStore</b></p>
+<br/>
+
+## Возможности
+Данный плагин предлагает широкий функционал:
+* заливка пакета в магазин;
+* добавление скриншотов и иконки;
+* изменение названия и описания приложения;
+* выбор категории и типа приложения;
+* непрерывная интеграция за счет автоматического удаления черновиков, не прошедших модерацию.
+
+
+## Установка
+
+Чтобы начать работу, добавьте ссылку на плагин в своем файле `fastlane/Pluginfile`:
+```ruby
+gem "fastlane-plugin-lazurite", git: "https://github.com/CheeryLee/fastlane-plugin-lazurite.git" 
+```
+
+## Использование
+### Получение информации
+После установки вы можете вызвать следующую команду для получения дополнительной информации о каждом action:
+```shell
+fastlane action upload_to_rustore # или любой другой action
+```
+
+### Action-ы
+Ниже представлен список всех доступных action-ов. Чтобы узнать подробнее о каждом, нажмите на соответствующее поле в таблице.
+Список сгруппирован по категории Fastlane.
+
+#### 📦 Production
+
+| Аргумент                                               | Описание                        |
+|--------------------------------------------------------|---------------------------------|
+| [upload_to_rustore](docs/actions/upload_to_rustore.md) | Загружает новый пакет в RuStore |
+#### 🔆 Misc
+
+| Аргумент                                                   | Описание                         |
+|------------------------------------------------------------|----------------------------------|
+| [rustore_credentials](docs/actions/rustore_credentials.md) | Настраивает данные доступа к API |
+
+## Обратная связь
+
+По всем вопросам, связанным с данным проектом, используйте [GitHub issue](https://github.com/CheeryLee/fastlane-plugin-lazurite/issues).
+
+## Решение проблем
+
+Если остались какие-то вопросы касательно работы с плагинами, загляните на эту страницу:
+[Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/).
+
+## Лицензия
+
+Проект лицензирован под [MIT лицензией](LICENSE).

data/lib/fastlane/plugin/lazurite/actions/rustore_credentials_action.rb

@@ -0,0 +1,83 @@
+require "fastlane/action"
+require_relative "../helper/uploader"
+
+module Fastlane
+  module Actions
+    class RustoreCredentialsAction < Action
+      def self.run(params)
+        private_key = ""
+
+        if params.values.include?(:private_key_file) && !params[:private_key_file].nil?
+          private_key = File.read(File.expand_path(params[:private_key_file]))
+        elsif params.values.include?(:private_key) && !params[:private_key].nil?
+          private_key = params[:private_key]
+        else
+          UI.user_error!("You need to provide the private API key")
+        end
+
+        private_key = private_key.strip
+        Helper::Uploader.authorize(params[:company_id], private_key)
+        UI.success("Credentials for RuStore account are successfully saved for further actions")
+      end
+
+      def self.description
+        "Sets RuStore account credentials needed for authorization"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :company_id,
+            description: "ID of RuStore company",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Company ID can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :private_key_file,
+            description: [
+              "The path to file where private API key is located.",
+              "Either use it or provide the raw key content with `private_key` option"
+            ].join("\n"),
+            optional: true,
+            conflicting_options: [:private_key],
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Path to the private API key file is invalid") unless value && !value.empty?
+              UI.user_error!("There is no any file that provided in API key file path") unless
+                File.exist?(File.expand_path(value))
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :private_key,
+            description: [
+              "The private API key content.",
+              "Either use it or provide the key content in a file with `private_key_file` option"
+            ].join("\n"),
+            optional: true,
+            conflicting_options: [:private_key_file],
+            sensitive: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("API key can't be empty") unless value && !value.empty?
+            end
+          )
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/lazurite/actions/upload_to_rustore_action.rb

@@ -0,0 +1,310 @@
+require "fastlane/action"
+require_relative "../helper/enums"
+
+module Fastlane
+  module Actions
+    class UploadToRustoreAction < Action
+      SHORT_DESCRIPTION_LENGTH = 80
+      FULL_DESCRIPTION_LENGTH = 4000
+      CHANGELOG_LENGTH = 500
+      SCREENSHOTS_COUNT = 10
+      APP_CATEGORIES_COUNT = 2
+      PACKAGES_COUNT = 10
+
+      def self.run(params)
+        UI.user_error!("Publish time must be provided while uploading with DELAYED type of publishing") if
+          params.values[:publish_type] == Helper::PublishType::DELAYED && params.values[:publish_date_time].nil?
+        UI.user_error!("App categories validation failed. Check the errors above.") unless validate_app_categories(params)
+
+        version = create_draft(params)
+        upload_apk(params, version)
+        upload_icon(params, version)
+        upload_screenshots(params, version)
+      end
+
+      def self.description
+        "Uploads app metadata, screenshots, icons and app bundles to RuStore"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :package_name,
+            description: "The package name of the application to use",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Package name can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :app_name,
+            description: "The custom application name",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Custom application name can't be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :short_description,
+            description: "The short application description text",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.important("Short description length is more than #{SHORT_DESCRIPTION_LENGTH} characters. The rest part will be ended with ellipsis.") if
+                !value.nil? && value.length > SHORT_DESCRIPTION_LENGTH
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :full_description,
+            description: "The full application description text",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.important("Full description length is more than #{FULL_DESCRIPTION_LENGTH} characters. The rest part will be ended with ellipsis.") if
+                !value.nil? && value.length > FULL_DESCRIPTION_LENGTH
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :changelog,
+            description: "The changelog text",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.important("Changelog length is more than #{CHANGELOG_LENGTH} characters. The rest part will be ended with ellipsis.") if
+                !value.nil? && value.length > CHANGELOG_LENGTH
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :publish_type,
+            description: "Should app be published after moderation",
+            optional: true,
+            default_value: Helper::PublishType::MANUAL,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Publish type must have one of the followed values: #{Helper.all_constants(Helper::PublishType).join(", ")}") unless
+                value && Helper.has_constant?(Helper::PublishType, value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :publish_date_time,
+            description: "The date time when app would be automatically released after moderation passed",
+            optional: true,
+            type: Time,
+            verify_block: proc do |value|
+              UI.user_error!("The specified time can't be older than now") unless
+                value && value >= Time.now
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :app_type,
+            description: "The app type: MAIN or GAMES",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("App type must have one of the followed values: #{Helper.all_constants(Helper::AppType).join(", ")}") unless
+                value && Helper.has_constant?(Helper::AppType, value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :categories,
+            description: "The app categories",
+            optional: true,
+            type: Array,
+            verify_block: proc do |array|
+              UI.user_error!("App categories array can't be empty") if array.empty?
+              UI.important("Maximum count of app categories is #{APP_CATEGORIES_COUNT}") if array.length > APP_CATEGORIES_COUNT
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :apks,
+            description: "An array of paths to APK files and their metadata to upload",
+            optional: false,
+            type: Array,
+            verify_block: proc do |array|
+              UI.user_error!("Packages array can't be empty") if array.empty?
+              UI.important("Maximum count of packages is #{PACKAGES_COUNT}") if array.length > PACKAGES_COUNT
+
+              counter = 0
+              has_error = false
+
+              array.each do |value|
+                has_error &&= !validate_apk(value, counter)
+                counter += 1
+              end
+
+              unless array.find_all { |x| x.include?(:is_main_apk) && x[:is_main_apk] == true }.empty?
+                UI.error(`Only one package can be chosen as main`)
+                has_error = true
+              end
+
+              UI.user_error!("Some APK settings contain errors. Check them above.") if has_error
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :remove_active_draft,
+            description: "Automatically remove the last created draft",
+            optional: true,
+            default_value: false,
+            type: Fastlane::Boolean
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :timeout,
+            description: "Request timeout in seconds applied to individual HTTP requests",
+            optional: true,
+            default_value: 1200,
+            type: Integer,
+            verify_block: proc do |value|
+              UI.important("Request timeout can't be less than or equal to zero. Using default value.") if
+                value.zero? || value.negative?
+            end
+          )
+        ]
+      end
+
+      def self.category
+        :production
+      end
+
+      def self.create_draft(params)
+        # remove active draft if needed
+        if params.values.include?(:remove_active_draft) && [true].include?(params.values[:remove_active_draft])
+          active_version = Helper::Uploader.get_active_version(params[:package_name], params[:timeout])
+
+          unless active_version == -1
+            data = {
+              package: params[:package_name],
+              version: active_version
+            }
+
+            UI.message("Removing active draft with ID = #{active_version} ...")
+            Helper::Uploader.remove_draft(data, params[:timeout])
+            UI.success("The draft ID = #{active_version} has been removed")
+          end
+        end
+
+        data = {
+          package: params[:package_name],
+          publish_type: params.values[:publish_type]
+        }
+
+        data[:app_name] = params.values[:app_name] if
+          !params.values[:app_name].nil? && !params.values[:app_name].empty?
+        data[:short_description] = params.values[:short_description] if
+          !params.values[:short_description].nil? && !params.values[:short_description].empty?
+        data[:full_description] = params.values[:full_description] if
+          !params.values[:full_description].nil? && !params.values[:full_description].empty?
+        data[:changelog] = params.values[:changelog] if
+          !params.values[:changelog].nil? && !params.values[:changelog].empty?
+        data[:publish_date_time] = params.values[:publish_date_time] unless params.values[:publish_date_time].nil?
+
+        UI.message("Creating a draft ...")
+        version = Helper::Uploader.create_draft(data, params[:timeout])
+        UI.success("A new draft has been created: #{version}")
+      end
+
+      def self.upload_apk(params, version)
+        UI.message("Process packages ...")
+
+        counter = 0
+        params.values[:apks].each do |apk|
+          break if counter >= PACKAGES_COUNT
+
+          data = {
+            package: params[:package_name],
+            version: version,
+            file: File.expand_path(apk[:file]),
+            services_type: apk.include?(:services_type) && apk[:services_type].is_a?(String) ? apk[:services_type] : Helper::ServicesType::UNKNOWN,
+            is_main_apk: apk.include?(:is_main_apk) && [true, false].include?(apk[:is_main_apk]) ? apk[:is_main_apk] : false
+          }
+
+          UI.message("Uploading package with the following values:")
+          UI.message("---------------------")
+
+          data_str = JSON.pretty_generate(data)
+          data_str.each_line do |x|
+            UI.message(x.gsub("\n", ""))
+          end
+
+          UI.message("---------------------")
+          Helper::Uploader.upload_apk(data, params[:timeout])
+          UI.success("Package has been uploaded successfully")
+
+          counter += 1
+        end
+      end
+
+      def self.commit(params, version)
+        data = {
+          package: params[:package_name],
+          version: version,
+          priority_update: 0
+        }
+
+        UI.message("Committing the draft ...")
+        Helper::Uploader.commit(data, params[:timeout])
+        UI.success("Submission passed! Wait until moderation process ends")
+      end
+
+      def self.validate_apk(value, counter)
+        has_error = false
+        path = File.expand_path(value[:path])
+        services_type = value[:services_type]
+
+        unless value.include?(:is_main_apk)
+          UI.error("[#{counter}] You must define is this APK file main or not")
+          has_error = true
+        end
+
+        unless path && !path.empty?
+          UI.error("[#{counter}] Path to the APK file is invalid: #{path}")
+          has_error = true
+        end
+
+        unless File.exist?(path)
+          UI.error("[#{counter}] There is no any file that provided in APK file path: #{path}")
+          has_error = true
+        end
+
+        unless path.end_with?(".apk")
+          UI.error("[#{counter}] Path to the APK file doesn't point to the file with .apk extension: #{path}")
+          has_error = true
+        end
+
+        if !services_type.is_a?(String) || (!services_type.nil? && !services_type.empty? && !Helper.has_constant?(Helper::ServicesType, services_type))
+          constants = Helper.all_constants(Helper::ServicesType)
+          UI.error("[#{counter}] Incorrect services type for #{path}. Pick one from this array: #{constants.join(", ")}")
+          has_error = true
+        end
+
+        !has_error
+      end
+
+      def self.validate_app_categories(params)
+        return true if params.values[:categories].nil?
+
+        has_error = false
+
+        if params.values[:app_type].nil?
+          UI.error("App type must be defined along with chosen categories")
+        else
+          app_category_module = params.values[:app_type] == Helper::AppType::MAIN ? Helper::AppCategory::Main : Helper::AppCategory::Games
+          params.values[:categories].each do |x|
+            UI.error("Unknown app category: #{x}") if Helper.has_constant?(app_category_module, x)
+          end
+        end
+
+        !has_error
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/lazurite/helper/config.rb

@@ -0,0 +1,40 @@
+require "time"
+
+module Fastlane
+  module Helper
+    class Config
+      attr_accessor :company_id
+      attr_accessor :private_key
+    end
+
+    class AuthData
+      attr_accessor :token
+      attr_accessor :created_at
+      attr_accessor :time
+
+      def valid?
+        current_time = Time.now.to_i
+        token? && current_time < (@created_at + @time)
+      end
+
+      def token?
+        @token.is_a?(String) && !@token.nil? && !@token.empty?
+      end
+
+      def setup(token, time)
+        @token = token
+        @created_at = Time.now.to_i
+        @time = time
+      end
+    end
+
+    class << self
+      attr_accessor :config
+      attr_accessor :auth_data
+    end
+
+    self.config = Config.new
+    self.auth_data = AuthData.new
+    self.auth_data.setup("", 0)
+  end
+end

data/lib/fastlane/plugin/lazurite/helper/enums.rb

@@ -0,0 +1,80 @@
+module Fastlane
+  module Helper
+    def self.has_constant?(module_type, value)
+      !module_type.constants.find { |x| module_type.const_get(x) == value }.nil?
+    end
+
+    def self.all_constants(module_type)
+      module_type.constants.map { |x| module_type.const_get(x) }
+    end
+
+    module ScreenshotOrientation
+      LANDSCAPE = "LANDSCAPE"
+      PORTRAIT = "PORTRAIT"
+    end
+
+    module AppType
+      MAIN = "MAIN"
+      GAMES = "GAMES"
+    end
+
+    module ServicesType
+      UNKNOWN = "Unknown"
+      HMS = "HMS"
+    end
+
+    module PublishType
+      MANUAL = "MANUAL"
+      INSTANTLY = "INSTANTLY"
+      DELAYED = "DELAYED"
+    end
+
+    module AppCategory
+      module Main
+        BUSINESS = "business"
+        STATE = "state"
+        FOOD_AND_DRINK = "foodAndDrink"
+        HEALTH = "health"
+        BOOKS = "books"
+        NEWS = "news"
+        LIFESTYLE = "lifestyle"
+        EDUCATION = "education"
+        SOCIAL = "social"
+        ADS_AND_SERVICES = "adsAndServices"
+        PETS = "pets"
+        PURCHASES = "purchases"
+        TOOLS = "tools"
+        TRAVELLING = "travelling"
+        ENTERTAINMENT = "entertainment"
+        PARENTING = "parenting"
+        SPORT = "sport"
+        GAMBLING = "gambling"
+        TRANSPORT = "transport"
+        FINANCE = "finance"
+      end
+
+      module Games
+        ARCADE = "arcade"
+        QUIZ = "quiz"
+        PUZZLE = "puzzle"
+        RACE = "race"
+        CHILDREN = "children"
+        AR = "ar"
+        INDIE = "indie"
+        CASINO = "casino"
+        CASUAL = "casual"
+        CARD = "card"
+        MUSIC = "music"
+        BOARD = "board"
+        ADVENTURE = "adventure"
+        ROLE_PLAYING = "rolePlaying"
+        FAMILY = "family"
+        SIMULATOR = "simulator"
+        WORD = "word"
+        SPORTS = "sports"
+        STRATEGY = "strategy"
+        ACTION = "action"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/lazurite/helper/uploader.rb

@@ -0,0 +1,214 @@
+require "time"
+require "openssl"
+require "base64"
+
+module Fastlane
+  module Helper
+    class Uploader
+      HOST = "https://public-api.rustore.ru".freeze
+      API_VERSION = "/public/v1".freeze
+      REQUEST_HEADERS = {
+        "Accept": "application/json"
+      }.freeze
+
+      def self.authorize(company_id, private_key, timeout = 0)
+        timestamp = Time.at(Time.now.to_i - 10).iso8601
+        signature_data = "#{company_id}#{timestamp}"
+        private_key = "-----BEGIN RSA PRIVATE KEY-----\n#{private_key}\n-----END RSA PRIVATE KEY-----"
+        signature = OpenSSL::PKey::RSA.new(private_key).sign(OpenSSL::Digest.new("SHA512"), signature_data)
+        signature_hex = Base64.encode64(signature)
+
+        body = {
+          companyId: company_id,
+          timestamp: timestamp,
+          signature: signature_hex
+        }
+        headers = {
+          "Content-Type": "application/json"
+        }.merge(REQUEST_HEADERS)
+
+        begin
+          connection = Faraday.new(HOST)
+          response = connection.post("/public/auth") do |req|
+            req.headers = headers
+            req.body = body.to_json
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          response_data = JSON.parse(response.body)
+
+          if response.status == 200
+            token = response_data["body"]["jwe"]
+            time = response_data["body"]["ttl"]
+
+            Helper.auth_data.setup(token, time)
+            UI.message("Received a new authorization token. Current time: #{Helper.auth_data.created_at}, time to live: #{Helper.auth_data.time}")
+          else
+            request_error(response_data)
+          end
+        rescue StandardError => ex
+          UI.user_error!("Authorization failed: #{ex}")
+        end
+      end
+
+      def self.create_draft(data, timeout = 0)
+        check_auth_token
+
+        body = {
+          appName: data[:app_name],
+          shortDescription: data[:short_description],
+          fullDescription: data[:full_description],
+          whatsNew: data[:changelog],
+          publishType: data[:publish_type],
+          publishDateTime: data[:publish_date_time]
+        }
+
+        begin
+          connection = Faraday.new(HOST)
+          response = connection.post("#{API_VERSION}/application/#{data[:package]}/version") do |req|
+            req.headers = build_headers(Helper.auth_data.token)
+            req.body = body.to_json
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          response_data = JSON.parse(response.body)
+          request_error(response_data) if response.status != 200
+
+          response_data["body"]
+        rescue StandardError => ex
+          UI.user_error!("Draft creation failed: #{ex}")
+        end
+      end
+
+      def self.remove_draft(data, timeout = 0)
+        check_auth_token
+
+        begin
+          connection = Faraday.new(HOST)
+          response = connection.delete("#{API_VERSION}/application/#{data[:package]}/version/#{data[:version]}") do |req|
+            req.headers = build_headers(Helper.auth_data.token)
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          response_data = JSON.parse(response.body)
+          request_error(response_data) if response.status != 200
+        rescue StandardError => ex
+          UI.user_error!("Draft removal failed: #{ex}")
+        end
+      end
+
+      def self.get_active_version(package_id, timeout = 0)
+        check_auth_token
+
+        begin
+          connection = Faraday.new(HOST)
+          response = connection.get("#{API_VERSION}/application/#{package_id}/version") do |req|
+            req.headers = build_headers(Helper.auth_data.token)
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          response_data = JSON.parse(response.body)
+          request_error(response_data) if response.status != 200
+
+          versions = response_data["body"]["content"]
+          version_obj = versions.find { |x| x["versionStatus"] == "DRAFT" }
+
+          !version_obj.nil? ? version_obj["versionId"] : -1
+        rescue StandardError => ex
+          UI.user_error!("Can't get active draft version: #{ex}")
+        end
+      end
+
+      def self.upload_apk(data, timeout = 0)
+        check_auth_token
+
+        body = {
+          file: Faraday::Multipart::FilePart.new(data[:file], "application/octet-stream")
+        }
+        query = {
+          servicesType: data[:services_type],
+          isMainApk: data[:is_main_apk]
+        }
+        headers = build_headers(Helper.auth_data.token)
+        headers["Content-Type"] = "multipart/form-data"
+
+        begin
+          connection = Faraday.new(HOST) do |con|
+            con.request :multipart
+          end
+          response = connection.post("#{API_VERSION}/application/#{data[:package]}/version/#{data[:version]}/apk") do |req|
+            req.headers = headers
+            req.params = query
+            req.body = body
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          response_data = JSON.parse(response.body)
+          request_error(response_data) if response.status != 200
+        rescue StandardError => ex
+          UI.user_error!("Package uploading failed: #{ex}")
+        end
+      end
+
+      def self.commit(data, timeout = 0)
+        check_auth_token
+
+        query = {
+          priorityUpdate: data[:priority_update]
+        }
+
+        begin
+          connection = Faraday.new(HOST)
+          response = connection.post("#{API_VERSION}/application/#{data[:package]}/version/#{data[:version]}/commit") do |req|
+            req.headers = build_headers(Helper.auth_data.token)
+            req.params = query
+            req.body = body
+            req.options.timeout = timeout if timeout.positive?
+          end
+
+          response_data = JSON.parse(response.body)
+          request_error(response_data) if response.status != 200
+        rescue StandardError => ex
+          UI.user_error!("Draft committing failed: #{ex}")
+        end
+      end
+
+      def self.check_auth_token
+        return if Helper.auth_data.valid?
+
+        UI.user_error!("No authorization data has provided. You need to call `rustore_credentials` action first.") unless
+          Helper.auth_data.token?
+        UI.important("Authorization token is not valid. Renewing...")
+        authorize(Helper.config.company_id, Helper.config.private_key)
+      end
+
+      def self.build_headers(auth_token)
+        {
+          "Public-Token": auth_token,
+          "Content-Type": "application/json"
+        }.merge(REQUEST_HEADERS)
+      end
+
+      def self.request_error(data)
+        error_code = data["code"]
+        error_description = data["message"]
+        UI.user_error!("Request returned the error.\nCode: #{error_code}\nDescription: #{error_description}")
+      end
+
+      public_class_method(:authorize)
+      public_class_method(:create_draft)
+      public_class_method(:remove_draft)
+      public_class_method(:get_active_version)
+      public_class_method(:upload_apk)
+      public_class_method(:commit)
+
+      private_class_method(:check_auth_token)
+      private_class_method(:build_headers)
+      private_class_method(:request_error)
+
+      private_constant(:HOST)
+      private_constant(:API_VERSION)
+      private_constant(:REQUEST_HEADERS)
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Lazurite
+    VERSION = "0.1.0.beta.1"
+  end
+end

data/lib/fastlane/plugin/rustore.rb

@@ -0,0 +1,16 @@
+require "fastlane/plugin/lazurite/version"
+
+module Fastlane
+  module Lazurite
+    # 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::Lazurite.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-lazurite
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta.1
+platform: ruby
+authors:
+- CheeryLee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.200.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.200.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.48.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.48.0
+description: 
+email:
+- cheerylee90@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/lazurite/actions/rustore_credentials_action.rb
+- lib/fastlane/plugin/lazurite/actions/upload_to_rustore_action.rb
+- lib/fastlane/plugin/lazurite/helper/config.rb
+- lib/fastlane/plugin/lazurite/helper/enums.rb
+- lib/fastlane/plugin/lazurite/helper/uploader.rb
+- lib/fastlane/plugin/lazurite/version.rb
+- lib/fastlane/plugin/rustore.rb
+homepage: https://github.com/CheeryLee/fastlane-plugin-rustore
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Faslane plugin for RuStore deployment
+test_files: []