postnhost 0.0.0 → 0.1.0

data/app/models/postnhost/article.rb

@@ -0,0 +1,142 @@
+module Postnhost
+  class Article < ApplicationRecord
+    include ExcerptOptimizable
+    include PrimaryLanguageGuard
+    include Postnhost::Article::ImageUploadable
+
+    STATUSES = %w[published draft scheduled].freeze
+    SORT_OPTIONS = {
+      "created_at_desc" => { column: "created_at", direction: :desc },
+      "created_at_asc" => { column: "created_at", direction: :asc }
+    }.freeze
+
+    DEFAULT_SORT = "created_at_desc"
+
+    has_paper_trail versions: { class_name: "Postnhost::Version" },
+                    only: %i[title title_tag og_title schema_headline schema_article_type meta_description custom_excerpt
+                             use_excerpt_as_meta_description content slug cover_image_alt cover_image],
+                    on: []
+
+    mount_uploader :cover_image, CoverImageUploader
+
+    belongs_to :user, class_name: "Postnhost::User", optional: true
+    belongs_to :language, optional: true, counter_cache: true
+
+    has_many :article_authors, dependent: :destroy
+    has_many :authors, -> { order("postnhost_article_authors.position ASC") }, through: :article_authors, source: :user
+    has_many :article_categories, dependent: :destroy
+    has_many :categories, through: :article_categories
+    has_many :article_variants, dependent: :destroy
+    has_many :article_suggestions, dependent: :destroy
+    has_many :suggested_articles, through: :article_suggestions
+    has_one :article_snapshot, class_name: "Postnhost::Snapshot::Article", dependent: :destroy
+    has_many :article_variant_snapshots, through: :article_variants, source: :article_variant_snapshot
+
+    validates :slug, uniqueness: true,
+                     format: { with: /\A[a-z0-9-]+\z/, message: "can only contain lowercase letters, numbers, and hyphens" },
+                     allow_blank: true
+    validate :slug_not_used_by_page, if: -> { slug.present? }
+
+    before_validation :generate_slug, if: -> { slug.blank? && title.present? }
+    before_validation :normalize_blank_slug
+    after_create :assign_creator_as_default_author
+
+    scope :published, -> { joins(:article_snapshot) }
+    scope :draft, -> { where.missing(:article_snapshot) }
+    scope :scheduled, -> { draft.where.not(scheduled_at: nil) }
+    scope :top_picks, -> { where(top_pick: true) }
+    scope :with_status, lambda { |status|
+      case status
+      when "published" then published
+      when "draft" then draft
+      when "scheduled" then scheduled
+      else all
+      end
+    }
+    scope :sorted_by, lambda { |sort_key|
+      option = SORT_OPTIONS.fetch(sort_key) { SORT_OPTIONS.fetch(DEFAULT_SORT) }
+      order(option[:column] => option[:direction])
+    }
+
+    def self.normalize_status(status)
+      status.to_s.presence_in(STATUSES)
+    end
+
+    def self.normalize_sort(sort)
+      sort.to_s.presence_in(SORT_OPTIONS.keys) || DEFAULT_SORT
+    end
+
+    def published?
+      article_snapshot.present?
+    end
+
+    def unpublished_changes?
+      article_snapshot&.differs_from?(self) || false
+    end
+
+    def schedule_publication!(scheduled_time)
+      with_lock do
+        cancel_scheduled_job
+        job = Postnhost::ScheduledArticleJob.set(wait_until: scheduled_time).perform_later(id)
+        update!(scheduled_at: scheduled_time, scheduled_job_id: job.job_id)
+      end
+    end
+
+    def unschedule_publication!
+      with_lock do
+        cancel_scheduled_job
+        update!(scheduled_at: nil, scheduled_job_id: nil)
+      end
+    end
+
+    def sync_publication_schedule!
+      return unless saved_change_to_scheduled_at?
+
+      if scheduled_at.present?
+        schedule_publication!(scheduled_at)
+      else
+        unschedule_publication!
+      end
+    end
+
+    private
+
+    def normalize_blank_slug
+      self.slug = nil if slug.blank?
+    end
+
+    def generate_slug
+      base_slug = title.downcase.gsub(/[^a-z0-9\s-]/, "").gsub(/\s+/, "-").strip
+      self.slug = base_slug
+      counter = 1
+      while self.class.where(slug: slug).where.not(id: id).exists? || Postnhost::Page.exists?(slug: slug)
+        self.slug = "#{base_slug}-#{counter}"
+        counter += 1
+      end
+    end
+
+    def slug_not_used_by_page
+      return unless Postnhost::Page.exists?(slug: slug)
+
+      errors.add(:slug, "has already been taken")
+    end
+
+    def translation_variants
+      article_variants
+    end
+
+    def cancel_scheduled_job
+      return if scheduled_job_id.blank?
+      return unless defined?(SolidQueue::Job)
+
+      SolidQueue::Job.find_by(active_job_id: scheduled_job_id)&.destroy
+    end
+
+    def assign_creator_as_default_author
+      return if user.blank?
+      return if article_authors.exists?(user_id: user_id)
+
+      article_authors.create!(user:, position: article_authors.maximum(:position).to_i + 1)
+    end
+  end
+end

