not_pressed-core 0.1.0

data/app/controllers/not_pressed/admin/media_attachments_controller.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    class MediaAttachmentsController < BaseController
+      PER_PAGE = 25
+
+      before_action :set_media_attachment, only: %i[edit update destroy]
+
+      def picker
+        @media = NotPressed::MediaAttachment.images.recent.limit(50)
+        render partial: "picker", layout: false
+      end
+
+      def index
+        page_title "Media Library"
+        @media = filtered_media
+                   .recent
+                   .limit(PER_PAGE)
+                   .offset(page_offset)
+        @total_count = filtered_media.count
+        @current_page = current_page
+        @total_pages = (@total_count.to_f / PER_PAGE).ceil
+      end
+
+      def create
+        files = Array(params[:files])
+
+        files.each do |file|
+          attachment = NotPressed::MediaAttachment.new
+          attachment.file.attach(file)
+          attachment.title = file.original_filename.sub(/\.[^.]+\z/, "").titleize
+          attachment.save
+        end
+
+        redirect_to admin_media_attachments_path, notice: "Media uploaded successfully."
+      end
+
+      def edit
+        page_title "Edit Media: #{@media_attachment.title}"
+      end
+
+      def update
+        if @media_attachment.update(media_attachment_params)
+          redirect_to edit_admin_media_attachment_path(@media_attachment), notice: "Media updated successfully."
+        else
+          page_title "Edit Media: #{@media_attachment.title}"
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @media_attachment.destroy
+        redirect_to admin_media_attachments_path, notice: "Media deleted successfully."
+      end
+
+      private
+
+      def filtered_media
+        scope = NotPressed::MediaAttachment.all
+
+        case params[:type]
+        when "images"
+          scope = scope.images
+        when "documents"
+          scope = scope.documents
+        end
+
+        if params[:q].present?
+          query = "%#{params[:q]}%"
+          scope = scope.where("title LIKE :q OR alt_text LIKE :q", q: query)
+        end
+
+        scope
+      end
+
+      def current_page
+        [(params[:page] || 1).to_i, 1].max
+      end
+
+      def page_offset
+        (current_page - 1) * PER_PAGE
+      end
+
+      def set_media_attachment
+        @media_attachment = NotPressed::MediaAttachment.find(params[:id])
+      end
+
+      def media_attachment_params
+        params.require(:media_attachment).permit(:title, :alt_text)
+      end
+    end
+  end
+end

data/app/controllers/not_pressed/admin/pages_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    class PagesController < BaseController
+      before_action :set_page, only: %i[edit update destroy preview duplicate]
+
+      def index
+        page_title "Pages"
+        @pages = NotPressed::Page.roots.ordered.includes(children: :children)
+      end
+
+      def new
+        page_title "New Page"
+        @page = NotPressed::Page.new
+      end
+
+      def create
+        @page = NotPressed::Page.new(page_params)
+
+        if @page.save
+          redirect_to edit_admin_page_path(@page), notice: "Page created successfully."
+        else
+          page_title "New Page"
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+        page_title "Edit: #{@page.title}"
+        @blocks = @page.content_blocks.ordered
+        @versions = @page.page_versions.ordered.limit(10)
+      end
+
+      def update
+        if @page.update(page_params)
+          redirect_to edit_admin_page_path(@page), notice: "Page updated successfully."
+        else
+          page_title "Edit: #{@page.title}"
+          @blocks = @page.content_blocks.ordered
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def preview
+        render layout: false
+      end
+
+      def duplicate
+        new_page = NotPressed::Page.new(
+          title: "#{@page.title} (Copy)",
+          status: :draft,
+          content_type: @page.content_type,
+          meta_description: @page.meta_description,
+          parent_id: @page.parent_id,
+          position: @page.position + 1
+        )
+
+        if new_page.save
+          @page.content_blocks.ordered.each do |block|
+            new_page.content_blocks.create!(
+              block_type: block.block_type,
+              content: block.content,
+              position: block.position
+            )
+          end
+
+          redirect_to edit_admin_page_path(new_page), notice: "Page duplicated successfully."
+        else
+          redirect_to admin_pages_path, alert: "Failed to duplicate page."
+        end
+      end
+
+      def reorder
+        entries = params.permit(pages: [:id, :position, :parent_id]).fetch(:pages, [])
+
+        ActiveRecord::Base.transaction do
+          entries.each do |entry|
+            page = NotPressed::Page.find_by(id: entry[:id])
+            next unless page
+
+            new_parent_id = entry[:parent_id].presence
+            if new_parent_id.present?
+              next if new_parent_id.to_i == page.id
+              next if descendant_ids(page).include?(new_parent_id.to_i)
+            end
+
+            page.update!(position: entry[:position], parent_id: new_parent_id)
+          end
+        end
+
+        head :ok
+      end
+
+      def destroy
+        @page.destroy
+        redirect_to admin_pages_path, notice: "Page deleted successfully."
+      end
+
+      private
+
+      def set_page
+        @page = NotPressed::Page.find(params[:id])
+      end
+
+      def descendant_ids(page)
+        ids = []
+        children = page.children.to_a
+        while children.any?
+          child = children.shift
+          ids << child.id
+          children.concat(child.children.to_a)
+        end
+        ids
+      end
+
+      def page_params
+        params.require(:page).permit(:title, :slug, :status, :meta_description, :content_type, :parent_id, :position, :scheduled_at, :meta_title, :og_image_url, :layout, :visibility, :page_password, :canonical_url, :meta_robots, :og_type, :twitter_card, :head_code, :body_code, :category_id, tag_ids: [])
+      end
+    end
+  end
+end

