postnhost 0.0.0 → 0.1.0

data/app/controllers/postnhost/article_variants_controller.rb

@@ -0,0 +1,138 @@
+module Postnhost
+  class ArticleVariantsController < ApplicationController
+    PAGE_SIZE = 15
+
+    before_action :authenticate_user!
+    before_action :load_article
+    before_action :load_article_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 = @article.article_variants.includes(:language, :article_variant_snapshot).order(:created_at)
+      @pagy, @variants = pagy(:offset, variants, limit: PAGE_SIZE)
+      @available_languages = Postnhost::Language.where.not(id: @article.article_variants.select(:language_id))
+      @available_languages = @available_languages.where.not(id: @article.language_id) if @article.language_id.present?
+    end
+
+    def new
+      @article_variant = @article.article_variants.new
+      @article_variant.language = Postnhost::Language.find_by(id: params[:language_id]) if params[:language_id]
+      @article_variant.title = @article.title
+      @article_variant.title_tag = @article.title_tag
+      @article_variant.og_title = @article.og_title
+      @article_variant.schema_headline = @article.schema_headline
+      @article_variant.meta_description = @article.meta_description
+      @article_variant.custom_excerpt = @article.custom_excerpt
+      @article_variant.use_excerpt_as_meta_description = @article.use_excerpt_as_meta_description
+      @article_variant.content = @article.content
+      @article_variant.save!
+
+      redirect_to edit_article_variant_path(@article, @article_variant)
+    end
+
+    def edit; end
+
+    def update
+      if @article_variant.update(variant_params)
+        respond_to do |format|
+          format.html do
+            redirect_to edit_article_variant_path(@article, @article_variant)
+          end
+          format.json { head :no_content }
+          format.turbo_stream
+        end
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def publish
+      result = Postnhost::Publishing::ArticleVariants::Publish.call(article_variant: @article_variant)
+      @article_variant.reload
+      error = result.errors.to_sentence unless result.success?
+
+      respond_to do |format|
+        format.html do
+          redirect_to edit_article_variant_path(@article, @article_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::ArticleVariants::Unpublish.call(article_variant: @article_variant)
+      @article_variant.reload
+      error = result.errors.to_sentence unless result.success?
+
+      respond_to do |format|
+        format.html do
+          redirect_to edit_article_variant_path(@article, @article_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
+      @article_variant.destroy
+      redirect_to article_variants_path(@article)
+    end
+
+    def bulk_publish
+      result = Postnhost::Publishing::ArticleVariants::PublishMany.call(article: @article, 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 article_variants_path(@article), **(error.present? ? { alert: error } : {})
+    end
+
+    def bulk_unpublish
+      result = Postnhost::Publishing::ArticleVariants::UnpublishMany.call(article: @article, 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 article_variants_path(@article), **(error.present? ? { alert: error } : {})
+    end
+
+    def bulk_destroy
+      variants = @article.article_variants.where(id: params[:ids]).where.not(generating: true)
+      count = variants.count
+      variants.destroy_all
+
+      redirect_to article_variants_path(@article), notice: "#{count} translation(s) deleted successfully."
+    end
+
+    private
+
+    def load_article
+      @article = Postnhost::Article.find(params[:article_id])
+    end
+
+    def load_article_variant
+      @article_variant = @article.article_variants.find(params[:id])
+    end
+
+    def ensure_variant_editable
+      return unless @article_variant.generating?
+
+      redirect_to article_variants_path(@article),
+                  alert: "This translation is still in progress. You can edit it when it finishes."
+    end
+
+    def variant_params
+      params.require(:article_variant).permit(:title, :title_tag, :og_title, :schema_headline, :meta_description,
+                                              :custom_excerpt, :use_excerpt_as_meta_description, :content, :language_id)
+    end
+
+    def resolve_layout
+      action_name == "index" ? "postnhost/product" : "postnhost/articles"
+    end
+  end
+end

data/app/controllers/postnhost/articles/cover_images_controller.rb

@@ -0,0 +1,35 @@
+module Postnhost
+  class Articles::CoverImagesController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_article, only: %i[create destroy]
+
+    def create
+      file = params[:file]
+
+      if file.present?
+        @article.cover_image = file
+
+        if @article.save
+          render json: { url: @article.cover_image.url }, status: :ok
+        else
+          render json: { error: @article.errors.full_messages.join(", ") }, status: :unprocessable_content
+        end
+      else
+        render json: { error: "No file provided" }, status: :bad_request
+      end
+    end
+
+    def destroy
+      # HACK: to bypass carrierwave image removal from bucket to keep the version history
+      @article.update_column(:cover_image, nil)
+
+      head :no_content
+    end
+
+    private
+
+    def load_article
+      @article = Postnhost::Article.find(params[:article_id])
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Postnhost
+  class Articles::ImagesController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_article
+
+    def create
+      file = params[:file]
+
+      if file.present?
+        result = @article.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_article
+      @article = Postnhost::Article.find(params[:article_id])
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Postnhost
+  class Articles::TranslationsController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_article
+
+    def new; end
+
+    def create
+      language_ids = params[:language_ids] || []
+
+      language_ids.each do |language_id|
+        Postnhost::Translation::ArticleVariantJob.perform_later(@article.id, language_id.to_i)
+
+        @article.article_variants.create!(language: Postnhost::Language.find_by(id: language_id.to_i), generating: true)
+      end
+
+      redirect_to article_variants_path(@article)
+    end
+
+    private
+
+    def load_article
+      @article = Postnhost::Article.find(params[:article_id])
+    end
+  end
+end

data/app/controllers/postnhost/articles_controller.rb

@@ -0,0 +1,130 @@
+module Postnhost
+  class ArticlesController < ApplicationController
+    PAGE_SIZE = 15
+
+    before_action :authenticate_user!
+    before_action :load_article, except: %i[index new]
+
+    layout :resolve_layout
+
+    def index
+      @status = Postnhost::Article.normalize_status(params[:status])
+      @sort = Postnhost::Article.normalize_sort(params[:sort])
+
+      articles = current_user.articles
+                             .includes(:language, :article_snapshot)
+                             .with_status(@status)
+                             .sorted_by(@sort)
+
+      @pagy, @articles = pagy(:offset, articles, limit: PAGE_SIZE)
+    end
+
+    def new
+      @article = current_user.articles.new
+      @article.language = Postnhost::Language.blog_default
+      @article.save!
+      redirect_to edit_article_path(@article)
+    end
+
+    def edit
+      @categories = Postnhost::Category.all
+      @users = Postnhost::User.order(:name, :email)
+      @languages = Postnhost::Language.order(default: :desc, name: :asc)
+      @articles = current_user.articles.where.not(id: @article.id).order(:title)
+    end
+
+    def update
+      if @article.update(article_params)
+        @article.sync_publication_schedule!
+        respond_to do |format|
+          format.html { redirect_to articles_path }
+          format.json { head :no_content }
+          format.turbo_stream
+        end
+      else
+        @categories = Postnhost::Category.all
+        @users = Postnhost::User.order(:name, :email)
+        @languages = Postnhost::Language.order(default: :desc, name: :asc)
+        @articles = current_user.articles.where.not(id: @article.id).order(:title)
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def publish
+      result = Postnhost::Publishing::Articles::Publish.call(article: @article)
+      @article.reload
+      respond_to do |format|
+        format.html do
+          redirect_to edit_article_path(@article),
+                      **publication_flash(result, success: "Article has been published.")
+        end
+        format.turbo_stream do
+          flash.now[result.success? ? :notice : :alert] = result.success? ? "Article has been published." : result.errors.to_sentence
+          render :publish, status: result.status
+        end
+      end
+    end
+
+    def unpublish
+      result = Postnhost::Publishing::Articles::Unpublish.call(article: @article)
+      @article.reload
+      respond_to do |format|
+        format.html do
+          redirect_to edit_article_path(@article),
+                      **publication_flash(result, success: "Article has been unpublished.")
+        end
+        format.turbo_stream do
+          flash.now[result.success? ? :notice : :alert] = result.success? ? "Article has been unpublished." : result.errors.to_sentence
+          render :unpublish, status: result.status
+        end
+      end
+    end
+
+    def rollback
+      version = @article.versions.find_by(id: params[:version_id])
+      result = version && Postnhost::Publishing::Versions::RestoreDraft.call(record: @article, version:)
+      if result&.success?
+        redirect_to edit_article_path(@article), notice: "Article has been rolled back to the selected version."
+      else
+        redirect_to edit_article_path(@article), alert: result&.errors&.to_sentence || "Version was not found."
+      end
+    end
+
+    def versions
+      publication_version_id = @article.article_snapshot&.paper_trail_version_id
+      @versions = @article.versions.includes(:item).sort_by do |version|
+        [version.id == publication_version_id ? 0 : 1, -version.created_at.to_i]
+      end
+    end
+
+    def version_preview
+      @version = @article.versions.find(params[:version_id])
+      @versioned_article = @version.reify
+    end
+
+    def destroy
+      @article.destroy
+      redirect_to articles_url
+    end
+
+    private
+
+    def load_article
+      @article = Postnhost::Article.find(params[:id])
+    end
+
+    def article_params
+      params.require(:article).permit(:title, :title_tag, :og_title, :schema_headline, :schema_article_type, :slug, :meta_description,
+                                      :custom_excerpt, :use_excerpt_as_meta_description, :content, :language_id, :cover_image_alt,
+                                      :scheduled_at, :top_pick, author_ids: [], category_ids: [], suggested_article_ids: [])
+    end
+
+    def resolve_layout
+      %w[index versions].include?(action_name) ? "postnhost/product" : "postnhost/articles"
+    end
+
+    def publication_flash(result, success:)
+      result.success? ? { notice: success } : { alert: result.errors.to_sentence }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Postnhost
+  class Categories::TranslationsController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_category
+
+    def create
+      language_ids = params[:language_ids] || []
+
+      language_ids.each do |language_id|
+        Postnhost::Translation::CategoryVariantJob.perform_later(@category.id, language_id.to_i)
+
+        @category.category_variants.create!(language: Postnhost::Language.find_by(id: language_id.to_i), generating: true)
+      end
+
+      redirect_to category_variants_path(@category)
+    end
+
+    private
+
+    def load_category
+      @category = Postnhost::Category.find(params[:category_id])
+    end
+  end
+end

data/app/controllers/postnhost/categories_controller.rb

@@ -0,0 +1,59 @@
+module Postnhost
+  class CategoriesController < ApplicationController
+    PAGE_SIZE = 15
+
+    before_action :authenticate_user!
+    before_action :load_category, only: %i[show edit update destroy]
+
+    layout "postnhost/product"
+
+    def index
+      @categories = Postnhost::Category.order(updated_at: :desc)
+    end
+
+    def show
+      articles = @category.articles.includes(:article_snapshot, :language).order(created_at: :desc)
+      @pagy, @articles = pagy(:offset, articles, limit: PAGE_SIZE)
+    end
+
+    def new
+      @category = Postnhost::Category.new
+    end
+
+    def edit; end
+
+    def create
+      @category = Postnhost::Category.new
+      @category.assign_attributes(category_params)
+
+      if @category.save
+        redirect_to categories_url
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def update
+      if @category.update(category_params)
+        redirect_to @category, notice: "Category was successfully updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @category.destroy
+      redirect_to categories_url, notice: "Category was successfully deleted."
+    end
+
+    private
+
+    def load_category
+      @category = Postnhost::Category.find(params[:id])
+    end
+
+    def category_params
+      params.require(:category).permit(:name, :slug, :meta_description)
+    end
+  end
+end

data/app/controllers/postnhost/category_variants_controller.rb

@@ -0,0 +1,69 @@
+module Postnhost
+  class CategoryVariantsController < ApplicationController
+    before_action :authenticate_user!
+    before_action :load_category
+    before_action :load_category_variant, only: %i[edit update destroy]
+    before_action :ensure_variant_editable, only: %i[edit update]
+
+    layout "postnhost/product"
+
+    def index
+      @variants = @category.category_variants.includes(:language).order(:created_at)
+      @available_languages = Postnhost::Language.where.not(id: @category.category_variants.select(:language_id))
+
+      default_language = Postnhost::Language.blog_default
+      @available_languages = @available_languages.where.not(id: default_language.id) if default_language.present?
+    end
+
+    def new
+      @category_variant = @category.category_variants.new
+      @category_variant.language = Postnhost::Language.find_by(id: params[:language_id]) if params[:language_id]
+    end
+
+    def edit; end
+
+    def create
+      @category_variant = @category.category_variants.new(variant_params)
+
+      if @category_variant.save
+        redirect_to category_variants_path(@category), notice: "Translation was successfully created."
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def update
+      if @category_variant.update(variant_params)
+        redirect_to category_variants_path(@category), notice: "Translation was successfully updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @category_variant.destroy
+      redirect_to category_variants_path(@category), notice: "Translation was successfully deleted."
+    end
+
+    private
+
+    def load_category
+      @category = Postnhost::Category.find(params[:category_id])
+    end
+
+    def load_category_variant
+      @category_variant = @category.category_variants.find(params[:id])
+    end
+
+    def ensure_variant_editable
+      return unless @category_variant.generating?
+
+      redirect_to category_variants_path(@category),
+                  alert: "This translation is still in progress. You can edit it when it finishes."
+    end
+
+    def variant_params
+      params.require(:category_variant).permit(:name, :meta_description, :language_id)
+    end
+  end
+end

data/app/controllers/postnhost/languages_controller.rb

@@ -0,0 +1,66 @@
+module Postnhost
+  class LanguagesController < ApplicationController
+    PAGE_SIZE = 15
+
+    before_action :authenticate_user!
+    before_action :load_language, only: %i[show edit update destroy]
+    layout "postnhost/product"
+
+    def index
+      @languages = Postnhost::Language.order(updated_at: :desc)
+    end
+
+    def show
+      articles = @language.articles.includes(:article_snapshot, :categories).order(created_at: :desc)
+      article_variants = @language.article_variants.includes(:article).order(created_at: :desc)
+
+      @articles_pagy, @articles = pagy(:offset, articles, limit: PAGE_SIZE, page_key: "articles_page")
+      @article_variants_pagy, @article_variants = pagy(
+        :offset,
+        article_variants,
+        limit: PAGE_SIZE,
+        page_key: "article_variants_page"
+      )
+    end
+
+    def new
+      @language = Postnhost::Language.new
+    end
+
+    def edit; end
+
+    def create
+      @language = Postnhost::Language.new
+      @language.assign_attributes(language_params)
+
+      if @language.save
+        redirect_to @language
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def update
+      if @language.update(language_params)
+        redirect_to languages_url, notice: "Language was successfully updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @language.destroy
+      redirect_to languages_url, notice: "Language was successfully deleted."
+    end
+
+    private
+
+    def load_language
+      @language = Postnhost::Language.find(params[:id])
+    end
+
+    def language_params
+      params.require(:language).permit(:name, :html_lang, :default)
+    end
+  end
+end

data/app/controllers/postnhost/onboarding_controller.rb

@@ -0,0 +1,70 @@
+module Postnhost
+  class OnboardingController < ApplicationController
+    include Postnhost::Onboarding::AccessControl
+    include Postnhost::Onboarding::StepAssignment
+
+    layout "postnhost/application"
+
+    before_action :ensure_onboarding_allowed!
+    before_action :synchronize_onboarding_session
+
+    def show
+      @post_install_checklist = post_install_checklist_mode?
+      return if @post_install_checklist
+
+      @step = current_step
+      load_step_assignments
+    end
+
+    def update
+      handle_step_result(Postnhost::Onboarding::StepProcessor.call(params:, session:))
+    end
+
+    private
+
+    def handle_step_result(result)
+      payload = result.value || {}
+
+      case result.status
+      when :redirect_onboarding then redirect_to_onboarding(payload[:alert])
+      when :redirect_new_session then redirect_to postnhost.new_session_path, alert: payload[:alert]
+      when :render_show then render_step(payload:, result:)
+      when :finish_setup then finish_setup(payload.fetch(:user))
+      when :redirect_articles then redirect_to postnhost.articles_path
+      else redirect_to_onboarding("Invalid onboarding response.")
+      end
+    end
+
+    def redirect_to_onboarding(alert = nil)
+      if alert.present?
+        redirect_to postnhost.onboarding_path, alert:
+      else
+        redirect_to postnhost.onboarding_path
+      end
+    end
+
+    def render_step(payload:, result:)
+      assign_step_payload(payload)
+      flash.now[:alert] = payload[:alert] || result.errors.first if payload[:alert].present? || result.errors.first.present?
+      render :show, status: :unprocessable_content
+    end
+
+    def assign_step_payload(payload)
+      @step = payload[:step] if payload.key?(:step)
+      @user = payload[:user] if payload.key?(:user)
+      @language_options = payload[:language_options] if payload.key?(:language_options)
+      @selected_language_locales = payload[:selected_language_locales] if payload.key?(:selected_language_locales)
+      @selected_default_locale = payload[:selected_default_locale] if payload.key?(:selected_default_locale)
+      @locale = payload[:locale] if payload.key?(:locale)
+      @site_url = payload[:site_url] if payload.key?(:site_url)
+      @site_indexing = payload[:site_indexing] if payload.key?(:site_indexing)
+      @site_copy = payload[:site_copy] if payload.key?(:site_copy)
+    end
+
+    def finish_setup(user)
+      sign_in(user)
+      session[:onboarding_post_install_checklist] = true
+      redirect_to postnhost.onboarding_path(post_install: "1")
+    end
+  end
+end