postnhost 0.0.0 → 0.1.0

data/app/controllers/postnhost/page_variants_controller.rb

@@ -0,0 +1,136 @@
+module Postnhost
+  class PageVariantsController < ApplicationController
+    PAGE_SIZE = 15
+
+    before_action :authenticate_user!
+    before_action :load_page
+    before_action :load_page_variant, only: %i[edit update publish unpublish destroy]
+    before_action :ensure_variant_editable, only: %i[edit update publish unpublish]
+
+    layout :resolve_layout
+
+    def index
+      variants = @page.page_variants.includes(:language, :page_variant_snapshot).order(:created_at)
+      @pagy, @variants = pagy(:offset, variants, limit: PAGE_SIZE)
+      @available_languages = Postnhost::Language.where.not(id: @page.page_variants.select(:language_id))
+      @available_languages = @available_languages.where.not(id: @page.language_id) if @page.language_id.present?
+    end
+
+    def new
+      @page_variant = @page.page_variants.new
+      @page_variant.language = Postnhost::Language.find_by(id: params[:language_id]) if params[:language_id]
+      @page_variant.title = @page.title
+      @page_variant.title_tag = @page.title_tag
+      @page_variant.og_title = @page.og_title
+      @page_variant.meta_description = @page.meta_description
+      @page_variant.content = @page.content
+      @page_variant.save!
+
+      redirect_to edit_page_variant_path(@page, @page_variant),
+                  notice: "Page variant was successfully created."
+    end
+
+    def edit; end
+
+    def update
+      if @page_variant.update(variant_params)
+        respond_to do |format|
+          format.html do
+            redirect_to edit_page_variant_path(@page, @page_variant),
+                        notice: "Translation was successfully updated."
+          end
+          format.json { head :no_content }
+          format.turbo_stream
+        end
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def publish
+      result = Postnhost::Publishing::PageVariants::Publish.call(page_variant: @page_variant)
+      @page_variant.reload
+      error = result.errors.to_sentence unless result.success?
+
+      respond_to do |format|
+        format.html do
+          redirect_to edit_page_variant_path(@page, @page_variant), **(error.present? ? { alert: error } : {})
+        end
+        format.turbo_stream do
+          flash.now[:alert] = error if error.present?
+          render :publish, status: result.status
+        end
+      end
+    end
+
+    def unpublish
+      result = Postnhost::Publishing::PageVariants::Unpublish.call(page_variant: @page_variant)
+      @page_variant.reload
+      error = result.errors.to_sentence unless result.success?
+
+      respond_to do |format|
+        format.html do
+          redirect_to edit_page_variant_path(@page, @page_variant), **(error.present? ? { alert: error } : {})
+        end
+        format.turbo_stream do
+          flash.now[:alert] = error if error.present?
+          render :unpublish, status: result.status
+        end
+      end
+    end
+
+    def destroy
+      @page_variant.destroy
+      redirect_to page_variants_path(@page), notice: "Translation was successfully deleted."
+    end
+
+    def bulk_publish
+      result = Postnhost::Publishing::PageVariants::PublishMany.call(page: @page, ids: params[:ids])
+      error = result.errors.to_sentence unless result.success?
+      error = "#{result.value[:failures].count} translation(s) failed." if result.success? && result.value[:failures].any?
+
+      redirect_to page_variants_path(@page), **(error.present? ? { alert: error } : {})
+    end
+
+    def bulk_unpublish
+      result = Postnhost::Publishing::PageVariants::UnpublishMany.call(page: @page, ids: params[:ids])
+      error = result.errors.to_sentence unless result.success?
+      error = "#{result.value[:failures].count} translation(s) failed." if result.success? && result.value[:failures].any?
+
+      redirect_to page_variants_path(@page), **(error.present? ? { alert: error } : {})
+    end
+
+    def bulk_destroy
+      variants = @page.page_variants.where(id: params[:ids]).where.not(generating: true)
+      count = variants.count
+      variants.destroy_all
+
+      redirect_to page_variants_path(@page), notice: "#{count} translation(s) deleted successfully."
+    end
+
+    private
+
+    def load_page
+      @page = Postnhost::Page.find(params[:page_id])
+    end
+
+    def load_page_variant
+      @page_variant = @page.page_variants.find(params[:id])
+    end
+
+    def ensure_variant_editable
+      return unless @page_variant.generating?
+
+      redirect_to page_variants_path(@page),
+                  alert: "This translation is still in progress. You can edit it when it finishes."
+    end
+
+    def variant_params
+      params.require(:page_variant).permit(:title, :title_tag, :og_title, :meta_description, :content, :language_id)
+    end
+
+    def resolve_layout
+      action_name == "index" ? "postnhost/product" : "postnhost/articles"
+    end
+  end
+end