data/app/controllers/not_pressed/admin/plugins_controller.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    class PluginsController < BaseController
+      before_action :set_plugin, only: [:show, :toggle, :update_settings]
+
+      def index
+        page_title "Plugins"
+        @plugins = NotPressed::PluginManager.registered
+      end
+
+      def export
+        info = NotPressed::PluginManager.find(params[:id])
+        plugin_name = info[:klass].plugin_name
+
+        temp_dir = Dir.mktmpdir("np_plugin_export")
+        zip_path = NotPressed::PluginPackager.new(plugin_name).package(temp_dir)
+
+        send_file zip_path,
+                  type: "application/zip",
+                  disposition: "attachment",
+                  filename: File.basename(zip_path)
+
+        # Schedule cleanup after response is sent
+        response.headers["X-Temp-Dir"] = temp_dir
+      rescue NotPressed::PluginManager::NotFound
+        redirect_to admin_plugins_path, alert: "Plugin not found."
+      end
+
+      def import
+        unless params[:plugin_archive].present?
+          redirect_to admin_plugins_path, alert: "Please select a plugin archive to import."
+          return
+        end
+
+        temp_file = Tempfile.new(["plugin_import", ".zip"])
+        temp_file.binmode
+        temp_file.write(params[:plugin_archive].read)
+        temp_file.close
+
+        result = NotPressed::PluginImporter.new(temp_file.path).import!
+        redirect_to admin_plugins_path, notice: "Plugin '#{result[:name]}' v#{result[:version]} imported successfully."
+      rescue NotPressed::PluginImporter::InvalidArchive => e
+        redirect_to admin_plugins_path, alert: "Import failed: #{e.message}"
+      rescue NotPressed::PluginImporter::DuplicatePlugin => e
+        redirect_to admin_plugins_path, alert: "Import failed: #{e.message}"
+      ensure
+        temp_file&.unlink
+      end
+
+      def show
+        page_title @plugin_class.plugin_name
+      end
+
+      def toggle
+        name = @plugin_class.plugin_name
+        if NotPressed::PluginManager.enabled?(name)
+          NotPressed::PluginManager.disable(name)
+          redirect_to admin_plugin_path(plugin_name: name), notice: "Plugin '#{name}' has been disabled."
+        else
+          NotPressed::PluginManager.enable(name)
+          redirect_to admin_plugin_path(plugin_name: name), notice: "Plugin '#{name}' has been enabled."
+        end
+      rescue NotPressed::PluginManager::DependencyError => e
+        redirect_to admin_plugin_path(plugin_name: name), alert: e.message
+      end
+
+      def update_settings
+        name = @plugin_class.plugin_name
+        schema = @plugin_class.plugin_settings_schema || []
+        instance = plugin_instance
+
+        errors = []
+        schema.each do |field|
+          key = field[:key].to_s
+          value = params.dig(:plugin_settings, key)
+
+          if field[:required] && (value.nil? || value.to_s.strip.empty?)
+            errors << "#{field[:label] || key.humanize} is required"
+            next
+          end
+
+          value = cast_setting_value(value, field[:type])
+          instance.set_setting(key, value)
+        end
+
+        if errors.any?
+          redirect_to admin_plugin_path(plugin_name: name), alert: errors.join(", ")
+        else
+          redirect_to admin_plugin_path(plugin_name: name), notice: "Settings saved successfully."
+        end
+      end
+
+      private
+
+      def set_plugin
+        info = NotPressed::PluginManager.find(params[:plugin_name])
+        @plugin_class = info[:klass]
+        @plugin_info = info
+      rescue NotPressed::PluginManager::NotFound
+        redirect_to admin_plugins_path, alert: "Plugin not found."
+      end
+
+      def plugin_instance
+        @plugin_info[:instance] || @plugin_class.new
+      end
+
+      def cast_setting_value(value, type)
+        case type
+        when :boolean
+          value == "1" || value == "true"
+        when :integer
+          value.to_s.strip.empty? ? nil : value.to_i
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/app/controllers/not_pressed/admin/settings_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    class SettingsController < BaseController
+      def code_injection
+        page_title "Code Injection"
+        @global_head_code = NotPressed::Setting.get("global_head_code") || ""
+        @global_body_code = NotPressed::Setting.get("global_body_code") || ""
+      end
+
+      def update_code_injection
+        NotPressed::Setting.set("global_head_code", params[:global_head_code])
+        NotPressed::Setting.set("global_body_code", params[:global_body_code])
+        redirect_to code_injection_admin_settings_path, notice: "Code injection settings saved."
+      end
+    end
+  end
+end

