postnhost 0.0.0 → 0.1.0

data/app/controllers/concerns/postnhost/public_footer_data.rb

@@ -0,0 +1,103 @@
+module Postnhost
+  module PublicFooterData
+    extend ActiveSupport::Concern
+
+    private
+
+    def set_footer_data
+      @setting = current_setting
+      @use_auto_header_navigation = @setting.use_auto_header_navigation
+      @use_auto_footer_navigation = @setting.use_auto_footer_navigation
+      initialize_navigation_data
+
+      set_auto_navigation_data if @use_auto_header_navigation || @use_auto_footer_navigation
+      set_custom_navigation_data unless @use_auto_header_navigation && @use_auto_footer_navigation
+    end
+
+    def initialize_navigation_data
+      @sidebar_categories = []
+      @header_categories = []
+      @footer_categories = []
+      @footer_published_pages = []
+      @footer_static_pages = []
+      @header_navigation_items = []
+      @footer_navigation_columns = []
+    end
+
+    def set_auto_navigation_data
+      data = Rails.cache.fetch(public_navigation_cache_key("auto")) do
+        {
+          categories: auto_navigation_categories.to_a,
+          published_pages: published_footer_pages.to_a
+        }
+      end
+
+      if @use_auto_header_navigation
+        @sidebar_categories = data.fetch(:categories)
+        @header_categories = data.fetch(:categories)
+      end
+
+      return unless @use_auto_footer_navigation
+
+      @footer_categories = data.fetch(:categories)
+      @footer_published_pages = data.fetch(:published_pages)
+      @footer_static_pages = static_footer_pages - @footer_published_pages.map(&:slug)
+    end
+
+    def set_custom_navigation_data
+      items = Rails.cache.fetch(public_navigation_cache_key("custom")) do
+        @setting.current_navigation.navigation_items.roots.with_children.to_a
+      end
+      @default_language = public_request_context.default_language
+      targets = Postnhost::PublicNavigationTargets.call(
+        items: items.flat_map { |item| [item, *item.children] },
+        language: @current_language
+      ).value
+      @navigation_target_cache = targets.records
+      @navigation_variant_cache = targets.variants
+
+      @header_navigation_items = items.select { |item| item.container_kind == "header" && item.parent_id.nil? }.sort_by(&:position) unless @use_auto_header_navigation
+      return if @use_auto_footer_navigation
+
+      @footer_navigation_columns = items.select { |item| item.container_kind == "footer" && item.parent_id.nil? }.sort_by(&:position)
+    end
+
+    def public_navigation_cache_key(kind)
+      ["postnhost", "public_navigation", kind, public_site_revision, @current_language]
+    end
+
+    def auto_navigation_categories
+      Postnhost::Category.with_category_variants_for_language(@current_language)
+                         .with_published_articles
+                         .alphabetical
+    end
+
+    def static_footer_pages
+      static_page_template_paths
+        .map { |template_path| File.basename(template_path, ".html.erb") }
+        .uniq
+        .sort
+    end
+
+    def published_footer_pages
+      return default_footer_pages if @current_language.default?
+
+      localized_footer_pages
+    end
+
+    def default_footer_pages
+      Postnhost::Snapshot::Page.footer_links
+    end
+
+    def localized_footer_pages
+      Postnhost::Snapshot::PageVariant.footer_links_for(@current_language)
+    end
+
+    def static_page_template_paths
+      [
+        Rails.root.join("app/views/postnhost/static_pages/*.html.erb"),
+        Postnhost::Engine.root.join("app/views/postnhost/static_pages/*.html.erb")
+      ].flat_map { |pattern| Dir[pattern.to_s] }
+    end
+  end
+end

data/app/controllers/concerns/postnhost/public_http_caching.rb

@@ -0,0 +1,35 @@
+module Postnhost
+  module PublicHttpCaching
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :public_site_revision
+    end
+
+    private
+
+    def apply_public_http_cache(*dependencies, template:)
+      return if user_signed_in?
+
+      fresh_when(
+        etag: [public_layout_digest, public_site_revision, @current_language&.id, controller_path, action_name,
+               request.script_name, current_setting.site_configuration_cache_key, *dependencies].compact,
+        public: true,
+        template:
+      )
+      expires_in 0.seconds, public: true, must_revalidate: true
+    end
+
+    def public_site_revision
+      public_request_context.public_site_revision
+    end
+
+    def public_layout_digest
+      ActionView::Digestor.digest(
+        name: "layouts/#{resolved_public_layout_template}",
+        format: nil,
+        finder: lookup_context
+      )
+    end
+  end
+end