data/app/controllers/postnhost/pages/images_controller.rb

@@ -0,0 +1,28 @@
+module Postnhost
+  class Pages::ImagesController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_page
+
+    def create
+      file = params[:file]
+
+      if file.present?
+        result = @page.upload_inline_image(file)
+
+        if result[:success]
+          render json: { url: result[:url] }, status: :ok
+        else
+          render json: { error: result[:error] }, status: :unprocessable_content
+        end
+      else
+        render json: { error: "No file provided" }, status: :bad_request
+      end
+    end
+
+    private
+
+    def load_page
+      @page = Postnhost::Page.find(params[:page_id])
+    end
+  end
+end

data/app/controllers/postnhost/pages/translations_controller.rb

@@ -0,0 +1,26 @@
+module Postnhost
+  class Pages::TranslationsController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_page
+
+    def new; end
+
+    def create
+      language_ids = params[:language_ids] || []
+
+      language_ids.each do |language_id|
+        Postnhost::Translation::PageVariantJob.perform_later(@page.id, language_id.to_i)
+
+        @page.page_variants.create!(language: Postnhost::Language.find_by(id: language_id.to_i), generating: true)
+      end
+
+      redirect_to page_variants_path(@page)
+    end
+
+    private
+
+    def load_page
+      @page = Postnhost::Page.find(params[:page_id])
+    end
+  end
+end

data/app/controllers/postnhost/pages_controller.rb

@@ -0,0 +1,95 @@
+module Postnhost
+  class PagesController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_page, only: %i[edit update destroy publish unpublish]
+
+    layout :resolve_layout
+
+    def index
+      @pages = Postnhost::Page.includes(:page_snapshot).order(updated_at: :desc)
+      @static_page_slugs = static_page_slugs
+    end
+
+    def new
+      @page = current_user.pages.new
+      @page.language = Postnhost::Language.blog_default
+      @page.save!
+      redirect_to edit_page_path(@page)
+    end
+
+    def edit; end
+
+    def update
+      if @page.update(page_params)
+        respond_to do |format|
+          format.html { redirect_to edit_page_path(@page) }
+          format.json { head :no_content }
+          format.turbo_stream { head :no_content }
+        end
+      else
+        respond_to do |format|
+          format.html { render :edit, status: :unprocessable_content }
+          format.json { render json: { errors: @page.errors.full_messages }, status: :unprocessable_content }
+          format.turbo_stream { head :unprocessable_content }
+        end
+      end
+    end
+
+    def publish
+      result = Postnhost::Publishing::Pages::Publish.call(page: @page)
+      @page.reload
+      error = result.errors.to_sentence unless result.success?
+
+      respond_to do |format|
+        format.html { redirect_to edit_page_path(@page), **(error.present? ? { alert: error } : {}) }
+        format.turbo_stream do
+          flash.now[:alert] = error if error.present?
+          render :publish, status: result.status
+        end
+      end
+    end
+
+    def unpublish
+      result = Postnhost::Publishing::Pages::Unpublish.call(page: @page)
+      @page.reload
+      error = result.errors.to_sentence unless result.success?
+
+      respond_to do |format|
+        format.html { redirect_to edit_page_path(@page), **(error.present? ? { alert: error } : {}) }
+        format.turbo_stream do
+          flash.now[:alert] = error if error.present?
+          render :unpublish, status: result.status
+        end
+      end
+    end
+
+    def destroy
+      @page.destroy
+      redirect_to pages_path
+    end
+
+    private
+
+    def load_page
+      @page = Postnhost::Page.find(params[:id])
+    end
+
+    def page_params
+      params.require(:page).permit(:title, :title_tag, :og_title, :meta_description, :content, :slug, :language_id)
+    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 { |template_path| File.basename(template_path, ".html.erb") }
+       .uniq
+       .sort
+    end
+
+    def resolve_layout
+      action_name == "index" ? "postnhost/product" : "postnhost/articles"
+    end
+  end
+end