data/app/controllers/not_pressed/admin/tags_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    class TagsController < BaseController
+      def index
+        page_title "Tags"
+        @tags = NotPressed::Tag.order(:name)
+        @tag = NotPressed::Tag.new
+      end
+
+      def create
+        @tag = NotPressed::Tag.new(tag_params)
+
+        if @tag.save
+          redirect_to admin_tags_path, notice: "Tag created successfully."
+        else
+          page_title "Tags"
+          @tags = NotPressed::Tag.order(:name)
+          render :index, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @tag = NotPressed::Tag.find(params[:id])
+        @tag.destroy
+        redirect_to admin_tags_path, notice: "Tag deleted successfully."
+      end
+
+      private
+
+      def tag_params
+        params.require(:tag).permit(:name)
+      end
+    end
+  end
+end

data/app/controllers/not_pressed/admin/themes_controller.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Admin
+    class ThemesController < BaseController
+      before_action :set_theme, only: [:show, :activate, :deactivate, :update_colors]
+
+      def index
+        page_title "Themes"
+        @themes = NotPressed::ThemeRegistry.available.map { |name| [name, NotPressed::ThemeRegistry.find(name)] }
+        @active_theme = NotPressed::ThemeRegistry.active
+      end
+
+      def show
+        page_title @theme_class.plugin_name
+        @colors = @theme_class.theme_color_scheme
+        @color_values = load_color_values
+      end
+
+      def activate
+        name = @theme_class.plugin_name
+        NotPressed::ThemeRegistry.activate(name)
+        redirect_to admin_themes_path, notice: "Theme '#{name}' has been activated."
+      end
+
+      def deactivate
+        NotPressed::ThemeRegistry.deactivate
+        redirect_to admin_themes_path, notice: "Theme has been deactivated."
+      end
+
+      def update_colors
+        name = @theme_class.plugin_name
+        colors = @theme_class.theme_color_scheme
+
+        colors.each do |color|
+          key = "theme.#{name}.color_#{color[:key]}"
+          value = params.dig(:theme_colors, color[:key].to_s)
+          if value.present?
+            NotPressed::Setting.set(key, value)
+          end
+        end
+
+        redirect_to admin_theme_path(theme_name: name), notice: "Colors saved successfully."
+      end
+
+      def export
+        info = NotPressed::ThemeRegistry.find(params[:id])
+        theme_name = info[:klass].plugin_name
+
+        temp_dir = Dir.mktmpdir("np_theme_export")
+        zip_path = NotPressed::ThemePackager.new(theme_name).package(temp_dir)
+
+        send_file zip_path,
+                  type: "application/zip",
+                  disposition: "attachment",
+                  filename: File.basename(zip_path)
+
+        # Schedule cleanup after response is sent
+        response.headers["X-Temp-Dir"] = temp_dir
+      rescue NotPressed::ThemeRegistry::NotFound
+        redirect_to admin_themes_path, alert: "Theme not found."
+      end
+
+      def import
+        unless params[:theme_archive].present?
+          redirect_to admin_themes_path, alert: "Please select a theme archive to import."
+          return
+        end
+
+        temp_file = Tempfile.new(["theme_import", ".zip"])
+        temp_file.binmode
+        temp_file.write(params[:theme_archive].read)
+        temp_file.close
+
+        result = NotPressed::ThemeImporter.new(temp_file.path).import!
+        redirect_to admin_themes_path, notice: "Theme '#{result[:name]}' v#{result[:version]} imported successfully."
+      rescue NotPressed::ThemeImporter::InvalidArchive => e
+        redirect_to admin_themes_path, alert: "Import failed: #{e.message}"
+      rescue NotPressed::ThemeImporter::DuplicateTheme => e
+        redirect_to admin_themes_path, alert: "Import failed: #{e.message}"
+      ensure
+        temp_file&.unlink
+      end
+
+      private
+
+      def set_theme
+        info = NotPressed::ThemeRegistry.find(params[:theme_name])
+        @theme_class = info[:klass]
+        @theme_info = info
+      rescue NotPressed::ThemeRegistry::NotFound
+        redirect_to admin_themes_path, alert: "Theme not found."
+      end
+
+      def load_color_values
+        name = @theme_class.plugin_name
+        @theme_class.theme_color_scheme.each_with_object({}) do |color, hash|
+          key = "theme.#{name}.color_#{color[:key]}"
+          hash[color[:key]] = NotPressed::Setting.get(key) || color[:default]
+        end
+      end
+    end
+  end
+end