data/app/controllers/concerns/postnhost/public_page_size.rb

@@ -0,0 +1,17 @@
+module Postnhost
+  module PublicPageSize
+    extend ActiveSupport::Concern
+
+    PAGINATION_SLOTS = 3
+
+    private
+
+    def pagination_slots
+      PAGINATION_SLOTS
+    end
+
+    def public_page_size
+      current_setting.effective_public_page_size
+    end
+  end
+end

data/app/controllers/concerns/postnhost/public_template_resolvable.rb

@@ -0,0 +1,44 @@
+module Postnhost
+  module PublicTemplateResolvable
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_public_template_name
+    end
+
+    def default_url_options
+      options = @public_default_url_options ||= super.merge(current_setting.site_url_options)
+      return options unless preview_public_template_name
+
+      options.merge(preview_template: preview_public_template_name)
+    end
+
+    private
+
+    def current_public_template_name
+      @current_public_template_name ||= preview_public_template_name || public_request_context.template_name
+    end
+
+    def preview_public_template_name
+      return @preview_public_template_name if defined?(@preview_public_template_name)
+      return @preview_public_template_name = nil unless user_signed_in? && params[:preview_template].present?
+
+      @preview_public_template_name = params[:preview_template].tap do |template_name|
+        raise ActiveRecord::RecordNotFound unless Postnhost::Template::NAMES.include?(template_name)
+      end
+    end
+
+    def resolved_public_layout_template
+      "postnhost/public/templates/#{current_public_template_name}"
+    end
+
+    def render_public_template(path, **options)
+      resolved_template = resolve_public_template(path)
+      render({ template: resolved_template }.merge(options))
+    end
+
+    def resolve_public_template(path)
+      "postnhost/public/templates/#{current_public_template_name}/#{path}"
+    end
+  end
+end

data/app/controllers/concerns/postnhost/settings/i18n_manageable.rb

@@ -0,0 +1,61 @@
+module Postnhost
+  module Settings
+    module I18nManageable
+      extend ActiveSupport::Concern
+
+      private
+
+      def translations_params
+        params.fetch(:translations, ActionController::Parameters.new).permit!.to_h
+      end
+
+      def selected_locale_key
+        locale_keys = @locale_keys || locale_keys_for_i18n
+        locale = params[:locale].presence || params[:locale_key].presence
+        if locale.present?
+          locale_key = locale.to_s
+          return locale_key if locale_keys.include?(locale_key)
+        end
+
+        locale_keys.first
+      end
+
+      def update_i18n
+        locale = selected_locale_key
+        if locale.blank?
+          @setting.errors.add(:base, "Create at least one language before editing i18n settings.")
+          set_i18n_editor_state
+          render :edit, status: :unprocessable_content
+          return
+        end
+
+        merged_overrides = Postnhost::Settings::I18nOverrides.merge_locale_overrides(
+          @setting.locale_overrides, locale, translations_params
+        )
+
+        if @setting.update(locale_overrides: merged_overrides)
+          redirect_to edit_settings_path(section: "i18n", locale: locale),
+                      notice: "I18n settings were successfully updated."
+        else
+          set_i18n_editor_state
+          @translation_entries = @translation_entries.merge(translations_params.transform_keys(&:to_s))
+          render :edit, status: :unprocessable_content
+        end
+      end
+
+      def set_i18n_editor_state
+        @locale_keys = locale_keys_for_i18n
+        @selected_locale_key = selected_locale_key
+        @translation_entries = Postnhost::Settings::I18nOverrides.editable_translations_for_locale(
+          @selected_locale_key,
+          @setting.locale_overrides
+        )
+      end
+
+      def locale_keys_for_i18n
+        allowed_locales = Postnhost::Language.pluck(:html_lang).compact
+        Postnhost::Settings::I18nOverrides.locale_keys(@setting.locale_overrides, allowed_locales: allowed_locales)
+      end
+    end
+  end
+end

data/app/controllers/concerns/postnhost/settings/navigation_manageable.rb