data/app/controllers/postnhost/public/articles_controller.rb

@@ -0,0 +1,135 @@
+module Postnhost
+  class Public::ArticlesController < Postnhost::PublicController
+    TOP_PICKS_LIMIT = 4
+
+    include CanonicalFirstPageRedirect
+    include LanguageSwitcher
+    include PublicFooterData
+    include PublicHttpCaching
+    include PublicPageSize
+    include PublicTemplateResolvable
+
+    layout :resolved_public_layout_template
+
+    before_action :authenticate_user!, only: %i[preview]
+    before_action :ensure_search_enabled, only: %i[search]
+    before_action :redirect_page_one_to_canonical!, only: %i[index search]
+
+    def index
+      apply_public_http_cache(params[:page].to_i, template: resolve_public_template("articles/index"))
+      return if performed?
+
+      set_footer_data
+      load_index_collection
+      render_public_template("articles/index")
+    end
+
+    def search
+      @search_query = normalized_search_query
+      apply_public_http_cache(@search_query, params[:page].to_i, template: resolve_public_template("articles/index"))
+      return if performed?
+
+      set_footer_data
+      load_index_collection(search_only: true)
+
+      render_public_template("articles/index")
+    end
+
+    def show
+      resolution = public_route_resolution(kind: :article, slug: params[:slug])
+      apply_public_http_cache(resolution.record_id, template: resolve_public_template("articles/show"))
+      return if performed?
+
+      @article = resolution.record
+      raise ActiveRecord::RecordNotFound if !localized_request? && @article.language_id != @current_language.id
+
+      preload_article_associations
+
+      if localized_request?
+        @article_variant = @article.article_variant_snapshots.for_language(@current_language).first!
+        @content = @article_variant
+        @actual_language = @article_variant.language
+        @primary_language = @article.language
+      else
+        @content = @article
+        @actual_language = @current_language
+        @primary_language = @current_language
+      end
+
+      @available_variants = @article.article_variant_snapshots.with_language.to_a
+
+      set_footer_data
+      render_public_template("articles/show")
+    end
+
+    def preview
+      set_footer_data
+      @article = Postnhost::Article.includes(:categories, :language, article_authors: :user).find(params[:id])
+
+      @content = @article
+      @actual_language = @article.language || @current_language
+
+      @available_variants = @article.article_variants.includes(:language)
+
+      render_public_template("articles/preview")
+    end
+
+    private
+
+    def ensure_search_enabled
+      raise_not_found unless current_setting.search_enabled?
+    end
+
+    def load_index_collection(search_only: false)
+      load_top_pick_collection unless search_only || params[:page].to_i > 1
+
+      collection = public_article_collection
+      collection = collection.matching(@search_query) if search_only
+      @pagy, snapshots = pagy(:offset, collection, limit: public_page_size, slots: pagination_slots)
+      assign_article_collection(snapshots)
+    end
+
+    def load_top_pick_collection
+      snapshots = public_article_collection.top_picks.limit(TOP_PICKS_LIMIT)
+
+      if localized_request?
+        @top_pick_article_variant_snapshots = snapshots
+      else
+        @top_pick_article_snapshots = snapshots
+      end
+    end
+
+    def preload_article_associations
+      associations = [:categories, { article_snapshot_authors: :user }]
+      associations << :language if localized_request?
+      ActiveRecord::Associations::Preloader.new(records: [@article], associations:).call
+    end
+
+    def public_article_collection
+      if localized_request?
+        Postnhost::Snapshot::ArticleVariant.for_language(@current_language)
+                                           .with_language
+                                           .with_categories
+                                           .with_authors
+                                           .recent_first
+      else
+        Postnhost::Snapshot::Article.for_language(@current_language)
+                                    .with_categories
+                                    .with_authors
+                                    .recent_first
+      end
+    end
+
+    def assign_article_collection(snapshots)
+      if localized_request?
+        @article_variant_snapshots = snapshots
+      else
+        @article_snapshots = snapshots
+      end
+    end
+
+    def normalized_search_query
+      params[:s].to_s.strip.presence
+    end
+  end
+end