data/app/models/postnhost/article_author.rb

@@ -0,0 +1,20 @@
+module Postnhost
+  class ArticleAuthor < ApplicationRecord
+    belongs_to :article, touch: true
+    belongs_to :user, class_name: "Postnhost::User"
+
+    before_validation :assign_position, on: :create
+
+    validates :user_id, uniqueness: { scope: :article_id }
+
+    default_scope { order(:position) }
+
+    private
+
+    def assign_position
+      return if position.present? && position.positive?
+
+      self.position = article&.article_authors&.maximum(:position).to_i + 1
+    end
+  end
+end

data/app/models/postnhost/article_category.rb

@@ -0,0 +1,8 @@
+module Postnhost
+  class ArticleCategory < ApplicationRecord
+    belongs_to :article, touch: true
+    belongs_to :category, counter_cache: :articles_count, touch: true
+
+    validates :article_id, uniqueness: { scope: :category_id }
+  end
+end

data/app/models/postnhost/article_suggestion.rb

@@ -0,0 +1,19 @@
+module Postnhost
+  class ArticleSuggestion < ApplicationRecord
+    belongs_to :article, touch: true
+    belongs_to :suggested_article, class_name: "Postnhost::Article"
+
+    validates :suggested_article_id, uniqueness: { scope: :article_id }
+    validate :cannot_suggest_self
+
+    default_scope { order(:position) }
+
+    private
+
+    def cannot_suggest_self
+      return unless article_id == suggested_article_id
+
+      errors.add(:suggested_article, "can't be the same as the article")
+    end
+  end
+end

data/app/models/postnhost/article_variant.rb

@@ -0,0 +1,28 @@
+module Postnhost
+  class ArticleVariant < ApplicationRecord
+    include ExcerptOptimizable
+
+    has_paper_trail versions: { class_name: "Postnhost::Version" },
+                    only: %i[title title_tag og_title schema_headline meta_description custom_excerpt use_excerpt_as_meta_description content],
+                    on: []
+
+    belongs_to :article, counter_cache: true, touch: true
+    belongs_to :language, counter_cache: true
+    has_one :user, through: :article
+    has_one :article_variant_snapshot, class_name: "Postnhost::Snapshot::ArticleVariant", dependent: :destroy
+
+    broadcasts_refreshes_to ->(r) { "article_variants_#{r.article_id}" }
+
+    validates :article_id, uniqueness: { scope: :language_id }
+
+    scope :published, -> { joins(:article_variant_snapshot) }
+
+    def published?
+      article_variant_snapshot.present?
+    end
+
+    def unpublished_changes?
+      article_variant_snapshot&.differs_from?(self) || false
+    end
+  end
+end

data/app/models/postnhost/category.rb

@@ -0,0 +1,34 @@
+module Postnhost
+  class Category < ApplicationRecord
+    include Postnhost::PublicRevisionTouch
+
+    has_many :article_categories, dependent: :destroy
+    has_many :articles, through: :article_categories
+    has_many :category_variants, dependent: :destroy
+    has_many :article_snapshot_categories, class_name: "Postnhost::Snapshot::ArticleCategory",
+                                           dependent: :restrict_with_error
+    has_many :article_snapshots, through: :article_snapshot_categories
+
+    scope :with_category_variants_for_language, lambda { |language|
+      language&.default? ? all : includes(:category_variants)
+    }
+    scope :with_published_articles, -> { joins(:article_snapshot_categories).distinct }
+    scope :alphabetical, -> { order(:name) }
+
+    validates :name, presence: true, uniqueness: true
+    validates :slug, presence: true, uniqueness: true
+
+    after_destroy :touch_articles
+    after_save :touch_articles, if: :saved_change_to_name_or_slug?
+
+    private
+
+    def saved_change_to_name_or_slug?
+      saved_change_to_name? || saved_change_to_slug?
+    end
+
+    def touch_articles
+      articles.find_each(&:touch)
+    end
+  end
+end