@@ -0,0 +1,118 @@
+module Postnhost
+  module Settings
+    module NavigationManageable
+      extend ActiveSupport::Concern
+
+      private
+
+      def set_navigation_editor_state
+        @navigation_locale_keys = Postnhost::Language.order(:name).pluck(:html_lang)
+        @selected_navigation_locale_key = selected_navigation_locale_key
+        @default_navigation_locale_key = Postnhost::Language.blog_default&.html_lang || I18n.default_locale.to_s
+        @navigation = @setting.current_navigation
+        @navigation_tree = navigation_tree_for_editor
+        @navigation_target_options = navigation_target_options
+      end
+
+      def selected_navigation_locale_key
+        locale_keys = @navigation_locale_keys || Postnhost::Language.order(:name).pluck(:html_lang)
+        locale = params[:locale].presence || params[:locale_key].presence
+        locale = locale.to_s if locale.present?
+        return locale if locale.present? && locale_keys.include?(locale)
+
+        locale_keys.first
+      end
+
+      def update_navigation
+        set_navigation_editor_state
+        @setting.assign_attributes(
+          use_auto_header_navigation: navigation_setting_enabled?(:use_auto_header_navigation),
+          use_auto_footer_navigation: navigation_setting_enabled?(:use_auto_footer_navigation)
+        )
+
+        tree = parse_navigation_tree
+        if tree.nil?
+          @setting.errors.add(:base, "Navigation payload is invalid")
+          render :edit, status: :unprocessable_content
+          return
+        end
+
+        Postnhost::Setting.transaction do
+          @setting.save!
+          @navigation.replace_tree!(tree:, locale_key: @selected_navigation_locale_key)
+        end
+
+        redirect_to edit_settings_path(section: "navigation", locale: @selected_navigation_locale_key),
+                    notice: "Navigation settings were successfully updated."
+      end
+
+      def navigation_setting_enabled?(key)
+        ActiveModel::Type::Boolean.new.cast(params.dig(:setting, key))
+      end
+
+      def parse_navigation_tree
+        raw_tree = params.dig(:navigation, :tree)
+        return nil if raw_tree.blank?
+
+        parsed = JSON.parse(raw_tree)
+        return unless parsed.is_a?(Hash)
+
+        header = parsed["header"]
+        footer = parsed["footer"]
+        return unless header.is_a?(Array) && footer.is_a?(Array)
+
+        {
+          "header" => header,
+          "footer" => footer
+        }
+      rescue JSON::ParserError
+        nil
+      end
+
+      def navigation_tree_for_editor
+        items = @navigation.navigation_items.includes(:children).to_a
+
+        {
+          "header" => navigation_items_tree(items.select { |item| item.container_kind == "header" && item.parent_id.nil? }),
+          "footer" => navigation_items_tree(items.select { |item| item.container_kind == "footer" && item.parent_id.nil? })
+        }
+      end
+
+      def navigation_items_tree(items)
+        items.sort_by(&:position).map do |item|
+          {
+            "id" => item.id,
+            "kind" => item.kind,
+            "target_kind" => item.target_kind,
+            "target_id" => item.target_id,
+            "target_slug" => item.target_slug,
+            "url" => item.url,
+            "nofollow" => item.nofollow,
+            "label" => item.label_for(locale_key: @selected_navigation_locale_key, default_locale_key: @default_navigation_locale_key),
+            "has_locale_override" => item.label_translations.to_h.key?(@selected_navigation_locale_key),
+            "children" => navigation_items_tree(item.children)
+          }
+        end
+      end
+
+      def navigation_target_options
+        {
+          "article" => Postnhost::Snapshot::Article.order(:title).pluck(:title, :article_id),
+          "page" => Postnhost::Snapshot::Page.order(:title).pluck(:title, :page_id),
+          "category" => Postnhost::Category.order(:name).pluck(:name, :id),
+          "static_page" => static_page_slugs.map { |slug| [slug.humanize, slug] }
+        }
+      end
+
+      def static_page_slugs
+        [
+          Rails.root.join("app/views/postnhost/static_pages/*.html.erb"),
+          Postnhost::Engine.root.join("app/views/postnhost/static_pages/*.html.erb")
+        ].flat_map { |pattern| Dir[pattern.to_s] }
+         .map { |path| File.basename(path, ".html.erb") }
+         .uniq
+         .sort
+      end
+    end
+  end
+end

data/app/controllers/concerns/postnhost/settings/schema_manageable.rb

