discourse_subscription_client 0.1.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b7303b45879b410ec868c784e77786d7c9c4b864e6cf02b840ac9b62ae7c2a29
+  data.tar.gz: f5c231e658b1023df67810547b9a982d0fe54a57e7a65582fd751067a6def9b7
+SHA512:
+  metadata.gz: 31fe492137483fbb3ca7ead97f0ad583aa6b3f7a8a2fd57456776b57f767cd5c31ed897c85b2ed8ec35178996b75176a8f01eb584a304d693482f135e06a44ff
+  data.tar.gz: c6474026b3db22c4ab8de05f8e21d286a0140c4b638e504642a2c501bcd9efee0983539baf023c4f40d2902abbf5c11d90e1c608b8d4fcda8dbf9d3d53b1c352

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Angus McLeod
+
+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,28 @@
+# DiscourseSubscriptionClient
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "discourse_subscription_client"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install discourse_subscription_client
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/support/discourse/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/assets/config/discourse_subscription_client_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/discourse_subscription_client .css

data/app/assets/stylesheets/discourse_subscription_client/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/discourse_subscription_client/admin_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class AdminController < ApplicationController
+    requires_login
+    before_action :ensure_can_manage_subscriptions
+
+    def index
+      respond_to do |format|
+        format.html do
+          render :index
+        end
+        format.json do
+          render_json_dump(
+            authorized_supplier_count: SubscriptionClientSupplier.authorized.count,
+            resource_count: SubscriptionClientResource.count
+          )
+        end
+      end
+    end
+
+    def ensure_can_manage_subscriptions
+      Guardian.new(current_user).ensure_can_manage_subscriptions!
+    end
+
+    def failed_json
+      { failed: "FAILED" }
+    end
+
+    def success_json
+      { success: "OK" }
+    end
+
+    def render_serialized(objects, serializer, opts = {})
+      render_json_dump(serialize_data(objects, serializer, opts))
+    end
+
+    def serialize_data(objects, serializer, opts = {})
+      ActiveModel::ArraySerializer.new(objects.to_a, opts.merge(each_serializer: serializer)).as_json
+    end
+
+    def render_json_dump(json)
+      render json: json, status: 200
+    end
+  end
+end

data/app/controllers/discourse_subscription_client/notices_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class NoticesController < AdminController
+    before_action :find_notice, only: %i[dismiss hide show]
+
+    def index
+      notice_type = params[:notice_type]
+      notice_subject_type = params[:notice_subject_type]
+      page = params[:page].to_i
+
+      visible = ActiveRecord::Type::Boolean.new.cast(params[:visible])
+
+      include_all = if current_user.admin
+                      ActiveRecord::Type::Boolean.new.cast(params[:include_all])
+                    else
+                      false
+                    end
+
+      if notice_type
+        notice_type = if notice_type.is_a?(Array)
+                        notice_type.map { |t| SubscriptionClientNotice.types[t.to_sym] }
+                      else
+                        SubscriptionClientNotice.types[notice_type.to_sym]
+                      end
+      end
+
+      if notice_subject_type
+        notice_subject_type = if notice_subject_type.is_a?(Array)
+                                notice_subject_type.map { |t| SubscriptionClientNotice.notice_subject_types[t.to_sym] }
+                              else
+                                SubscriptionClientNotice.notice_subject_types[notice_subject_type.to_sym]
+                              end
+      end
+
+      notices = SubscriptionClientNotice.list(
+        include_all: include_all,
+        page: page,
+        notice_type: notice_type,
+        notice_subject_type: notice_subject_type,
+        visible: visible
+      )
+
+      render_json_dump(
+        notices: serialize_data(notices, NoticeSerializer),
+        hidden_notice_count: SubscriptionClientNotice.hidden.count
+      )
+    end
+
+    def dismiss
+      if @notice.dismissable? && @notice.dismiss!
+        render json: success_json.merge(dismissed_at: @notice.dismissed_at)
+      else
+        render json: failed_json
+      end
+    end
+
+    def show
+      if @notice.hidden? && @notice.show!
+        render json: success_json
+      else
+        render json: failed_json
+      end
+    end
+
+    def hide
+      if @notice.can_hide? && @notice.hide!
+        render json: success_json.merge(hidden_at: @notice.hidden_at)
+      else
+        render json: failed_json
+      end
+    end
+
+    private
+
+    def find_notice
+      params.require(:notice_id)
+      @notice = SubscriptionClientNotice.find(params[:notice_id])
+      raise Discourse::InvalidParameters, :notice_id unless @notice
+    end
+  end
+end