data/app/controllers/postnhost/public/authors_controller.rb

@@ -0,0 +1,57 @@
+module Postnhost
+  class Public::AuthorsController < Postnhost::PublicController
+    include CanonicalFirstPageRedirect
+    include LanguageSwitcher
+    include PublicFooterData
+    include PublicHttpCaching
+    include PublicPageSize
+    include PublicTemplateResolvable
+
+    layout :resolved_public_layout_template
+
+    before_action :ensure_author_pages_enabled
+    before_action :redirect_page_one_to_canonical!, only: %i[show]
+    before_action :load_author
+
+    def show
+      apply_public_http_cache(@author, params[:page].to_i, template: resolve_public_template("authors/show"))
+      return if performed?
+
+      set_footer_data
+      @pagy, snapshots = pagy(:offset, author_articles, limit: public_page_size, slots: pagination_slots)
+
+      if localized_request?
+        @article_variant_snapshots = snapshots
+      else
+        @article_snapshots = snapshots
+      end
+
+      render_public_template("authors/show")
+    end
+
+    private
+
+    def ensure_author_pages_enabled
+      raise_not_found unless current_setting.author_pages_enabled?
+    end
+
+    def load_author
+      @author = Postnhost::User.find_by!(slug: params[:slug])
+    end
+
+    def author_articles
+      if localized_request?
+        Postnhost::Snapshot::ArticleVariant.for_language(@current_language)
+                                           .by_author(@author)
+                                           .with_language
+                                           .with_categories
+                                           .recent_first
+      else
+        Postnhost::Snapshot::Article.for_language(@current_language)
+                                    .by_author(@author)
+                                    .with_categories
+                                    .recent_first
+      end
+    end
+  end
+end

data/app/controllers/postnhost/public/categories_controller.rb

@@ -0,0 +1,61 @@
+module Postnhost
+  class Public::CategoriesController < Postnhost::PublicController
+    include CanonicalFirstPageRedirect
+    include LanguageSwitcher
+    include PublicFooterData
+    include PublicHttpCaching
+    include PublicPageSize
+    include PublicTemplateResolvable
+
+    layout :resolved_public_layout_template
+
+    before_action :redirect_page_one_to_canonical!, only: %i[index]
+
+    def index
+      resolution = public_route_resolution(kind: :category, slug: params[:category_slug])
+      apply_public_http_cache(resolution.record_id, params[:page].to_i,
+                              template: resolve_public_template("categories/index"))
+      return if performed?
+
+      @category = resolution.record
+      ActiveRecord::Associations::Preloader.new(records: [@category], associations: :category_variants).call unless @current_language.default?
+      set_category_language_data
+      set_footer_data
+      @pagy, snapshots = pagy(:offset, category_articles, limit: public_page_size, slots: pagination_slots)
+
+      if localized_request?
+        @article_variant_snapshots = snapshots
+      else
+        @article_snapshots = snapshots
+      end
+
+      render_public_template("categories/index")
+    end
+
+    private
+
+    def set_category_language_data
+      @published_category_language_ids = Postnhost::Snapshot::ArticleVariant
+                                         .in_category(@category)
+                                         .distinct
+                                         .pluck(:language_id)
+      @localized_category_fallback = localized_request? &&
+                                     @published_category_language_ids.exclude?(@current_language.id)
+    end
+
+    def category_articles
+      if localized_request?
+        Postnhost::Snapshot::ArticleVariant.for_language(@current_language)
+                                           .in_category(@category)
+                                           .with_language
+                                           .with_authors
+                                           .recent_first
+      else
+        Postnhost::Snapshot::Article.for_language(@current_language)
+                                    .in_category(@category)
+                                    .with_authors
+                                    .recent_first
+      end
+    end
+  end
+end

data/app/controllers/postnhost/public/static_pages_controller.rb