data/app/controllers/not_pressed/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/not_pressed/blog_controller.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class BlogController < ApplicationController
+    include NotPressed::ContentHelper
+
+    layout :resolve_layout
+
+    def index
+      @page_num = [params.fetch(:page, 1).to_i, 1].max
+      @posts = blog_posts.order(published_at: :desc).limit(12).offset((@page_num - 1) * 12)
+      @total_count = blog_posts.count
+    end
+
+    def show
+      @post = blog_posts.find_by!(slug: params[:slug])
+      @prev_post = blog_posts.where("published_at < ?", @post.published_at).order(published_at: :desc).first
+      @next_post = blog_posts.where("published_at > ?", @post.published_at).order(published_at: :asc).first
+    rescue ActiveRecord::RecordNotFound
+      redirect_to not_pressed.blog_path
+    end
+
+    def category
+      @category = NotPressed::Category.find_by!(slug: params[:slug])
+      @page_num = [params.fetch(:page, 1).to_i, 1].max
+      @posts = blog_posts.where(category: @category).order(published_at: :desc).limit(12).offset((@page_num - 1) * 12)
+      @total_count = blog_posts.where(category: @category).count
+      render :index
+    rescue ActiveRecord::RecordNotFound
+      redirect_to not_pressed.blog_path
+    end
+
+    def tag
+      @tag = NotPressed::Tag.find_by!(slug: params[:slug])
+      @page_num = [params.fetch(:page, 1).to_i, 1].max
+      @posts = blog_posts.joins(:taggings).where(not_pressed_taggings: { tag_id: @tag.id }).order(published_at: :desc).limit(12).offset((@page_num - 1) * 12)
+      @total_count = blog_posts.joins(:taggings).where(not_pressed_taggings: { tag_id: @tag.id }).count
+      render :index
+    rescue ActiveRecord::RecordNotFound
+      redirect_to not_pressed.blog_path
+    end
+
+    def archive
+      @year = params[:year].to_i
+      @month = params[:month]&.to_i
+      @page_num = [params.fetch(:page, 1).to_i, 1].max
+
+      scope = blog_posts.where("EXTRACT(YEAR FROM published_at) = ?", @year)
+      scope = scope.where("EXTRACT(MONTH FROM published_at) = ?", @month) if @month
+
+      @posts = scope.order(published_at: :desc).limit(12).offset((@page_num - 1) * 12)
+      @total_count = scope.count
+      render :index
+    end
+
+    def feed
+      @posts = blog_posts.order(published_at: :desc).limit(20)
+      respond_to do |format|
+        format.rss { render layout: false }
+      end
+    end
+
+    private
+
+    def blog_posts
+      NotPressed::Page.blog_posts.published
+    end
+
+    def resolve_layout
+      return false if action_name == "feed"
+
+      theme = NotPressed::ThemeRegistry.active
+      if theme
+        primary = theme.primary_layout
+        primary ? "not_pressed/#{primary[:name]}" : "not_pressed/page"
+      else
+        "not_pressed/page"
+      end
+    rescue ActionView::MissingTemplate
+      "not_pressed/page"
+    end
+  end
+end

