fastlane-plugin-rustore_publish 0.3.1

data/lib/fastlane/plugin/rustore_publish/actions/rustore_upload.rb

@@ -0,0 +1,523 @@
+require "fastlane/action"
+require_relative "../helper/rustore_auth"
+require_relative "../helper/rustore_client"
+require_relative "../helper/rustore_logger"
+
+module Fastlane
+  module Actions
+    class RustoreUploadAction < Action
+      TOTAL_STEPS = 5
+
+      def self.run(params)
+        logger = RustorePublish::RustoreLogger.new(total_steps: TOTAL_STEPS)
+
+        # ── Step 1: Authentication ─────────────────────────────────────────────
+        logger.step(1, "Authentication")
+
+        private_key = params[:private_key] || File.read(params[:private_key_path])
+        auth = RustorePublish::RustoreAuth.new(
+          key_id:      params[:key_id],
+          private_key: private_key,
+          logger:      logger
+        )
+        auth.refresh!
+        logger.success("JWE token obtained (valid 900s, auto-refresh enabled)")
+
+        client       = RustorePublish::RustoreClient.new(auth: auth, logger: logger, upload_timeout: params[:upload_timeout])
+        package_name = params[:package_name]
+
+        # ── Step 2: Draft Management ───────────────────────────────────────────
+        logger.step(2, "Draft Management")
+
+        existing = client.find_existing_draft(package_name: package_name)
+        if existing
+          draft_id = existing["publishId"] || existing["versionId"]
+          logger.warning("Found existing draft (id=#{draft_id}) — deleting it")
+          client.delete_draft(package_name: package_name, version_id: draft_id)
+          logger.info("Existing draft deleted")
+        end
+
+        whats_new          = params[:whats_new]
+        moder_info         = params[:moder_info]
+        publish_type       = params[:publish_type]
+        release_date       = params[:release_date]
+        rollout_percentage = params[:rollout_percentage]
+
+        if release_date && publish_type != "DELAYED"
+          logger.warning("release_date is set but publish_type is '#{publish_type}' — only used with DELAYED")
+        end
+
+        draft_meta = {}
+        draft_meta[:whatsNew]        = whats_new        if whats_new
+        draft_meta[:moderInfo]       = moder_info       if moder_info
+        draft_meta[:publishType]     = publish_type
+        draft_meta[:publishDateTime] = release_date     if release_date
+        draft_meta[:partialValue]    = rollout_percentage if rollout_percentage
+
+        # Draft metadata (RuStore API v2)
+        developer_contacts = params[:developer_contacts]
+        draft_meta[:developerContacts] = normalize_developer_contacts(developer_contacts) if developer_contacts
+        draft_meta[:appName]   = params[:app_name]  if params[:app_name]
+        draft_meta[:appType]   = params[:app_type]  if params[:app_type]
+        draft_meta[:ageLegal]  = params[:age_legal] if params[:age_legal]
+        draft_meta[:shortDescription] = params[:short_description] if params[:short_description]
+        draft_meta[:fullDescription]  = params[:full_description]  if params[:full_description]
+        draft_meta[:priceValue]       = params[:price_value]       if params[:price_value]
+        draft_meta[:categories] = params[:categories]  if params[:categories]
+        draft_meta[:seoTagIds]  = params[:seo_tag_ids] if params[:seo_tag_ids]
+        draft_meta[:faq] = params[:faq] if params[:faq]
+
+        version_id = client.create_draft(package_name: package_name, **draft_meta)
+        logger.success("Draft created (versionId=#{version_id})")
+        logger.table([
+          ["Package",        package_name],
+          ["Version ID",     version_id],
+          ["What's new",     whats_new  || "(not set)"],
+          ["Moderator note", moder_info || "(not set)"],
+          ["Publish type",   publish_type],
+          ["Rollout",        rollout_percentage ? "#{rollout_percentage}%" : "100%"],
+          ["Release date",   release_date || "(not set)"],
+          ["Update priority", params[:update_priority]],
+          ["Upload timeout", "#{params[:upload_timeout]}s"]
+        ])
+
+        # ── Step 3: Upload primary build ───────────────────────────────────────
+        aab_path     = params[:aab_path]
+        apk_path     = params[:apk_path]
+        hms_apk_path = params[:hms_apk_path]
+
+        primary_label = aab_path ? "Uploading AAB (GMS/main)" : "Uploading APK (main)"
+        logger.step(3, primary_label)
+
+        if aab_path
+          validate_file!(aab_path, "aab_path", ".aab", logger)
+          logger.table([
+            ["File",          File.basename(aab_path)],
+            ["Size",          "#{(File.size(aab_path) / 1_048_576.0).round(1)} MB"],
+            ["Type",          "AAB (main/GMS)"],
+            ["services_type", "Unknown"],
+            ["is_main",       "true (implicit for AAB)"]
+          ])
+          client.upload_aab(
+            package_name: package_name,
+            version_id:   version_id,
+            file_path:    aab_path
+          )
+          logger.success("AAB uploaded successfully")
+
+        elsif apk_path
+          validate_file!(apk_path, "apk_path", ".apk", logger)
+          logger.table([
+            ["File",          File.basename(apk_path)],
+            ["Size",          "#{(File.size(apk_path) / 1_048_576.0).round(1)} MB"],
+            ["Type",          "APK (main/GMS)"],
+            ["services_type", "Unknown"],
+            ["is_main",       "true"]
+          ])
+          client.upload_apk(
+            package_name:  package_name,
+            version_id:    version_id,
+            file_path:     apk_path,
+            services_type: RustorePublish::RustoreClient::SERVICES_TYPE_UNKNOWN,
+            is_main_apk:   true
+          )
+          logger.success("APK uploaded successfully")
+        else
+          logger.error(
+            "No build file provided",
+            hint: "Specify at least `aab_path` or `apk_path`"
+          )
+        end
+
+        # ── Step 4: Upload HMS APK (optional) ─────────────────────────────────
+        logger.step(4, "Uploading APK (HMS/secondary)")
+
+        if hms_apk_path
+          validate_file!(hms_apk_path, "hms_apk_path", ".apk", logger)
+          logger.table([
+            ["File",          File.basename(hms_apk_path)],
+            ["Size",          "#{(File.size(hms_apk_path) / 1_048_576.0).round(1)} MB"],
+            ["Type",          "APK (secondary/HMS)"],
+            ["services_type", "HMS"],
+            ["is_main",       "false"]
+          ])
+          client.upload_apk(
+            package_name:  package_name,
+            version_id:    version_id,
+            file_path:     hms_apk_path,
+            services_type: RustorePublish::RustoreClient::SERVICES_TYPE_HMS,
+            is_main_apk:   false
+          )
+          logger.success("HMS APK uploaded successfully")
+        else
+          logger.info("Skipped (no hms_apk_path provided)")
+        end
+
+        # ── Step 5: Submit for moderation ─────────────────────────────────────
+        logger.step(5, "Submitting for moderation")
+        client.submit_for_review(package_name: package_name, version_id: version_id, update_priority: params[:update_priority])
+
+        case publish_type
+        when "INSTANTLY"
+          logger.success("Submitted — RuStore will publish automatically after moderation")
+        when "DELAYED"
+          logger.success("Submitted — scheduled for #{release_date}")
+        when "MANUAL"
+          logger.success("Submitted — publish manually from RuStore Console after moderation passes")
+        end
+
+        logger.finalize
+        UI.success("#{RustorePublish::RustoreLogger::PREFIX} All done! #{package_name} versionId=#{version_id} submitted to RuStore.")
+      end
+
+      # ── Parameter definitions ────────────────────────────────────────────────
+
+      def self.available_options
+        [
+          # ── Authentication ─────────────────────────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:         :key_id,
+            env_name:    "RUSTORE_KEY_ID",
+            description: "API key ID from RuStore Console → Company → API RuStore",
+            type:        String,
+            optional:    false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :private_key_path,
+            env_name:    "RUSTORE_PRIVATE_KEY_PATH",
+            description: "Path to RSA private key PEM file (mutually exclusive with private_key)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v| UI.user_error!("private_key_path file not found: #{v}") unless File.exist?(v) }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :private_key,
+            env_name:    "RUSTORE_PRIVATE_KEY",
+            description: "RSA private key PEM content (mutually exclusive with private_key_path)",
+            type:        String,
+            optional:    true,
+            sensitive:   true
+          ),
+
+          # ── App identity ───────────────────────────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:         :package_name,
+            env_name:    "RUSTORE_PACKAGE_NAME",
+            description: "Application package name (e.g. com.example.app)",
+            type:        String,
+            optional:    false
+          ),
+
+          # ── Build files ────────────────────────────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:         :aab_path,
+            env_name:    "RUSTORE_AAB_PATH",
+            description: "Path to AAB file (Google/GMS build — becomes the main artifact)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v| UI.user_error!("aab_path file not found: #{v}") unless File.exist?(v) }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :apk_path,
+            env_name:    "RUSTORE_APK_PATH",
+            description: "Path to APK file (used when aab_path is not provided; becomes main artifact)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v| UI.user_error!("apk_path file not found: #{v}") unless File.exist?(v) }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :hms_apk_path,
+            env_name:    "RUSTORE_HMS_APK_PATH",
+            description: "Path to Huawei/HMS APK file (uploaded with servicesType=HMS, isMainApk=false)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v| UI.user_error!("hms_apk_path file not found: #{v}") unless File.exist?(v) }
+          ),
+
+          # ── Release notes ──────────────────────────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:         :whats_new,
+            env_name:    "RUSTORE_WHATS_NEW",
+            description: "Release notes shown to users (max 5000 chars, plain text)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v| UI.user_error!("whats_new must not exceed 5000 characters") if v.length > 5000 }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :moder_info,
+            env_name:    "RUSTORE_MODER_INFO",
+            description: "Notes for the RuStore moderator, e.g. test credentials (max 180 chars)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v| UI.user_error!("moder_info must not exceed 180 characters") if v.length > 180 }
+          ),
+
+          # ── Publication ────────────────────────────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:           :publish_type,
+            env_name:      "RUSTORE_PUBLISH_TYPE",
+            description:   "INSTANTLY — auto-publish after moderation; MANUAL — publish from Console; DELAYED — scheduled via release_date",
+            default_value: "INSTANTLY",
+            type:          String,
+            optional:      true,
+            verify_block:  proc { |v| UI.user_error!("publish_type must be INSTANTLY, MANUAL, or DELAYED") unless %w[INSTANTLY MANUAL DELAYED].include?(v) }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :release_date,
+            env_name:    "RUSTORE_RELEASE_DATE",
+            description: "Scheduled release datetime in ISO 8601 format (only used with DELAYED)",
+            type:        String,
+            optional:    true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :rollout_percentage,
+            env_name:    "RUSTORE_ROLLOUT_PERCENTAGE",
+            description: "Staged rollout: allowed values are 5, 10, 25, 50, 75, 100; omit for full rollout",
+            type:        Integer,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("rollout_percentage must be one of: 5, 10, 25, 50, 75, 100") unless [5, 10, 25, 50, 75, 100].include?(v)
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:           :update_priority,
+            env_name:      "RUSTORE_UPDATE_PRIORITY",
+            description:   "In-app update priority sent with the moderation request: 0 (min) to 5 (max)",
+            default_value: 0,
+            type:          Integer,
+            optional:      true,
+            verify_block:  proc { |v| UI.user_error!("update_priority must be between 0 and 5") unless (0..5).cover?(v) }
+          ),
+
+          # ── Network ────────────────────────────────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:           :upload_timeout,
+            env_name:      "RUSTORE_UPLOAD_TIMEOUT",
+            description:   "Seconds to wait for RuStore to answer an AAB/APK upload; RuStore checks the file before answering",
+            default_value: RustorePublish::RustoreClient::DEFAULT_UPLOAD_TIMEOUT,
+            type:          Integer,
+            optional:      true,
+            verify_block:  proc { |v| UI.user_error!("upload_timeout must be a positive number of seconds") unless v > 0 }
+          ),
+
+          # ── Draft metadata (RuStore API v2) ──────────────────────────────
+          FastlaneCore::ConfigItem.new(
+            key:         :developer_contacts,
+            description: "Developer contact info Hash: { email:, website:, vk_community: } — at least one key required",
+            type:        Hash,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("developer_contacts must contain at least one of: email, website, vk_community") if v.empty?
+              allowed = %i[email website vk_community]
+              v.each_key do |k|
+                unless allowed.include?(k.to_sym)
+                  UI.user_error!("developer_contacts: unknown sub-key '#{k}' (accepted: #{allowed.join(', ')})")
+                end
+              end
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :app_name,
+            env_name:    "RUSTORE_APP_NAME",
+            description: "App display name (max 50 chars)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("app_name must not exceed 50 characters") if v.length > 50
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :app_type,
+            env_name:    "RUSTORE_APP_TYPE",
+            description: "App type: GAMES or MAIN",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("app_type must be 'GAMES' or 'MAIN'") unless %w[GAMES MAIN].include?(v)
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :age_legal,
+            env_name:    "RUSTORE_AGE_LEGAL",
+            description: "Age rating: 0+, 6+, 12+, 16+, or 18+",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v|
+              allowed = %w[0+ 6+ 12+ 16+ 18+]
+              UI.user_error!("age_legal must be one of: #{allowed.join(', ')}") unless allowed.include?(v)
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :short_description,
+            env_name:    "RUSTORE_SHORT_DESCRIPTION",
+            description: "Brief description shown in app list (max 80 chars)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("short_description must not exceed 80 characters") if v.length > 80
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :full_description,
+            env_name:    "RUSTORE_FULL_DESCRIPTION",
+            description: "Full description on the app page (max 4000 chars)",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("full_description must not exceed 4000 characters") if v.length > 4000
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :price_value,
+            env_name:    "RUSTORE_PRICE_VALUE",
+            description: "Price in kopecks as a string of digits, e.g. '8799' for 87.99 RUB",
+            type:        String,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("price_value must be a non-empty string of digits") unless v.is_a?(String) && v =~ /\A\d+\z/
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :categories,
+            description: "App categories, e.g. ['news', 'education'] — max 2 elements",
+            type:        Array,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("categories must be an Array") unless v.is_a?(Array)
+              UI.user_error!("categories must not exceed 2 elements") if v.size > 2
+              v.each do |c|
+                unless c.is_a?(String) && !c.strip.empty?
+                  UI.user_error!("categories elements must be non-empty strings")
+                end
+              end
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :seo_tag_ids,
+            description: "RuStore search tag IDs (max 5 integers)",
+            type:        Array,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("seo_tag_ids must be an Array") unless v.is_a?(Array)
+              UI.user_error!("seo_tag_ids must not exceed 5 elements") if v.size > 5
+              v.each do |t|
+                UI.user_error!("seo_tag_ids elements must be integers") unless t.is_a?(Integer)
+              end
+            }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key:         :faq,
+            description: "FAQ items array (max 10), each Hash with question (max 120 chars) and answer (max 500 chars)",
+            type:        Array,
+            optional:    true,
+            verify_block: proc { |v|
+              UI.user_error!("faq must be an Array") unless v.is_a?(Array)
+              UI.user_error!("faq must not exceed 10 elements") if v.size > 10
+              v.each_with_index do |item, idx|
+                UI.user_error!("faq[#{idx}] must be a Hash") unless item.is_a?(Hash)
+                q = item[:question] || item["question"]
+                a = item[:answer]   || item["answer"]
+                UI.user_error!("faq[#{idx}] missing :question") if q.nil?
+                UI.user_error!("faq[#{idx}] missing :answer")   if a.nil?
+                UI.user_error!("faq[#{idx}].question must not exceed 120 characters") if q.length > 120
+                UI.user_error!("faq[#{idx}].answer must not exceed 500 characters")   if a.length > 500
+              end
+            }
+          )
+        ]
+      end
+
+      def self.description
+        "Upload and publish Android apps (APK/AAB) to RuStore app store"
+      end
+
+      def self.details
+        <<~DETAILS
+          Uploads an Android application to the RuStore app store via the RuStore Public API.
+
+          Supports multi-file versions in a single API version:
+            - AAB (Google/GMS build) as the main artifact
+            - APK (Huawei/HMS build) as a secondary artifact (servicesType=HMS)
+
+          The pipeline always finishes immediately after submitting for moderation.
+          Publication behaviour is controlled by publish_type:
+            INSTANTLY — RuStore auto-publishes after moderation passes (default)
+            DELAYED   — scheduled publication via release_date
+            MANUAL    — moderation runs, then publish manually from RuStore Console
+
+          GitLab CI: when GITLAB_CI=true, each step is wrapped in a collapsible
+          section visible in the Pipeline web UI.
+
+          Requires at least one active version already published in RuStore Console.
+        DETAILS
+      end
+
+      def self.authors
+        ["Sergey Gorban"]
+      end
+
+      def self.example_usage
+        [
+          '# Minimal — AAB only, INSTANTLY (default)',
+          'rustore_upload(',
+          '  package_name:     "com.example.app",',
+          '  key_id:           ENV["RUSTORE_KEY_ID"],',
+          '  private_key_path: "rustore_private_key.pem",',
+          '  aab_path:         "app/build/outputs/bundle/release/app-release.aab"',
+          ')',
+          '',
+          '# AAB (GMS) + APK (HMS), staged rollout',
+          'rustore_upload(',
+          '  package_name:       "com.example.app",',
+          '  key_id:             ENV["RUSTORE_KEY_ID"],',
+          '  private_key:        ENV["RUSTORE_PRIVATE_KEY"],',
+          '  aab_path:           "app/build/outputs/bundle/gmsRelease/app-gms-release.aab",',
+          '  hms_apk_path:       "app/build/outputs/apk/hmsRelease/app-hms-release.apk",',
+          '  publish_type:       "INSTANTLY",',
+          '  rollout_percentage: 20',
+          ')',
+          '',
+          '# Scheduled release',
+          'rustore_upload(',
+          '  package_name: "com.example.app",',
+          '  key_id:       ENV["RUSTORE_KEY_ID"],',
+          '  private_key:  ENV["RUSTORE_PRIVATE_KEY"],',
+          '  aab_path:     "...",',
+          '  publish_type: "DELAYED",',
+          '  release_date: "2025-03-01T10:00:00+03:00"',
+          ')'
+        ].join("\n")
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      private
+
+      def self.validate_file!(path, param_name, expected_ext, logger)
+        unless File.exist?(path)
+          logger.error(
+            "File not found for #{param_name}: #{path}",
+            hint: "Check that the build step ran before rustore_upload and the path is correct"
+          )
+        end
+        ext = File.extname(path).downcase
+        unless ext == expected_ext
+          logger.error(
+            "#{param_name} has unexpected extension '#{ext}' (expected '#{expected_ext}'): #{path}",
+            hint: "Make sure you passed the correct file path"
+          )
+        end
+      end
+
+      def self.normalize_developer_contacts(contacts)
+        map = { email: :email, website: :website, vk_community: :vkCommunity }
+        contacts.each_with_object({}) do |(k, v), out|
+          mapped = map[k.to_sym]
+          out[mapped] = v if mapped
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/rustore_publish/certs/russian_trusted_root_ca.crt