data/app/models/postnhost/category_variant.rb

@@ -0,0 +1,24 @@
+module Postnhost
+  class CategoryVariant < ApplicationRecord
+    belongs_to :category, touch: true
+    belongs_to :language
+
+    broadcasts_refreshes_to ->(r) { "category_variants_#{r.category_id}" }
+
+    validates :category_id, uniqueness: { scope: :language_id }
+    validates :name, presence: true, unless: :generating?
+    validate :language_must_not_be_blog_default
+
+    private
+
+    def language_must_not_be_blog_default
+      return if language_id.blank?
+
+      default = Postnhost::Language.blog_default
+      return if default.nil?
+      return unless language_id == default.id
+
+      errors.add(:language_id, "cannot be the site default language; edit the category for that locale")
+    end
+  end
+end

data/app/models/postnhost/language.rb

@@ -0,0 +1,38 @@
+module Postnhost
+  class Language < ApplicationRecord
+    include Postnhost::PublicRevisionTouch
+
+    has_many :articles, dependent: :nullify
+    has_many :article_variants, dependent: :destroy
+    has_many :category_variants, dependent: :destroy
+    has_many :pages, dependent: :nullify
+    has_many :page_variants, dependent: :destroy
+    has_many :article_snapshots, class_name: "Postnhost::Snapshot::Article", dependent: :restrict_with_error
+    has_many :article_variant_snapshots, class_name: "Postnhost::Snapshot::ArticleVariant", dependent: :restrict_with_error
+    has_many :page_snapshots, class_name: "Postnhost::Snapshot::Page", dependent: :restrict_with_error
+    has_many :page_variant_snapshots, class_name: "Postnhost::Snapshot::PageVariant", dependent: :restrict_with_error
+
+    validates :name, presence: true, uniqueness: true
+    validates :html_lang, presence: true, uniqueness: true
+
+    after_destroy :touch_articles_and_variants
+    after_save :touch_articles_and_variants, if: :saved_change_to_name_or_html_lang?
+
+    def self.blog_default
+      find_by(default: true)
+    end
+
+    private
+
+    def saved_change_to_name_or_html_lang?
+      saved_change_to_name? || saved_change_to_html_lang?
+    end
+
+    def touch_articles_and_variants
+      articles.find_each(&:touch)
+      article_variants.find_each(&:touch)
+      pages.find_each(&:touch)
+      page_variants.find_each(&:touch)
+    end
+  end
+end

data/app/models/postnhost/navigation.rb

@@ -0,0 +1,76 @@
+module Postnhost
+  class Navigation < ApplicationRecord
+    self.table_name = "postnhost_navigations"
+
+    belongs_to :setting, class_name: "Postnhost::Setting", touch: true
+    has_many :navigation_items,
+             -> { order(:container_kind, :parent_id, :position, :id) },
+             class_name: "Postnhost::NavigationItem",
+             dependent: :destroy,
+             inverse_of: :navigation
+
+    validates :setting_id, uniqueness: true
+
+    def replace_tree!(tree:, locale_key:)
+      locale = locale_key.to_s
+
+      transaction do
+        old_items = navigation_items.index_by(&:id)
+        navigation_items.delete_all
+        create_container_items!("header", tree.fetch("header", []), locale, old_items)
+        create_container_items!("footer", tree.fetch("footer", []), locale, old_items)
+        setting.touch
+      end
+    end
+
+    private
+
+    def create_container_items!(container_kind, items, locale, old_items)
+      items.each_with_index do |item_payload, position|
+        create_item!(parent: nil, payload: item_payload, context: {
+                       container_kind: container_kind,
+                       locale: locale,
+                       position: position,
+                       old_items: old_items
+                     })
+      end
+    end
+
+    def create_item!(parent:, payload:, context:)
+      container_kind = context[:container_kind]
+      locale = context[:locale]
+      position = context[:position]
+      old_items = context[:old_items]
+      original_item = old_items[payload["id"].to_i]
+      labels = (original_item&.label_translations || {}).deep_stringify_keys
+      new_label = payload["label"].to_s.strip
+      if new_label.blank?
+        labels.delete(locale)
+      else
+        labels[locale] = new_label
+      end
+
+      item = navigation_items.create!(
+        parent:,
+        container_kind:,
+        kind: payload["kind"],
+        target_kind: payload["target_kind"].presence,
+        target_id: payload["target_id"].presence,
+        target_slug: payload["target_slug"].presence,
+        url: payload["url"].presence,
+        nofollow: ActiveModel::Type::Boolean.new.cast(payload["nofollow"]) || false,
+        label_translations: labels,
+        position:
+      )
+
+      payload["children"].to_a.each_with_index do |child_payload, child_position|
+        create_item!(parent: item, payload: child_payload, context: {
+                       container_kind: container_kind,
+                       locale: locale,
+                       position: child_position,
+                       old_items: old_items
+                     })
+      end
+    end
+  end
+end