data/app/controllers/not_pressed/form_submissions_controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class FormSubmissionsController < ApplicationController
+    def create
+      @form = NotPressed::Form.find_by(slug: params[:form_slug])
+
+      unless @form
+        render plain: "Form not found", status: :not_found
+        return
+      end
+
+      unless @form.status_active?
+        render plain: "This form is not currently accepting submissions", status: :gone
+        return
+      end
+
+      data = build_submission_data
+      @submission = @form.form_submissions.build(data: data)
+
+      if @submission.save
+        send_notification_email(@submission)
+
+        if @form.redirect_url.present?
+          redirect_to @form.redirect_url, allow_other_host: true
+        else
+          render inline: thank_you_html(@form), layout: false
+        end
+      else
+        render plain: "There was an error processing your submission", status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def build_submission_data
+      submission_params = params[:submission] || {}
+      data = {}
+
+      @form.form_fields.ordered.each do |field|
+        key = field.label.parameterize(separator: "_")
+        value = submission_params[key]
+        data[field.label] = value.is_a?(Array) ? value.join(", ") : value.to_s
+      end
+
+      data
+    end
+
+    def send_notification_email(submission)
+      return unless submission.form.email_recipient.present?
+
+      NotPressed::FormMailer.submission_notification(submission).deliver_later
+    end
+
+    def thank_you_html(form)
+      message = ERB::Util.html_escape(form.success_message)
+      <<~HTML
+        <!DOCTYPE html>
+        <html>
+        <head><title>Thank You</title></head>
+        <body>
+          <div class="np-form-thank-you">
+            <p>#{message}</p>
+          </div>
+        </body>
+        </html>
+      HTML
+    end
+  end
+end

data/app/controllers/not_pressed/pages_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module NotPressed
+  class PagesController < ApplicationController
+    layout :resolve_layout
+
+    def show
+      @page = NotPressed::Page.published.find_by!(slug: params[:slug])
+    rescue ActiveRecord::RecordNotFound
+      render plain: "Not Found", status: :not_found
+    end
+
+    private
+
+    def resolve_layout
+      theme = NotPressed::ThemeRegistry.active
+      if theme
+        page_layout = @page&.layout
+        if page_layout.present? && page_layout != "default"
+          "not_pressed/#{page_layout}"
+        else
+          primary = theme.primary_layout
+          primary ? "not_pressed/#{primary[:name]}" : "not_pressed/page"
+        end
+      else
+        if @page&.layout.present? && @page.layout != "default"
+          "not_pressed/#{@page.layout}"
+        else
+          "not_pressed/page"
+        end
+      end
+    rescue ActionView::MissingTemplate
+      "not_pressed/page"
+    end
+  end
+end