@@ -0,0 +1,33 @@
+-----BEGIN CERTIFICATE-----
+MIIFwjCCA6qgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwcDELMAkGA1UEBhMCUlUx
+PzA9BgNVBAoMNlRoZSBNaW5pc3RyeSBvZiBEaWdpdGFsIERldmVsb3BtZW50IGFu
+ZCBDb21tdW5pY2F0aW9uczEgMB4GA1UEAwwXUnVzc2lhbiBUcnVzdGVkIFJvb3Qg
+Q0EwHhcNMjIwMzAxMjEwNDE1WhcNMzIwMjI3MjEwNDE1WjBwMQswCQYDVQQGEwJS
+VTE/MD0GA1UECgw2VGhlIE1pbmlzdHJ5IG9mIERpZ2l0YWwgRGV2ZWxvcG1lbnQg
+YW5kIENvbW11bmljYXRpb25zMSAwHgYDVQQDDBdSdXNzaWFuIFRydXN0ZWQgUm9v
+dCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMfFOZ8pUAL3+r2n
+qqE0Zp52selXsKGFYoG0GM5bwz1bSFtCt+AZQMhkWQheI3poZAToYJu69pHLKS6Q
+XBiwBC1cvzYmUYKMYZC7jE5YhEU2bSL0mX7NaMxMDmH2/NwuOVRj8OImVa5s1F4U
+zn4Kv3PFlDBjjSjXKVY9kmjUBsXQrIHeaqmUIsPIlNWUnimXS0I0abExqkbdrXbX
+YwCOXhOO2pDUx3ckmJlCMUGacUTnylyQW2VsJIyIGA8V0xzdaeUXg0VZ6ZmNUr5Y
+Ber/EAOLPb8NYpsAhJe2mXjMB/J9HNsoFMBFJ0lLOT/+dQvjbdRZoOT8eqJpWnVD
+U+QL/qEZnz57N88OWM3rabJkRNdU/Z7x5SFIM9FrqtN8xewsiBWBI0K6XFuOBOTD
+4V08o4TzJ8+Ccq5XlCUW2L48pZNCYuBDfBh7FxkB7qDgGDiaftEkZZfApRg2E+M9
+G8wkNKTPLDc4wH0FDTijhgxR3Y4PiS1HL2Zhw7bD3CbslmEGgfnnZojNkJtcLeBH
+BLa52/dSwNU4WWLubaYSiAmA9IUMX1/RpfpxOxd4Ykmhz97oFbUaDJFipIggx5sX
+ePAlkTdWnv+RWBxlJwMQ25oEHmRguNYf4Zr/Rxr9cS93Y+mdXIZaBEE0KS2iLRqa
+OiWBki9IMQU4phqPOBAaG7A+eP8PAgMBAAGjZjBkMB0GA1UdDgQWBBTh0YHlzlpf
+BKrS6badZrHF+qwshzAfBgNVHSMEGDAWgBTh0YHlzlpfBKrS6badZrHF+qwshzAS
+BgNVHRMBAf8ECDAGAQH/AgEEMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+AAOCAgEAALIY1wkilt/urfEVM5vKzr6utOeDWCUczmWX/RX4ljpRdgF+5fAIS4vH
+tmXkqpSCOVeWUrJV9QvZn6L227ZwuE15cWi8DCDal3Ue90WgAJJZMfTshN4OI8cq
+W9E4EG9wglbEtMnObHlms8F3CHmrw3k6KmUkWGoa+/ENmcVl68u/cMRl1JbW2bM+
+/3A+SAg2c6iPDlehczKx2oa95QW0SkPPWGuNA/CE8CpyANIhu9XFrj3RQ3EqeRcS
+AQQod1RNuHpfETLU/A2gMmvn/w/sx7TB3W5BPs6rprOA37tutPq9u6FTZOcG1Oqj
+C/B7yTqgI7rbyvox7DEXoX7rIiEqyNNUguTk/u3SZ4VXE2kmxdmSh3TQvybfbnXV
+4JbCZVaqiZraqc7oZMnRoWrXRG3ztbnbes/9qhRGI7PqXqeKJBztxRTEVj8ONs1d
+WN5szTwaPIvhkhO3CO5ErU2rVdUr89wKpNXbBODFKRtgxUT70YpmJ46VVaqdAhOZ
+D9EUUn4YaeLaS8AjSF/h7UkjOibNc4qVDiPP+rkehFWM66PVnP1Msh93tc+taIfC
+EYVMxjh8zNbFuoc7fzvvrFILLe7ifvEIUqSVIC/AzplM/Jxw7buXFeGP1qVCBEHq
+391d/9RAfaZ12zkwFsl+IKwE/OZxW8AHa9i1p4GO0YSNuczzEm4=
+-----END CERTIFICATE-----