@@ -0,0 +1,140 @@
+module Postnhost
+  module Settings
+    module SchemaManageable
+      extend ActiveSupport::Concern
+      include Postnhost::SchemaHelper
+
+      SCHEMA_SETTING_FIELDS = %w[
+        organization_type
+        founding_date
+        founding_location
+        contact_email
+        contact_type
+        address
+        address_city
+        address_country
+        default_article_type
+        coverage_starts_at
+        coverage_ends_at
+      ].freeze
+
+      SCHEMA_ARRAY_FIELDS = %w[same_as].freeze
+
+      private
+
+      def set_schema_editor_state
+        @schema_locale_keys = schema_locale_keys
+        @schema_default_locale_key = @setting.schema_default_locale_key
+        @schema_selected_locale_key = selected_schema_locale_key
+        @schema_setting_values = @setting.schema_settings_hash
+        @schema_translation_entries = schema_translation_entries_for(@schema_selected_locale_key)
+      end
+
+      def selected_schema_locale_key
+        @schema_locale_keys ||= schema_locale_keys
+        locale = params[:locale].presence || params[:locale_key].presence
+        return locale if locale.present? && @schema_locale_keys.include?(locale.to_s)
+
+        @schema_default_locale_key || @setting.schema_default_locale_key
+      end
+
+      def update_schema
+        @schema_locale_keys = schema_locale_keys
+        @schema_default_locale_key = @setting.schema_default_locale_key
+        locale_key = selected_schema_locale_key
+        merged_schema_settings = @setting.schema_settings_hash.merge(schema_settings_params)
+        merged_schema_overrides = merge_schema_locale_overrides(
+          @setting.schema_locale_overrides_hash,
+          locale_key,
+          schema_translation_params
+        )
+
+        if @setting.update(schema_settings: merged_schema_settings, schema_locale_overrides: merged_schema_overrides)
+          redirect_to edit_settings_path(section: "schema", locale: locale_key),
+                      notice: "Schema settings were successfully updated."
+        else
+          set_schema_editor_state
+          @schema_setting_values = merged_schema_settings
+          @schema_translation_entries = @schema_translation_entries.merge(schema_translation_params.stringify_keys)
+          render :edit, status: :unprocessable_content
+        end
+      end
+
+      def schema_locale_keys
+        keys = Postnhost::Language.pluck(:html_lang).compact.uniq
+        return [I18n.default_locale.to_s] if keys.empty?
+
+        return keys unless keys.include?("en")
+
+        ["en"] + keys.reject { |locale| locale == "en" }
+      end
+
+      def schema_translation_entries_for(locale)
+        SETTINGS_TEXT_OVERRIDE_FIELDS.index_with do |field|
+          @setting.schema_text_for(locale:, key: field, fallback: schema_text_fallback(field))
+        end
+      end
+
+      def schema_translation_params
+        translations = params.fetch(:schema_translations, ActionController::Parameters.new).permit!
+        SETTINGS_TEXT_OVERRIDE_FIELDS.index_with do |field|
+          translations[field]
+        end
+      end
+
+      def schema_settings_params
+        settings_params = params.fetch(:schema_settings, ActionController::Parameters.new).permit!
+        merged = SCHEMA_SETTING_FIELDS.index_with { |field| settings_params[field] }
+
+        SCHEMA_ARRAY_FIELDS.each do |field|
+          merged[field] = schema_multiline_to_array(settings_params[field])
+        end
+
+        merged["policies"] = schema_policy_fields.keys.index_with do |key|
+          settings_params.dig("policies", key)
+        end
+
+        merged.transform_values do |value|
+          value.is_a?(String) ? value.strip : value
+        end
+      end
+
+      def merge_schema_locale_overrides(current_overrides, locale_key, edited_translations)
+        locale = locale_key.to_s
+        normalized = current_overrides.deep_dup
+        normalized[locale] ||= {}
+
+        edited_translations.each do |field, value|
+          text = value.to_s.strip
+          if text.blank?
+            normalized[locale].delete(field)
+            next
+          end
+
+          if locale != @schema_default_locale_key && text == default_locale_schema_value(field)
+            normalized[locale].delete(field)
+            next
+          end
+
+          normalized[locale][field] = text
+        end
+
+        normalized.delete(locale) if normalized[locale].blank?
+        normalized
+      end
+
+      def default_locale_schema_value(field)
+        @setting.schema_text_for(locale: @schema_default_locale_key, key: field, fallback: schema_text_fallback(field))
+      end
+
+      def schema_text_fallback(field)
+        case field.to_s
+        when "website_name", "organization_name"
+          I18n.t("postnhost.public.site.schema_site_name")
+        when "website_description", "organization_description"
+          I18n.t("postnhost.public.site.blog_meta_description")
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/postnhost/users/schema_manageable.rb