data/app/models/postnhost/navigation_item.rb

@@ -0,0 +1,100 @@
+module Postnhost
+  class NavigationItem < ApplicationRecord
+    self.table_name = "postnhost_navigation_items"
+
+    enum :container_kind, {
+      header: 0,
+      footer: 1
+    }, validate: true
+
+    enum :kind, {
+      link: 0,
+      dropdown: 1,
+      column: 2
+    }, validate: true
+
+    enum :target_kind, {
+      article: 0,
+      page: 1,
+      category: 2,
+      static_page: 3,
+      external: 4,
+      text: 5
+    }, validate: { allow_nil: true }
+
+    belongs_to :navigation, class_name: "Postnhost::Navigation", inverse_of: :navigation_items
+    belongs_to :parent,
+               class_name: "Postnhost::NavigationItem",
+               optional: true,
+               inverse_of: :children
+    has_many :children,
+             -> { order(:position, :id) },
+             class_name: "Postnhost::NavigationItem",
+             foreign_key: :parent_id,
+             dependent: :destroy,
+             inverse_of: :parent
+
+    scope :roots, -> { where(parent_id: nil) }
+    scope :with_children, -> { includes(:children) }
+
+    validates :position, numericality: { greater_than_or_equal_to: 0 }
+
+    validate :validate_structure
+    validate :validate_target_requirements
+
+    def label_for(locale_key:, default_locale_key:)
+      labels = label_translations.deep_stringify_keys
+      labels[locale_key.to_s].presence || labels[default_locale_key.to_s].presence
+    end
+
+    private
+
+    def validate_structure
+      errors.add(:parent_id, "must belong to same navigation") if parent_id.present? && parent&.navigation_id != navigation_id
+
+      if parent_id.blank?
+        errors.add(:kind, "must be link or dropdown for header root") if header? && !link? && !dropdown?
+        errors.add(:kind, "must be column for footer root") if footer? && !column?
+        return
+      end
+
+      return if parent.blank?
+
+      if parent.dropdown? && !link?
+        errors.add(:kind, "must be link inside dropdown")
+      elsif parent.column? && !link?
+        errors.add(:kind, "must be link inside column")
+      elsif parent.link?
+        errors.add(:parent_id, "link items cannot have children")
+      end
+    end
+
+    def validate_target_requirements
+      if dropdown? || column?
+        errors.add(:target_kind, "must be blank for grouping items") if target_kind.present?
+        errors.add(:target_id, "must be blank for grouping items") if target_id.present?
+        errors.add(:target_slug, "must be blank for grouping items") if target_slug.present?
+        errors.add(:url, "must be blank for grouping items") if url.present?
+        return
+      end
+
+      if target_kind.blank?
+        errors.add(:target_kind, "is required for link items")
+        return
+      end
+
+      case target_kind
+      when "text"
+        errors.add(:target_id, "must be blank for text links") if target_id.present?
+        errors.add(:target_slug, "must be blank for text links") if target_slug.present?
+        errors.add(:url, "must be blank for text links") if url.present?
+      when "external"
+        errors.add(:url, "is required") if url.blank?
+      when "static_page"
+        errors.add(:target_slug, "is required") if target_slug.blank?
+      else
+        errors.add(:target_id, "is required") if target_id.blank?
+      end
+    end
+  end
+end

data/app/models/postnhost/page.rb

