discourse_subscription_client 0.1.0.pre1

data/app/models/subscription_client_supplier.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class SubscriptionClientSupplier < ActiveRecord::Base
+  has_many :resources, foreign_key: "supplier_id", class_name: "SubscriptionClientResource", dependent: :destroy
+  has_many :subscriptions, through: :resources
+  has_many :notices, class_name: "SubscriptionClientNotice", as: :notice_subject, dependent: :destroy
+
+  belongs_to :user
+
+  scope :authorized, -> { where("api_key IS NOT NULL") }
+
+  def destroy_authorization
+    if DiscourseSubscriptionClient::Authorization.revoke(self)
+      update(api_key: nil, user_id: nil, authorized_at: nil)
+      deactivate_all_subscriptions!
+      true
+    else
+      false
+    end
+  end
+
+  def authorized?
+    api_key.present?
+  end
+
+  def deactivate_all_subscriptions!
+    subscriptions.update_all(subscribed: false)
+  end
+
+  def self.publish_authorized_supplier_count
+    payload = { authorized_supplier_count: authorized.count }
+    group_id_key = SiteSetting.subscription_client_allow_moderator_subscription_management ? :staff : :admins
+    MessageBus.publish("/subscription_client", payload, group_ids: [Group::AUTO_GROUPS[group_id_key.to_sym]])
+  end
+end
+
+# == Schema Information
+#
+# Table name: subscription_client_suppliers
+#
+#  id            :bigint           not null, primary key
+#  name          :string
+#  url           :string           not null
+#  api_key       :string
+#  user_id       :bigint
+#  authorized_at :datetime
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+# Indexes
+#
+#  index_subscription_client_suppliers_on_url      (url) UNIQUE
+#  index_subscription_client_suppliers_on_user_id  (user_id)
+#

data/app/serializers/discourse_subscription_client/notice_serializer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class NoticeSerializer < ApplicationSerializer
+    attributes :id,
+               :title,
+               :message,
+               :notice_type,
+               :notice_subject_type,
+               :notice_subject_id,
+               :plugin_status_resource,
+               :created_at,
+               :expired_at,
+               :updated_at,
+               :dismissed_at,
+               :retrieved_at,
+               :hidden_at,
+               :dismissable,
+               :can_hide
+
+    has_one :supplier, serializer: DiscourseSubscriptionClient::SupplierSerializer, embed: :objects
+    has_one :resource, serializer: DiscourseSubscriptionClient::ResourceSerializer, embed: :objects
+
+    def include_supplier?
+      object.supplier.present?
+    end
+
+    def include_resource?
+      object.resource.present?
+    end
+
+    def plugin_status_resource
+      object.plugin_status_resource?
+    end
+
+    def dismissable
+      object.dismissable?
+    end
+
+    def can_hide
+      object.can_hide?
+    end
+
+    def notice_type
+      SubscriptionClientNotice.types.key(object.notice_type)
+    end
+
+    def messsage
+      PrettyText.cook(object.message)
+    end
+  end
+end

data/app/serializers/discourse_subscription_client/resource_serializer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class ResourceSerializer < ApplicationSerializer
+    attributes :id,
+               :name
+  end
+end

data/app/serializers/discourse_subscription_client/subscription_serializer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class SubscriptionSerializer < ApplicationSerializer
+    attributes :supplier_name,
+               :resource_name,
+               :product_name,
+               :price_name,
+               :active,
+               :updated_at
+  end
+end

data/app/serializers/discourse_subscription_client/supplier_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class SupplierSerializer < ApplicationSerializer
+    attributes :id,
+               :name,
+               :authorized,
+               :authorized_at
+
+    has_one :user, serializer: BasicUserSerializer, embed: :objects
+
+    def authorized
+      object.api_key.present? && object.authorized_at.present?
+    end
+  end
+end

data/config/locales/server.en.yml