@@ -0,0 +1,77 @@
+module Postnhost
+  class Public::StaticPagesController < Postnhost::PublicController
+    include LanguageSwitcher
+    include PublicFooterData
+    include PublicHttpCaching
+    include PublicTemplateResolvable
+
+    layout :resolved_public_layout_template
+
+    def show
+      raise ActionController::RoutingError, "Not Found" unless valid_slug?
+
+      if page_resolution.present?
+        apply_public_http_cache(page_resolution.record_id, template: resolve_public_template("static_pages/show"))
+        return if performed?
+
+        set_footer_data
+        load_dynamic_page
+        return render_public_template("static_pages/show")
+      end
+
+      template = resolved_template
+      raise ActionController::RoutingError, "Not Found" unless template
+
+      apply_public_http_cache(params[:slug], template:)
+      return if performed?
+
+      set_footer_data
+      render template: template
+    end
+
+    private
+
+    def resolved_template
+      template_path = "postnhost/static_pages/#{params[:slug]}"
+      template_path if lookup_context.exists?(template_path, [], false)
+    end
+
+    def page_resolution
+      return @page_resolution if defined?(@page_resolution)
+
+      @page_resolution = public_request_context.resolve_kind(:page, params[:slug])
+    end
+
+    def load_dynamic_page
+      @page = page_snapshot
+      @available_variants = @page.page_variant_snapshots.with_language
+
+      if localized_request?
+        @content = dynamic_page_variant
+        @actual_language = dynamic_page_variant.language
+      else
+        @content = page_snapshot
+        @actual_language = page_snapshot.language || @current_language
+      end
+    end
+
+    def page_snapshot
+      return @page_snapshot if defined?(@page_snapshot)
+
+      @page_snapshot = page_resolution.record
+      ActiveRecord::Associations::Preloader.new(records: [@page_snapshot], associations: %i[page language]).call
+      @page_snapshot
+    end
+
+    def dynamic_page_variant
+      return @dynamic_page_variant if defined?(@dynamic_page_variant)
+      return @dynamic_page_variant = nil if page_snapshot.blank?
+
+      @dynamic_page_variant = page_snapshot.page_variant_snapshots.for_language(@current_language).first
+    end
+
+    def valid_slug?
+      params[:slug].to_s.match?(/\A[a-z0-9_-]+\z/)
+    end
+  end
+end

data/app/controllers/postnhost/public_controller.rb

@@ -0,0 +1,32 @@
+module Postnhost
+  class PublicController < ApplicationController
+    before_action :validate_public_locale
+    before_action :redirect_to_onboarding_without_users
+
+    private
+
+    def current_setting
+      public_request_context.setting
+    end
+
+    def public_route_resolution(kind:, slug:)
+      resolution = public_request_context.resolve(slug)
+      raise ActiveRecord::RecordNotFound unless resolution&.kind == kind
+
+      resolution
+    end
+
+    def raise_not_found
+      raise ActionController::RoutingError, "Not Found"
+    end
+
+    def validate_public_locale
+      language = public_request_context.requested_language
+      raise_not_found if params[:locale].present? && (language.blank? || language.default?)
+    end
+
+    def redirect_to_onboarding_without_users
+      redirect_to postnhost.onboarding_path unless Postnhost::User.exists?
+    end
+  end
+end

data/app/controllers/postnhost/sessions_controller.rb

@@ -0,0 +1,37 @@
+module Postnhost
+  class SessionsController < ApplicationController
+    before_action :redirect_to_onboarding_when_needed, only: %i[new create]
+    before_action :skip_authentication, only: %i[new create]
+
+    def new; end
+
+    def create
+      user = Postnhost::User.find_by(email: session_params[:email].to_s.downcase.strip)
+
+      if user&.authenticate(session_params[:password].to_s)
+        sign_in(user)
+        redirect_to articles_path
+      else
+        flash.now[:alert] = "Invalid email or password."
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      sign_out
+      redirect_to root_path
+    end
+
+    private
+
+    def redirect_to_onboarding_when_needed
+      return if user_signed_in?
+
+      redirect_to postnhost.onboarding_path if Postnhost::User.none? || session[:onboarding_pending_user_id].present?
+    end
+
+    def session_params
+      params.require(:user).permit(:email, :password)
+    end
+  end
+end