@@ -0,0 +1,63 @@
+module Postnhost
+  class Page < ApplicationRecord
+    include PrimaryLanguageGuard
+    include Postnhost::Page::ImageUploadable
+
+    has_paper_trail versions: { class_name: "Postnhost::Version" },
+                    only: %i[title title_tag og_title meta_description content slug], on: []
+
+    belongs_to :user, class_name: "Postnhost::User"
+    belongs_to :language, optional: true
+
+    has_many :page_variants, dependent: :destroy
+    has_one :page_snapshot, class_name: "Postnhost::Snapshot::Page", dependent: :destroy
+    has_many :page_variant_snapshots, through: :page_variants, source: :page_variant_snapshot
+
+    validates :slug, uniqueness: true,
+                     format: { with: /\A[a-z0-9-]+\z/, message: "can only contain lowercase letters, numbers, and hyphens" },
+                     allow_blank: true
+    validate :slug_not_used_by_article, if: -> { slug.present? }
+
+    before_validation :generate_slug, if: -> { slug.blank? && title.present? }
+    before_validation :normalize_blank_slug
+    scope :published, -> { joins(:page_snapshot) }
+
+    def published?
+      page_snapshot.present?
+    end
+
+    def unpublished_changes?
+      page_snapshot&.differs_from?(self) || false
+    end
+
+    def title_for_meta
+      title_tag.presence || title
+    end
+
+    private
+
+    def normalize_blank_slug
+      self.slug = nil if slug.blank?
+    end
+
+    def generate_slug
+      base_slug = title.downcase.gsub(/[^a-z0-9\s-]/, "").gsub(/\s+/, "-").strip
+      self.slug = base_slug
+      counter = 1
+      while self.class.where(slug: slug).where.not(id: id).exists? || Postnhost::Article.exists?(slug: slug)
+        self.slug = "#{base_slug}-#{counter}"
+        counter += 1
+      end
+    end
+
+    def slug_not_used_by_article
+      return unless Postnhost::Article.exists?(slug: slug)
+
+      errors.add(:slug, "has already been taken")
+    end
+
+    def translation_variants
+      page_variants
+    end
+  end
+end

data/app/models/postnhost/page_variant.rb

@@ -0,0 +1,26 @@
+module Postnhost
+  class PageVariant < ApplicationRecord
+    has_paper_trail versions: { class_name: "Postnhost::Version" },
+                    only: %i[title title_tag og_title meta_description content],
+                    on: []
+
+    belongs_to :page, counter_cache: true, touch: true
+    belongs_to :language
+    has_one :user, through: :page
+    has_one :page_variant_snapshot, class_name: "Postnhost::Snapshot::PageVariant", dependent: :destroy
+
+    broadcasts_refreshes_to ->(r) { "page_variants_#{r.page_id}" }
+
+    validates :page_id, uniqueness: { scope: :language_id }
+
+    scope :published, -> { joins(:page_variant_snapshot) }
+
+    def published?
+      page_variant_snapshot.present?
+    end
+
+    def unpublished_changes?
+      page_variant_snapshot&.differs_from?(self) || false
+    end
+  end
+end

data/app/models/postnhost/public_site_revision.rb

@@ -0,0 +1,24 @@
+module Postnhost
+  class PublicSiteRevision < ApplicationRecord
+    SINGLETON_ID = 1
+
+    def self.current
+      find_or_create_by!(id: SINGLETON_ID)
+    end
+
+    def self.locked
+      current
+      lock.find(SINGLETON_ID)
+    end
+
+    def self.bump!
+      transaction do
+        locked.bump!
+      end
+    end
+
+    def bump!
+      update!(revision: revision + 1)
+    end
+  end
+end

data/app/models/postnhost/published_cover_image.rb

@@ -0,0 +1,28 @@
+module Postnhost
+  class PublishedCoverImage
+    attr_reader :identifier
+
+    def initialize(article_id:, identifier:)
+      @article_id = article_id
+      @identifier = identifier.presence
+    end
+
+    delegate :present?, to: :identifier
+
+    delegate :url, to: :uploader
+
+    delegate :thumbnail, to: :uploader
+
+    delegate :medium, to: :uploader
+
+    private
+
+    attr_reader :article_id
+
+    def uploader
+      @uploader ||= CoverImageUploader.new(Article.new(id: article_id), :cover_image).tap do |mounted_uploader|
+        mounted_uploader.retrieve_from_store!(identifier) if identifier.present?
+      end
+    end
+  end
+end