@@ -0,0 +1,40 @@
+en:
+  subscription_client:
+    custom_title: "Subscription"
+
+    notices:
+      connection_error: "Failed to connect to %{url}"
+      compatibility_issue:
+        title: The %{resource} is incompatibile with the latest version of Discourse.
+        message: Please check the %{resource} status before updating Discourse.
+      resource:
+        connection_error:
+          title: Unable to connect to the plugin status server
+          message: Please check your plugins' compatibility with the latest version of Discourse before updating.
+      supplier:
+        connection_error:
+          title: Unable to connect to %{supplier}
+          message: Any subscriptions you have with %{supplier} have been deactivated.
+
+    subscriptions:
+      error:
+        supplier_connection: Failed to connect to %{supplier} (%{supplier_url})
+        invalid_response: Invalid response from %{supplier} (%{supplier_url})
+      info:
+        no_suppliers: "Update was not run as there are no authorized suppliers."
+        no_subscriptions: "There are no active subscriptions for %{supplier} (%{supplier_url})."
+        no_resource: "There is no %{resource} resource associated with %{supplier} (%{supplier_url})."
+        deactivated_subscription: "Deactivated subscription for %{resource_name} (%{resource_id})."
+        updated_subscription: "Updated active subscription for %{resource_name} (%{resource_id}). Product: (%{product_id}), Price: %{price}, Supplier: %{supplier}"
+        created_subscription: "Created active subscription for resource: %{resource-id}. Product: %{product_id}; Price: %{price}, Supplier: %{supplier}"
+        failed_to_create_subscription: "Failed to create subscription for %{resource_name} (%{resource-id}). product: %{product_id}; price: %{price}. From %{supplier} (%{supplier_url})"
+
+  site_settings:
+    subscription_client_enabled: "Enable the subscription client."
+    subscription_client_verbose_logs: "Enable verbose logs for the subscription client."
+    subscription_client_warning_notices_on_dashboard: "Show warning notices about subscriptions on the admin dashboard."
+    subscription_client_allow_moderator_subscription_management: "Allow moderators to manage subscriptions."
+    subscription_client_allow_moderator_supplier_management: "Allow moderators to manage subscription suppliers."
+    subscription_client_request_plugin_statuses: Request the status of plugins from discourse.pluginmanager.org.
+    errors:
+      allow_moderator_subscription_management_not_enabled: "Allow moderator subscription management must be enabled."

data/config/routes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+DiscourseSubscriptionClient::Engine.routes.draw do
+  get "" => "admin#index"
+  get ".json" => "admin#index"
+
+  get "suppliers" => "suppliers#index"
+  get "suppliers/authorize" => "suppliers#authorize"
+  get "suppliers/authorize/callback" => "suppliers#authorize_callback"
+  delete "suppliers/authorize" => "suppliers#destroy"
+
+  get "subscriptions" => "subscriptions#index"
+  post "subscriptions" => "subscriptions#update"
+
+  get "notices" => "notices#index"
+  put "notices/:notice_id/dismiss" => "notices#dismiss"
+  put "notices/:notice_id/hide" => "notices#hide"
+  put "notices/:notice_id/show" => "notices#show"
+end

data/config/settings.yml

@@ -0,0 +1,16 @@
+plugins:
+  subscription_client_enabled:
+    default: true
+    client: true
+  subscription_client_verbose_logs:
+    default: false
+  subscription_client_warning_notices_on_dashboard:
+    default: true
+  subscription_client_allow_moderator_subscription_management:
+    default: false
+  subscription_client_allow_moderator_supplier_management:
+    default: false
+    client: true
+  subscription_client_request_plugin_statuses:
+    default: false
+    hidden: true

data/db/migrate/20220318160955_create_subscription_client_suppliers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateSubscriptionClientSuppliers < ActiveRecord::Migration[6.1]
+  def change
+    create_table :subscription_client_suppliers do |t|
+      t.string :name
+      t.string :url, null: false
+      t.string :api_key
+      t.references :user
+      t.datetime :authorized_at
+
+      t.timestamps
+    end
+
+    add_index :subscription_client_suppliers, [:url], unique: true
+  end
+end

data/db/migrate/20220318181029_create_subscription_client_resources.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateSubscriptionClientResources < ActiveRecord::Migration[6.1]
+  def change
+    create_table :subscription_client_resources do |t|
+      t.references :supplier, foreign_key: { to_table: :subscription_client_suppliers }
+      t.string :name, null: false
+
+      t.timestamps
+    end
+
+    add_index :subscription_client_resources, %i[supplier_id name], unique: true
+  end
+end

data/db/migrate/20220318181054_create_subscription_client_notices.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class CreateSubscriptionClientNotices < ActiveRecord::Migration[6.1]
+  def change
+    create_table :subscription_client_notices do |t|
+      t.string :title, null: false
+      t.string :message
+      t.integer :notice_type, null: false
+      t.references :notice_subject, polymorphic: true
+      t.datetime :changed_at
+      t.datetime :retrieved_at
+      t.datetime :dismissed_at
+      t.datetime :expired_at
+      t.datetime :hidden_at
+
+      t.timestamps null: false
+    end
+
+    add_index :subscription_client_notices, %i[notice_type notice_subject_type notice_subject_id changed_at],
+              unique: true, name: "sc_unique_notices"
+  end
+end