data/app/controllers/discourse_subscription_client/subscriptions_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class SubscriptionsController < AdminController
+    def index
+      render_serialized(SubscriptionClientSubscription.all, SubscriptionSerializer, root: "subscriptions")
+    end
+
+    def update
+      if DiscourseSubscriptionClient::Subscriptions.update
+        render_serialized(SubscriptionClientSubscription.all, SubscriptionSerializer, root: "subscriptions")
+      else
+        render json: failed_json
+      end
+    end
+  end
+end

data/app/controllers/discourse_subscription_client/suppliers_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module DiscourseSubscriptionClient
+  class SuppliersController < AdminController
+    before_action :ensure_can_manage_suppliers
+    skip_before_action :check_xhr, :preload_json, :verify_authenticity_token, only: %i[authorize authorize_callback]
+    before_action :find_supplier, only: %i[authorize destroy]
+
+    def index
+      render_serialized(SubscriptionClientSupplier.all, SupplierSerializer, root: "suppliers")
+    end
+
+    def authorize
+      request_id = DiscourseSubscriptionClient::Authorization.request_id(@supplier.id)
+      cookies[:user_api_request_id] = request_id
+      redirect_to DiscourseSubscriptionClient::Authorization.url(current_user, @supplier, request_id).to_s,
+                  allow_other_host: true
+    end
+
+    def authorize_callback
+      payload = params[:payload]
+      request_id = cookies[:user_api_request_id]
+      supplier_id = request_id.split("-").first
+
+      data = DiscourseSubscriptionClient::Authorization.process_response(request_id, payload)
+      raise Discourse::InvalidParameters, :payload unless data
+
+      supplier = SubscriptionClientSupplier.find(supplier_id)
+      raise Discourse::InvalidParameters, :supplier_id unless supplier
+
+      supplier.update(
+        api_key: data[:key],
+        user_id: data[:user_id],
+        authorized_at: DateTime.now.iso8601(3)
+      )
+
+      DiscourseSubscriptionClient::Subscriptions.update
+
+      redirect_to "/admin/plugins/subscription-client/subscriptions"
+    end
+
+    def destroy
+      if @supplier.destroy_authorization
+        render json: success_json.merge(supplier: @supplier.reload)
+      else
+        render json: failed_json
+      end
+    end
+
+    protected
+
+    def find_supplier
+      params.require(:supplier_id)
+      @supplier = SubscriptionClientSupplier.find(params[:supplier_id])
+      raise Discourse::InvalidParameters, :supplier_id unless @supplier
+    end
+
+    def ensure_can_manage_suppliers
+      Guardian.new(current_user).ensure_can_manage_suppliers!
+    end
+  end
+end

data/app/jobs/regular/discourse_subscription_client/find_resources.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Jobs
+  class SubscriptionClientFindResources < ::Jobs::Base
+    def execute(_args = {})
+      ::DiscourseSubscriptionClient::Resources.find_all unless Rails.env.test?
+    end
+  end
+end

data/app/jobs/scheduled/discourse_subscription_client/update_notices.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jobs
+  class SubscriptionClientUpdateNotices < ::Jobs::Scheduled
+    every 5.minutes
+
+    def execute(_args = {})
+      ::DiscourseSubscriptionClient::Notices.update
+    end
+  end
+end

data/app/jobs/scheduled/discourse_subscription_client/update_subscriptions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jobs
+  class SubscriptionClientUpdateSubscriptions < ::Jobs::Scheduled
+    every 1.day
+
+    def execute(_args = {})
+      ::DiscourseSubscriptionClient::Subscriptions.update
+    end
+  end
+end