@@ -0,0 +1,119 @@
+module Postnhost
+  module Users
+    module SchemaManageable
+      extend ActiveSupport::Concern
+      include Postnhost::SchemaHelper
+
+      USER_SCHEMA_PROFILE_FIELDS = %w[
+        same_as
+        image_url
+        knows_language
+        alumni_type
+      ].freeze
+
+      USER_SCHEMA_TEXT_FIELDS = %w[
+        name
+        job_title
+        bio
+        knows_about
+        alumni_of
+        awards
+      ].freeze
+
+      private
+
+      def set_user_schema_editor_state
+        @schema_locale_keys = user_schema_locale_keys
+        @schema_default_locale_key = user_schema_default_locale_key
+        @schema_selected_locale_key = selected_user_schema_locale_key
+        @schema_profile_values = @user.schema_profile_hash
+        @schema_translation_entries = user_schema_translation_entries_for(@schema_selected_locale_key)
+      end
+
+      def selected_user_schema_locale_key
+        @schema_locale_keys ||= user_schema_locale_keys
+        locale = params[:locale].presence || params[:locale_key].presence
+        return locale if locale.present? && @schema_locale_keys.include?(locale.to_s)
+
+        user_schema_default_locale_key
+      end
+
+      def user_schema_default_locale_key
+        Postnhost::Language.find_by(default: true)&.html_lang.presence || I18n.default_locale.to_s
+      end
+
+      def user_schema_locale_keys
+        keys = Postnhost::Language.pluck(:html_lang).compact.uniq
+        return [user_schema_default_locale_key] if keys.empty?
+
+        return keys unless keys.include?("en")
+
+        ["en"] + keys.reject { |locale| locale == "en" }
+      end
+
+      def user_schema_profile_params
+        settings_params = params.fetch(:schema_profile, ActionController::Parameters.new).permit!
+        USER_SCHEMA_PROFILE_FIELDS.index_with do |field|
+          if %w[same_as knows_language].include?(field)
+            schema_multiline_to_array(settings_params[field])
+          else
+            settings_params[field].to_s.strip
+          end
+        end
+      end
+
+      def user_schema_translation_params
+        translations = params.fetch(:schema_translations, ActionController::Parameters.new).permit!
+        USER_SCHEMA_TEXT_FIELDS.index_with do |field|
+          translations[field].to_s.strip
+        end
+      end
+
+      def user_schema_translation_entries_for(locale)
+        USER_SCHEMA_TEXT_FIELDS.index_with do |field|
+          @user.schema_text_for(locale:, key: field, fallback: user_schema_fallback(field))
+        end
+      end
+
+      def merge_user_schema_locale_overrides(current_overrides, locale_key, edited_translations)
+        locale = locale_key.to_s
+        normalized = current_overrides.deep_dup
+        normalized[locale] ||= {}
+
+        edited_translations.each do |field, value|
+          if value.blank?
+            normalized[locale].delete(field)
+            next
+          end
+
+          if locale != user_schema_default_locale_key && value == user_default_schema_value(field)
+            normalized[locale].delete(field)
+            next
+          end
+
+          normalized[locale][field] = value
+        end
+
+        normalized.delete(locale) if normalized[locale].blank?
+        normalized
+      end
+
+      def user_default_schema_value(field)
+        @user.schema_text_for(locale: user_schema_default_locale_key, key: field, fallback: user_schema_fallback(field))
+      end
+
+      def user_schema_fallback(field)
+        case field.to_s
+        when "name"
+          @user.name
+        when "job_title"
+          @user.position
+        when "bio"
+          @user.bio
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/app/controllers/postnhost/application_controller.rb

@@ -0,0 +1,37 @@
+module Postnhost
+  class ApplicationController < ::ApplicationController
+    include Postnhost::Authentication
+    include Pagy::Method
+
+    # Base locale before public LanguageSwitcher; avoids leaking I18n.locale into CMS/tests.
+    prepend_before_action :set_cms_locale
+
+    around_action :use_postnhost_timezone
+
+    helper_method :current_setting
+
+    helper Postnhost::ApplicationHelper
+    helper Postnhost::ArticleHelper
+    helper Postnhost::CategoryHelper
+    helper Postnhost::CommonCssHelper
+    helper Postnhost::NavigationHelper
+    helper Postnhost::PagyHelper
+    helper Postnhost::PublicPagesHelper
+    helper Postnhost::SeoHelper
+    helper Postnhost::SettingsHelper
+
+    private
+
+    def current_setting
+      @current_setting ||= Postnhost::Setting.current
+    end
+
+    def set_cms_locale
+      I18n.locale = I18n.default_locale
+    end
+
+    def use_postnhost_timezone(&)
+      Time.use_zone(current_setting.effective_timezone_name, &)
+    end
+  end
+end