data/db/migrate/20220318181140_create_subscription_client_subscriptions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateSubscriptionClientSubscriptions < ActiveRecord::Migration[6.1]
+  def change
+    create_table :subscription_client_subscriptions do |t|
+      t.references :resource, foreign_key: { to_table: :subscription_client_resources }
+      t.string :product_id, null: false
+      t.string :product_name
+      t.string :price_id, null: false
+      t.string :price_name
+      t.boolean :subscribed, default: false, null: false
+
+      t.timestamps null: false
+    end
+
+    add_index :subscription_client_subscriptions, %i[resource_id product_id price_id], unique: true,
+                                                                                       name: "sc_unique_subscriptions"
+  end
+end

data/db/migrate/20230220130259_create_subscription_client_requests.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateSubscriptionClientRequests < ActiveRecord::Migration[7.0]
+  def change
+    create_table :subscription_client_requests do |t|
+      t.bigint :request_id
+      t.string :request_type
+      t.datetime :expired_at
+      t.string :message
+      t.integer :count
+      t.json :response
+
+      t.timestamps
+    end
+  end
+end

data/lib/discourse_subscription_client/authorization.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class Authorization
+    SCOPE ||= "discourse-subscription-server:user_subscription"
+
+    def self.request_id(supplier_id)
+      "#{supplier_id}-#{SecureRandom.hex(32)}"
+    end
+
+    def self.url(user, supplier, request_id)
+      keys = generate_keys(user.id, request_id)
+      params = {
+        public_key: keys.public_key,
+        nonce: keys.nonce,
+        client_id: client_id(user.id),
+        auth_redirect: "#{Discourse.base_url}/admin/plugins/subscription-client/suppliers/authorize/callback",
+        application_name: SiteSetting.title,
+        scopes: SCOPE
+      }
+      uri = URI.parse("#{supplier.url}/user-api-key/new")
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    end
+
+    def self.process_response(request_id, payload)
+      data = decrypt_payload(request_id, payload)
+      return false unless data.is_a?(Hash) && data[:key] && data[:user_id]
+
+      data
+    end
+
+    def self.generate_keys(user_id, request_id)
+      rsa = OpenSSL::PKey::RSA.generate(2048)
+      nonce = SecureRandom.hex(32)
+      set_keys(request_id, user_id, rsa, nonce)
+      OpenStruct.new(nonce: nonce, public_key: rsa.public_key)
+    end
+
+    def self.decrypt_payload(request_id, payload)
+      keys = get_keys(request_id)
+
+      return false unless keys.present? && keys.pem
+
+      delete_keys(request_id)
+
+      rsa = OpenSSL::PKey::RSA.new(keys.pem)
+      decrypted_payload = rsa.private_decrypt(Base64.decode64(payload))
+
+      return false unless decrypted_payload.present?
+
+      begin
+        data = JSON.parse(decrypted_payload).symbolize_keys
+      rescue JSON::ParserError
+        return false
+      end
+
+      return false unless data[:nonce] == keys.nonce
+
+      data[:user_id] = keys.user_id
+      data
+    end
+
+    def self.get_keys(request_id)
+      raw = PluginStore.get(DiscourseSubscriptionClient::PLUGIN_NAME, "#{keys_db_key}_#{request_id}")
+      OpenStruct.new(
+        user_id: raw && raw["user_id"],
+        pem: raw && raw["pem"],
+        nonce: raw && raw["nonce"]
+      )
+    end
+
+    def self.revoke(supplier)
+      url = "#{supplier.url}/user-api-key/revoke"
+      request = DiscourseSubscriptionClient::Request.new(:supplier, supplier.id)
+      headers = { "User-Api-Key" => supplier.api_key }
+      result = request.perform(url, headers: headers, body: nil, opts: { method: "POST" })
+      result && result[:success] == "OK"
+    end
+
+    def self.client_id(user_id)
+      "#{Discourse.current_hostname}:#{user_id}:#{SecureRandom.hex(8)}"
+    end
+
+    def self.keys_db_key
+      "keys"
+    end
+
+    def self.set_keys(request_id, user_id, rsa, nonce)
+      PluginStore.set(DiscourseSubscriptionClient::PLUGIN_NAME, "#{keys_db_key}_#{request_id}",
+                      user_id: user_id,
+                      pem: rsa.export,
+                      nonce: nonce)
+    end
+
+    def self.delete_keys(request_id)
+      PluginStore.remove(DiscourseSubscriptionClient::PLUGIN_NAME, "#{keys_db_key}_#{request_id}")
+    end
+  end
+end