data/app/models/subscription_client_notice.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+class SubscriptionClientNotice < ActiveRecord::Base
+  belongs_to :notice_subject, polymorphic: true
+  delegate :name, to: :subject
+
+  scope :warnings, -> { where(notice_type: SubscriptionClientNotice.types[:warning]) }
+  scope :hidden, -> { where("hidden_at IS NOT NULL AND dismissed_at IS NULL AND expired_at IS NULL") }
+
+  def self.types
+    @types ||= {
+      info: 0,
+      warning: 1,
+      connection_error: 2
+    }
+  end
+
+  def self.notice_subject_types
+    @notice_subject_types ||= {
+      resource: "SubscriptionClientResource",
+      supplier: "SubscriptionClientSupplier"
+    }
+  end
+
+  def self.error_types
+    @error_types ||= [
+      types[:connection_error],
+      types[:warning]
+    ]
+  end
+
+  def supplier
+    if supplier?
+      notice_subject
+    elsif resource?
+      notice_subject.supplier
+    end
+  end
+
+  def resource
+    return unless resource?
+
+    notice_subject
+  end
+
+  def supplier?
+    notice_subject_type === self.class.notice_subject_types[:supplier]
+  end
+
+  def resource?
+    notice_subject_type === self.class.notice_subject_types[:resource] && !plugin_status_resource?
+  end
+
+  def plugin_status_resource?
+    DiscourseSubscriptionClient::Notices::PLUGIN_STATUS_RESOURCE_ID === notice_subject_id
+  end
+
+  def dismiss!
+    return unless dismissable?
+
+    self.dismissed_at = DateTime.now.iso8601(3)
+    save_and_publish
+  end
+
+  def hide!
+    if can_hide?
+      self.hidden_at = DateTime.now.iso8601(3)
+      save_and_publish
+    else
+      false
+    end
+  end
+
+  def show!
+    if hidden?
+      self.hidden_at = nil
+      save_and_publish
+    else
+      false
+    end
+  end
+
+  def expire!
+    if !expired?
+      self.expired_at = DateTime.now.iso8601(3)
+      save_and_publish
+    else
+      false
+    end
+  end
+
+  def save_and_publish
+    if save
+      self.class.publish_notice_count
+    else
+      false
+    end
+  end
+
+  def can_hide?
+    !hidden? && self.class.error_types.include?(notice_type) && (
+      notice_subject_type === self.class.notice_subject_types[:resource]
+    )
+  end
+
+  def expired?
+    expired_at.present?
+  end
+
+  def dismissed?
+    dismissed_at.present?
+  end
+
+  def dismissable?
+    !expired? && !dismissed? && notice_type === self.class.types[:info]
+  end
+
+  def hidden?
+    hidden_at.present?
+  end
+
+  def self.publish_notice_count
+    payload = {
+      visible_notice_count: list(visible: true).count
+    }
+    group_id_key = SiteSetting.subscription_client_allow_moderator_subscription_management ? :staff : :admins
+    MessageBus.publish("/subscription_client_user", payload, group_ids: [Group::AUTO_GROUPS[group_id_key.to_sym]])
+  end
+
+  def self.list(notice_type: nil, notice_subject_type: nil, notice_subject_id: nil, title: nil, include_all: false, visible: false, page: nil, page_limit: 30)
+    query = SubscriptionClientNotice.all
+    query = query.where("hidden_at IS NULL") if visible && !include_all
+    query = query.where("dismissed_at IS NULL") unless include_all
+    query = query.where("expired_at IS NULL") unless include_all
+    query = query.where("notice_subject_type = ?", notice_subject_type.to_s) if notice_subject_type
+    query = query.where("notice_subject_id = ?", notice_subject_id.to_i) if notice_subject_id
+    if notice_type
+      type_query_str = notice_type.is_a?(Array) ? "notice_type IN (?)" : "notice_type = ?"
+      query = query.where(type_query_str, notice_type)
+    end
+    query = query.where("title = ?", title) if title
+    query = query.limit(page_limit).offset(page.to_i * page_limit) unless page.nil?
+    query.order("expired_at DESC, updated_at DESC, dismissed_at DESC, created_at DESC")
+  end
+
+  def self.notify_connection_error(notice_subject_type_key, notice_subject_id)
+    notice_subject_type = notice_subject_types[notice_subject_type_key.to_sym]
+    return false unless notice_subject_type
+
+    notices = list(
+      notice_type: types[:connection_error],
+      notice_subject_type: notice_subject_type,
+      notice_subject_id: notice_subject_id
+    )
+    if notices.any?
+      notice = notices.first
+      notice.updated_at = DateTime.now.iso8601(3)
+      notice.save
+    else
+      opts = {}
+      if notice_subject_type === notice_subject_types[:supplier]
+        supplier = SubscriptionClientSupplier.find(notice_subject_id)
+        opts[:supplier] = supplier.name
+      end
+      create!(
+        title: I18n.t("subscription_client.notices.#{notice_subject_type_key}.connection_error.title", **opts),
+        message: I18n.t("subscription_client.notices.#{notice_subject_type_key}.connection_error.message", **opts),
+        notice_subject_type: notice_subject_type,
+        notice_subject_id: notice_subject_id,
+        notice_type: types[:connection_error],
+        created_at: DateTime.now.iso8601(3),
+        updated_at: DateTime.now.iso8601(3)
+      )
+    end
+  end
+
+  def self.expire_connection_error(notice_subject_type_key, notice_subject_id)
+    expired_count = expire_all(types[:connection_error], notice_subject_types[notice_subject_type_key.to_sym],
+                               notice_subject_id)
+    publish_notice_count if expired_count.to_i.positive?
+  end
+
+  def self.dismiss_all
+    where("
+      notice_type = #{types[:info]} AND
+      expired_at IS NULL AND
+      dismissed_at IS NULL
+    ").update_all("dismissed_at = now()")
+  end
+
+  def self.expire_all(notice_type, notice_subject_type, notice_subject_id)
+    where("
+      notice_type = #{notice_type} AND
+      notice_subject_type = '#{notice_subject_type}' AND
+      notice_subject_id = #{notice_subject_id} AND
+      expired_at IS NULL
+    ").update_all("expired_at = now()")
+  end
+end
+
+# == Schema Information
+#
+# Table name: subscription_client_notices
+#
+#  id                  :bigint           not null, primary key
+#  title               :string           not null
+#  message             :string
+#  notice_type         :integer          not null
+#  notice_subject_type :string
+#  notice_subject_id   :bigint
+#  changed_at          :datetime
+#  retrieved_at        :datetime
+#  dismissed_at        :datetime
+#  expired_at          :datetime
+#  hidden_at           :datetime
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#
+# Indexes
+#
+#  index_subscription_client_notices_on_notice_subject  (notice_subject_type,notice_subject_id)
+#  sc_unique_notices                                    (notice_type,notice_subject_type,notice_subject_id,changed_at) UNIQUE
+#

data/app/models/subscription_client_request.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SubscriptionClientRequest < ActiveRecord::Base
+end

data/app/models/subscription_client_resource.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class SubscriptionClientResource < ActiveRecord::Base
+  belongs_to :supplier, class_name: "SubscriptionClientSupplier"
+  has_many :notices, class_name: "SubscriptionClientNotice", as: :notice_subject, dependent: :destroy
+  has_many :subscriptions, foreign_key: "resource_id", class_name: "SubscriptionClientSubscription", dependent: :destroy
+end
+
+# == Schema Information
+#
+# Table name: subscription_client_resources
+#
+#  id          :bigint           not null, primary key
+#  supplier_id :bigint
+#  name        :string           not null
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  index_subscription_client_resources_on_supplier_id           (supplier_id)
+#  index_subscription_client_resources_on_supplier_id_and_name  (supplier_id,name) UNIQUE
+#
+# Foreign Keys
+#
+#  fk_rails_...  (supplier_id => subscription_client_suppliers.id)
+#

data/app/models/subscription_client_subscription.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class SubscriptionClientSubscription < ActiveRecord::Base
+  validates :product_id, presence: true, uniqueness: { scope: :price_id }
+  validates :price_id, presence: true
+
+  belongs_to :resource, class_name: "SubscriptionClientResource"
+
+  scope :active, -> { where("subscribed = true AND updated_at > ?", SubscriptionClientSubscription.update_period) }
+
+  def active
+    subscribed && updated_at.to_datetime > self.class.update_period.to_datetime
+  end
+
+  def deactivate!
+    update(subscribed: false)
+  end
+
+  def resource_name
+    resource.name
+  end
+
+  def supplier_name
+    resource.supplier.name
+  end
+
+  def self.update_period
+    Time.zone.now - 2.days
+  end
+end
+
+# == Schema Information
+#
+# Table name: subscription_client_subscriptions
+#
+#  id           :bigint           not null, primary key
+#  resource_id  :bigint
+#  product_id   :string           not null
+#  product_name :string
+#  price_id     :string           not null
+#  price_name   :string
+#  subscribed   :boolean          default(FALSE), not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#
+# Indexes
+#
+#  index_subscription_client_subscriptions_on_resource_id  (resource_id)
+#  sc_unique_subscriptions                                 (resource_id,product_id,price_id) UNIQUE
+#
+# Foreign Keys
+#
+#  fk_rails_...  (resource_id => subscription_client_resources.id)
+#