data/lib/discourse_subscription_client/engine.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  PLUGIN_NAME ||= "discourse_subscription_client"
+
+  class Engine < ::Rails::Engine
+    engine_name PLUGIN_NAME
+    isolate_namespace DiscourseSubscriptionClient
+
+    config.before_initialize do
+      config.i18n.load_path += Dir["#{config.root}/config/locales/**/*.yml"]
+    end
+
+    config.after_initialize do
+      gem_root = File.expand_path("../..", __dir__)
+
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths << "#{gem_root}/db/migrate"
+
+      %w[
+        ./request
+        ./authorization
+        ./resources
+        ./notices
+        ./subscriptions
+        ./subscriptions/result
+        ../../app/models/subscription_client_notice
+        ../../app/models/subscription_client_resource
+        ../../app/models/subscription_client_subscription
+        ../../app/models/subscription_client_supplier
+        ../../app/controllers/discourse_subscription_client/admin_controller
+        ../../app/controllers/discourse_subscription_client/subscriptions_controller
+        ../../app/controllers/discourse_subscription_client/suppliers_controller
+        ../../app/controllers/discourse_subscription_client/notices_controller
+        ../../app/serializers/discourse_subscription_client/supplier_serializer
+        ../../app/serializers/discourse_subscription_client/resource_serializer
+        ../../app/serializers/discourse_subscription_client/notice_serializer
+        ../../app/serializers/discourse_subscription_client/subscription_serializer
+        ../../app/jobs/regular/discourse_subscription_client/find_resources
+        ../../app/jobs/scheduled/discourse_subscription_client/update_subscriptions
+        ../../app/jobs/scheduled/discourse_subscription_client/update_notices
+        ../../extensions/discourse_subscription_client/current_user
+        ../../extensions/discourse_subscription_client/guardian
+      ].each do |path|
+        require_relative path
+      end
+
+      Jobs.enqueue(:subscription_client_find_resources) if DiscourseSubscriptionClient.database_exists? && !Rails.env.test?
+
+      Rails.application.routes.append do
+        mount DiscourseSubscriptionClient::Engine, at: "/admin/plugins/subscription-client"
+      end
+
+      SiteSetting.load_settings("#{gem_root}/config/settings.yml", plugin: PLUGIN_NAME)
+
+      Guardian.prepend DiscourseSubscriptionClient::GuardianExtension
+      CurrentUserSerializer.prepend DiscourseSubscriptionClient::CurrentUserSerializerExtension
+
+      User.has_many(:subscription_client_suppliers)
+
+      AdminDashboardData.add_scheduled_problem_check(:subscription_client) do
+        return unless SiteSetting.subscription_client_warning_notices_on_dashboard
+
+        notices = SubscriptionClientNotice.list(
+          notice_type: SubscriptionClientNotice.error_types,
+          visible: true
+        )
+        notices.map do |notice|
+          AdminDashboardData::Problem.new(
+            "#{notice.title}: #{notice.message}",
+            priority: "high",
+            identifier: "subscription_client_notice_#{notice.id}"
+          )
+        end
+      end
+
+      DiscourseEvent.trigger(:subscription_client_ready)
+    end
+  end
+
+  class << self
+    def root
+      Rails.root
+    end
+
+    def plugin_status_server_url
+      "https://discourse.pluginmanager.org"
+    end
+
+    def database_exists?
+      ActiveRecord::Base.connection
+    rescue ActiveRecord::NoDatabaseError
+      false
+    else
+      true
+    end
+  end
+end

data/lib/discourse_subscription_client/notices.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class Notices
+    PLUGIN_STATUS_RESOURCE_ID = -1
+    PLUGIN_STATUSES_TO_WARN = %w[incompatible tests_failing].freeze
+
+    def initialize
+      @suppliers = SubscriptionClientSupplier.authorized
+    end
+
+    def self.update(subscription: true, plugin: true)
+      new.update(subscription: subscription, plugin: plugin)
+    end
+
+    def update(subscription: true, plugin: true)
+      return if !SiteSetting.subscription_client_enabled || @suppliers.blank?
+
+      if subscription
+        @suppliers.each do |supplier|
+          update_subscription_messages(supplier)
+        end
+      end
+
+      update_plugin_statuses if plugin && SiteSetting.subscription_client_request_plugin_statuses
+
+      SubscriptionClientNotice.publish_notice_count
+    end
+
+    def update_subscription_messages(supplier)
+      url = "#{supplier.url}/subscription-server/messages"
+      request = DiscourseSubscriptionClient::Request.new(:supplier, supplier.id)
+      messages = request.perform(url)
+
+      return unless messages.present?
+
+      messages[:messages].each do |message|
+        notice_type = SubscriptionClientNotice.types[message[:type].to_sym]
+
+        if message[:resource] && (resource = SubscriptionClientResource.find_by(name: message[:resource],
+                                                                                supplier_id: supplier.id))
+          notice_subject_type = SubscriptionClientNotice.notice_subject_types[:resource]
+          notice_subject_id = resource.id
+        else
+          notice_subject_type = SubscriptionClientNotice.notice_subject_types[:supplier]
+          notice_subject_id = supplier.id
+        end
+
+        changed_at = message[:created_at]
+        notice = SubscriptionClientNotice.find_by(
+          notice_type: notice_type,
+          notice_subject_type: notice_subject_type,
+          notice_subject_id: notice_subject_id,
+          changed_at: changed_at
+        )
+
+        if notice
+          if message[:expired_at]
+            notice.expired_at = message[:expired_at]
+            notice.save
+          end
+        else
+          SubscriptionClientNotice.create!(
+            title: message[:title],
+            message: message[:message],
+            notice_type: notice_type,
+            notice_subject_type: notice_subject_type,
+            notice_subject_id: notice_subject_id,
+            changed_at: changed_at,
+            expired_at: message[:expired_at],
+            retrieved_at: DateTime.now.iso8601(3)
+          )
+        end
+      end
+    end
+
+    def update_plugin_statuses
+      request = DiscourseSubscriptionClient::Request.new(:resource, PLUGIN_STATUS_RESOURCE_ID)
+      response = request.perform(DiscourseSubscriptionClient.plugin_status_server_url)
+      return false unless response && response[:statuses].present?
+
+      statuses = response[:statuses]
+
+      return unless statuses.present?
+
+      warnings = statuses.select { |status| PLUGIN_STATUSES_TO_WARN.include?(status[:status]) }
+      expiries = statuses - warnings
+
+      create_plugin_warning_notices(warnings) if warnings.any?
+      expire_plugin_warning_notices(expiries) if expiries.any?
+    end
+
+    def expire_plugin_warning_notices(expiries)
+      plugin_names = expiries.map { |expiry| expiry[:name] }
+      sql = <<~SQL
+        UPDATE subscription_client_notices AS notices
+        SET expired_at = now()
+        FROM subscription_client_resources AS resources
+        WHERE resources.name IN (:plugin_names)
+        AND notices.notice_subject_id = resources.id
+        AND notices.notice_subject_type = 'SubscriptionClientResource'
+        AND notices.notice_type = :notice_type
+      SQL
+
+      ActiveRecord::Base.connection.execute(
+        ActiveRecord::Base.sanitize_sql(
+          [
+            sql, {
+              notice_type: SubscriptionClientNotice.types[:warning],
+              plugin_names: plugin_names
+            }
+          ]
+        )
+      )
+    end
+
+    def create_plugin_warning_notices(warnings)
+      plugin_names = warnings.map { |warning| warning[:name] }
+      resource_ids = SubscriptionClientResource.where(name: plugin_names)
+                                               .each_with_object({}) do |resource, result|
+        result[resource.name] =
+          resource.id
+      end
+
+      warnings.each do |warning|
+        notice_type = SubscriptionClientNotice.types[:warning]
+        notice_subject_type = SubscriptionClientNotice.notice_subject_types[:resource]
+        notice_subject_id = resource_ids[warning[:name]]
+        changed_at = warning[:status_changed_at]
+
+        notice = SubscriptionClientNotice.find_by(
+          notice_type: notice_type,
+          notice_subject_type: notice_subject_type,
+          notice_subject_id: notice_subject_id,
+          changed_at: changed_at
+        )
+
+        if notice
+          notice.touch
+        else
+          SubscriptionClientNotice.create!(
+            title: I18n.t("subscription_client.notices.compatibility_issue.title", resource: warning[:name]),
+            message: I18n.t("subscription_client.notices.compatibility_issue.message", resource: warning[:name]),
+            notice_type: notice_type,
+            notice_subject_type: notice_subject_type,
+            notice_subject_id: notice_subject_id,
+            changed_at: changed_at,
+            retrieved_at: DateTime.now.iso8601(3)
+          )
+        end
+      end
+    end
+  end
+end