panda-core 0.12.5 → 1.1.0

data/app/controllers/panda/core/admin/files_controller.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      class FilesController < ::Panda::Core::Admin::BaseController
+        before_action :set_initial_breadcrumb, only: [:index]
+        before_action :set_blob, only: [:show, :update, :destroy]
+
+        def index
+          # Exclude variant blobs — they are attached to VariantRecord, not user-uploaded
+          variant_blob_ids = ActiveStorage::Attachment
+            .where(record_type: "ActiveStorage::VariantRecord")
+            .select(:blob_id)
+
+          @files = ActiveStorage::Blob
+            .where.not(id: variant_blob_ids)
+            .includes(:variant_records)
+            .order(created_at: :desc)
+
+          @file_categories = Panda::Core::FileCategory.ordered
+          @active_category = params[:category]
+
+          # Apply category filter
+          if @active_category == "uncategorized"
+            categorized_blob_ids = Panda::Core::FileCategorization.select(:blob_id)
+            @files = @files.where.not(id: categorized_blob_ids)
+          elsif @active_category.present?
+            category = Panda::Core::FileCategory.find_by(slug: @active_category)
+            if category
+              blob_ids = Panda::Core::FileCategorization.where(file_category: category).select(:blob_id)
+              @files = @files.where(id: blob_ids)
+            end
+          end
+
+          # Preload category names for gallery display
+          categorizations = Panda::Core::FileCategorization
+            .where(blob_id: @files.select(:id))
+            .includes(:file_category)
+          @blob_categories = categorizations.each_with_object({}) do |cat, hash|
+            hash[cat.blob_id] = cat.file_category
+          end
+        end
+
+        def show
+          @file_categories = Panda::Core::FileCategory.ordered
+
+          if request.xhr? || request.headers["Turbo-Frame"].present?
+            render partial: "file_details", locals: {file: @blob, file_categories: @file_categories}
+          else
+            redirect_to admin_files_path
+          end
+        end
+
+        def create
+          # JSON uploads from EditorJS
+          if params[:image].present?
+            return create_from_editor
+          end
+
+          # File uploads from EditorJS AttachesTool
+          if params[:file].present?
+            return create_file_from_editor
+          end
+
+          # HTML form uploads from the file gallery
+          file = params.dig(:file_upload, :file)
+          category_id = params.dig(:file_upload, :file_category_id)
+
+          if file.blank?
+            redirect_to admin_files_path, alert: "Please select a file to upload."
+            return
+          end
+
+          if category_id.blank?
+            redirect_to admin_files_path, alert: "Please select a category."
+            return
+          end
+
+          unless (category = Panda::Core::FileCategory.find_by(id: category_id))
+            redirect_to admin_files_path, alert: "Selected category not found."
+            return
+          end
+
+          blob = find_existing_blob(file) || ActiveStorage::Blob.create_and_upload!(
+            io: file,
+            filename: file.original_filename,
+            content_type: file.content_type
+          )
+
+          stamp_uploader(blob)
+
+          Panda::Core::FileCategorization.find_or_create_by!(file_category: category, blob: blob)
+
+          redirect_to admin_files_path, notice: "File uploaded successfully."
+        end
+
+        def update
+          blob_params = params.require(:blob).permit(:filename, :description, :file_category_id)
+
+          # Update filename — always re-append the original extension
+          new_filename = blob_params[:filename].to_s.strip
+          if new_filename.present?
+            original_ext = File.extname(@blob.filename.to_s)
+            new_filename += original_ext if File.extname(new_filename).blank? && original_ext.present?
+            @blob.filename = new_filename
+          end
+
+          # Update description in metadata
+          metadata = @blob.metadata || {}
+          metadata["description"] = blob_params[:description].to_s.strip
+          @blob.metadata = metadata
+
+          @blob.save!
+          update_file_category(blob_params[:file_category_id])
+
+          @file_categories = Panda::Core::FileCategory.ordered
+          locals = {file: @blob, file_categories: @file_categories, notice: "File updated successfully."}
+          respond_to do |format|
+            format.turbo_stream do
+              render turbo_stream: turbo_stream.update(
+                "file-gallery-slideover-content",
+                partial: "file_details",
+                locals: locals
+              )
+            end
+            format.html do
+              redirect_to admin_files_path, notice: "File updated successfully.", status: :see_other
+            end
+          end
+        end
+
+        def destroy
+          # Remove variant records and their blobs first (each variant has its own blob)
+          @blob.variant_records.includes(image_attachment: :blob).find_each do |vr|
+            vr.image.purge_later if vr.image.attached?
+            vr.destroy
+          end
+
+          # Remove remaining FK references before purging the blob
+          ActiveStorage::Attachment.where(blob_id: @blob.id).delete_all
+          Panda::Core::FileCategorization.where(blob_id: @blob.id).delete_all
+          @blob.purge_later
+
+          redirect_to admin_files_path, notice: "File was successfully deleted.", status: :see_other
+        end
+
+        private
+
+        def set_blob
+          @blob = ActiveStorage::Blob.find(params[:id])
+        end
+
+        def set_initial_breadcrumb
+          add_breadcrumb "Files", admin_files_path
+        end
+
+        def create_from_editor
+          file = params[:image]
+          return render json: {success: 0} unless file
+
+          blob = find_existing_blob(file) || ActiveStorage::Blob.create_and_upload!(
+            io: file,
+            filename: file.original_filename,
+            content_type: file.content_type
+          )
+
+          stamp_uploader(blob)
+
+          render json: {
+            success: true,
+            file: {
+              url: Rails.application.routes.url_helpers.rails_blob_url(blob, only_path: true),
+              name: blob.filename.to_s,
+              size: blob.byte_size,
+              signed_id: blob.signed_id
+            }
+          }
+        end
+
+        def create_file_from_editor
+          file = params[:file]
+          return render json: {success: 0} unless file
+
+          blob = find_existing_blob(file) || ActiveStorage::Blob.create_and_upload!(
+            io: file,
+            filename: file.original_filename,
+            content_type: file.content_type
+          )
+
+          stamp_uploader(blob)
+
+          extension = File.extname(blob.filename.to_s).delete_prefix(".")
+
+          render json: {
+            success: 1,
+            file: {
+              url: Rails.application.routes.url_helpers.rails_blob_url(blob, only_path: true),
+              name: blob.filename.to_s,
+              size: blob.byte_size,
+              extension: extension,
+              signed_id: blob.signed_id
+            }
+          }
+        end
+
+        def find_existing_blob(file)
+          checksum = Digest::MD5.file(file.tempfile.path).base64digest
+          ActiveStorage::Blob.find_by(checksum: checksum, byte_size: file.size)
+        end
+
+        def stamp_uploader(blob)
+          return unless current_user
+          metadata = blob.metadata || {}
+          metadata["uploaded_by_id"] = current_user.id
+          metadata["uploaded_by_name"] = current_user.name
+          blob.update_column(:metadata, metadata)
+        end
+
+        def update_file_category(category_id)
+          Panda::Core::FileCategorization.where(blob_id: @blob.id).destroy_all
+          return if category_id.blank?
+
+          category = Panda::Core::FileCategory.find_by(id: category_id)
+          Panda::Core::FileCategorization.create!(file_category: category, blob: @blob) if category
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/import_sessions_controller.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      class ImportSessionsController < BaseController
+        before_action :set_initial_breadcrumb
+        before_action :set_import_session, only: %i[show column_map update_mapping preview import]
+
+        def index
+          @import_sessions = scoped_import_sessions.recent
+          @import_sessions = @import_sessions.where(importable_type: params[:type]) if params[:type].present?
+        end
+
+        def new
+          @importable_type = params[:importable_type]
+        end
+
+        def create
+          tenant = resolve_tenant
+          uploaded_file = params[:import_file]
+
+          unless uploaded_file.present?
+            @importable_type = params[:importable_type]
+            flash.now[:error] = "Please select a file to upload."
+            render :new, status: :unprocessable_entity
+            return
+          end
+
+          if FileParser.xls?(uploaded_file.original_filename)
+            @importable_type = params[:importable_type]
+            flash.now[:error] = "XLS format is not supported. Please save your spreadsheet as XLSX, CSV, or TSV and try again."
+            render :new, status: :unprocessable_entity
+            return
+          end
+
+          unless FileParser.supported?(uploaded_file.original_filename)
+            @importable_type = params[:importable_type]
+            flash.now[:error] = "Unsupported file format. Please upload a CSV, TSV, or XLSX file."
+            render :new, status: :unprocessable_entity
+            return
+          end
+
+          @import_session = ImportSession.new(
+            importable_type: params[:importable_type],
+            user: current_user,
+            tenant: tenant,
+            status: "mapping"
+          )
+
+          if uploaded_file.present?
+            @import_session.import_file.attach(uploaded_file)
+          end
+
+          if @import_session.save
+            redirect_to column_map_admin_import_session_path(@import_session)
+          else
+            @importable_type = params[:importable_type]
+            render :new, status: :unprocessable_entity
+          end
+        end
+
+        def show
+        end
+
+        def column_map
+          @headers = @import_session.file_headers
+          @field_options = @import_session.column_options
+        end
+
+        def update_mapping
+          mapping = {}
+          (params[:mapping] || {}).each do |csv_col, field_name|
+            mapping[csv_col] = field_name if field_name.present?
+          end
+
+          @import_session.update!(column_mapping: mapping, status: "previewing")
+          redirect_to preview_admin_import_session_path(@import_session)
+        end
+
+        def preview
+          @preview_rows = @import_session.preview_rows(limit: 5)
+          @mapping = @import_session.column_mapping
+          @field_definitions = @import_session.column_options
+        end
+
+        def import
+          @import_session.update!(status: "importing")
+
+          # Run synchronously for now — swap to CSVImportJob.perform_later for async
+          CSVImportService.new(@import_session).call
+
+          redirect_to admin_import_session_path(@import_session), success: "Import complete."
+        rescue => e
+          redirect_to admin_import_session_path(@import_session), error: "Import failed: #{e.message}"
+        end
+
+        private
+
+        def set_import_session
+          @import_session = scoped_import_sessions.find(params[:id])
+        end
+
+        def set_initial_breadcrumb
+          add_breadcrumb "Import", admin_import_sessions_path
+        end
+
+        def scoped_import_sessions
+          tenant = resolve_tenant
+          tenant ? ImportSession.where(tenant: tenant) : ImportSession.where(tenant_type: nil)
+        end
+
+        def resolve_tenant
+          return ActsAsTenant.current_tenant if defined?(ActsAsTenant) && ActsAsTenant.current_tenant
+          nil
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/my_profile/logins_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      module MyProfile
+        class LoginsController < BaseController
+          before_action :set_initial_breadcrumb
+
+          def show
+            render :show, locals: {user: current_user}
+          end
+
+          private
+
+          def set_initial_breadcrumb
+            add_breadcrumb "My Profile", edit_admin_my_profile_path
+            add_breadcrumb "Login & Security", admin_my_profile_logins_path
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/my_profile_controller.rb

@@ -24,7 +24,11 @@ module Panda
         # @type PATCH/PUT
         # @return void
         def update
+          purge_old_avatar_if_replacing
+
           if current_user.update(user_params)
+            rename_avatar_blob
+            clear_oauth_avatar_url_after_manual_upload
             flash[:success] = "Your profile has been updated successfully."
             redirect_to edit_admin_my_profile_path
           else
@@ -38,6 +42,33 @@ module Panda
           add_breadcrumb "My Profile", edit_admin_my_profile_path
         end
 
+        # Purge the existing avatar synchronously when a replacement is being uploaded.
+        # This ensures the old blob is fully removed (DB + storage) before the new
+        # one is attached, preventing orphaned blobs that show as "in use".
+        def purge_old_avatar_if_replacing
+          return unless params.dig(:user, :avatar).present? && current_user.avatar.attached?
+          current_user.avatar.purge
+        end
+
+        # Rename the avatar blob to a consistent "avatar-full-name.ext" format
+        # so it's identifiable in the file gallery.
+        def rename_avatar_blob
+          upload = params.dig(:user, :avatar)
+          return unless upload.present? && current_user.avatar.attached?
+
+          extension = File.extname(upload.original_filename)
+          new_filename = "avatar-#{current_user.name.parameterize}#{extension}"
+          current_user.avatar.blob.update!(filename: new_filename)
+        end
+
+        # Clear oauth_avatar_url when user manually uploads an avatar.
+        # This signals to find_or_create_from_auth_hash that the avatar
+        # was manually uploaded and should not be overwritten on OAuth re-login.
+        def clear_oauth_avatar_url_after_manual_upload
+          return unless params.dig(:user, :avatar).present?
+          current_user.update_column(:oauth_avatar_url, nil)
+        end
+
         # Only allow a list of trusted parameters through
         # @type private
         # @return ActionController::StrongParameters

data/app/controllers/panda/core/admin/search_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      class SearchController < ::Panda::Core::Admin::BaseController
+        def index
+          query = params[:q].to_s.strip
+          results = Panda::Core::SearchRegistry.admin_search(query, limit: 5)
+          render json: results
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/sessions_controller.rb

@@ -10,9 +10,14 @@ module Panda
         skip_before_action :authenticate_admin_user!, only: [:new, :create, :destroy, :failure]
 
         def new
-          # Only show providers that have valid credentials configured
-          @providers = Core.config.authentication_providers.select do |_key, config|
-            config[:client_id].present? && config[:client_secret].present?
+          providers = Core.config.resolved_authentication_providers(request)
+          @providers = providers.select do |key, config|
+            # Developer provider doesn't need credentials, only shown in development
+            if key.to_sym == :developer
+              Rails.env.development?
+            else
+              config[:client_id].present? && config[:client_secret].present?
+            end
           end.keys
         end
 
@@ -23,7 +28,8 @@ module Panda
           # Find the actual provider key (might be using path_name override)
           provider = find_provider_by_path(provider_path)
 
-          unless provider && Core.config.authentication_providers.key?(provider)
+          resolved = Core.config.resolved_authentication_providers(request)
+          unless provider && resolved.key?(provider)
             redirect_to admin_login_path, flash: {error: "Authentication provider not enabled"}
             return
           end
@@ -31,21 +37,69 @@ module Panda
           user = User.find_or_create_from_auth_hash(auth)
 
           if user.persisted?
-            # Check if user is admin before allowing access
-            unless user.admin?
+            # Per-login validation hook (e.g. email domain restrictions)
+            if Core.config.authentication_validator
+              validation_error = Core.config.authentication_validator.call(user, auth, request)
+              if validation_error
+                redirect_to admin_login_path, flash: {error: validation_error}
+                return
+              end
+            end
+
+            # Check if user is authorized to access the admin area.
+            # Admin users always have access. Non-admin users are checked
+            # via the configurable authorization_policy (e.g. role-based access
+            # from panda-cms-pro).
+            policy = Panda::Core.config.authorization_policy
+            unless user.admin? || policy.call(user, :access_admin, nil)
               flash[:error] = "You do not have permission to access the admin area"
               flash.keep(:error) if Rails.env.test?
               redirect_to admin_login_path
               return
             end
 
-            session[:user_id] = user.id
+            session[Panda::Core::ADMIN_SESSION_KEY] = user.id
             Panda::Core::Current.user = user
 
+            user.track_login!(request) if user.respond_to?(:track_login!)
+            Panda::Core::UserActivity.log!(user: user, action: "login", request: request) if defined?(Panda::Core::UserActivity)
+
             ActiveSupport::Notifications.instrument("panda.core.user_login",
               user: user,
               provider: provider)
 
+            # Consume stored redirect path once so it is cleared regardless of
+            # which redirect branch is taken below.
+            post_auth_path = session.delete(:post_auth_redirect_path)
+
+            # Post-authentication redirect hook (e.g. workspace picker).
+            # Wrapped in its own rescue so a broken hook falls through to the
+            # default redirect rather than hitting the outer rescue (which
+            # would redirect to login with the session already created).
+            if (redirect_proc = Panda::Core.config.post_authentication_redirect)
+              begin
+                redirect_url = redirect_proc.call(user, request)
+                if redirect_url.present?
+                  redirect_to append_admin_path_suffix(redirect_url, post_auth_path), allow_other_host: true, flash: {success: "Successfully logged in as #{user.name}"}
+                  return
+                end
+              rescue => e
+                Rails.logger.error "post_authentication_redirect hook failed: #{e.class}: #{e.message}"
+              end
+            end
+
+            # Redirect to originating subdomain if auth callback landed on root domain
+            origin = session.delete(:origin_subdomain)
+            if origin.present? && request.host.split(".").first != origin
+              scheme = request.scheme
+              base_domain = request.host.sub(/\A[^.]+\./, "")
+              port = request.port
+              port_suffix = [80, 443].include?(port) ? "" : ":#{port}"
+              base_url = "#{scheme}://#{origin}.#{base_domain}#{port_suffix}#{Core.config.admin_path}"
+              redirect_to append_admin_path_suffix(base_url, post_auth_path), allow_other_host: true, flash: {success: "Successfully logged in as #{user.name}"}
+              return
+            end
+
             # Use configured dashboard path or default to admin_root_path
             redirect_path = Panda::Core.config.dashboard_redirect_path || admin_root_path
             redirect_path = redirect_path.call if redirect_path.respond_to?(:call)
@@ -69,7 +123,7 @@ module Panda
         end
 
         def destroy
-          session.delete(:user_id)
+          session.delete(Panda::Core::ADMIN_SESSION_KEY)
           Panda::Core::Current.user = nil
 
           ActiveSupport::Notifications.instrument("panda.core.user_logout")
@@ -79,13 +133,33 @@ module Panda
 
         private
 
+        # Append the path segment that follows the admin prefix from +stored_path+
+        # to +base_url+.  Returns +base_url+ unchanged when there is no meaningful
+        # suffix (e.g. no stored path, or the stored path is the admin root itself).
+        #
+        # Example: base_url="https://workspace.example.com/admin", stored_path="/admin/users/123"
+        # → "https://workspace.example.com/admin/users/123"
+        def append_admin_path_suffix(base_url, stored_path)
+          return base_url if stored_path.blank?
+
+          admin_prefix = Core.config.admin_path
+          return base_url unless stored_path.start_with?(admin_prefix)
+
+          suffix = stored_path[admin_prefix.length..]
+          return base_url if suffix.blank? || suffix == "/"
+
+          base_url.chomp("/") + suffix
+        end
+
         # Find the provider key by path name (handles path_name override)
         def find_provider_by_path(provider_path)
+          providers = Core.config.resolved_authentication_providers(request)
+
           # First check if it's a direct match
-          return provider_path if Core.config.authentication_providers.key?(provider_path)
+          return provider_path if providers.key?(provider_path)
 
           # Then check if any provider has a matching path_name
-          Core.config.authentication_providers.each do |key, config|
+          providers.each do |key, config|
             return key if config[:path_name]&.to_sym == provider_path
           end
 

data/app/controllers/panda/core/admin/tags_controller.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      class TagsController < BaseController
+        before_action :set_initial_breadcrumb
+        before_action :set_tag, only: %i[edit update destroy]
+
+        def index
+          tenant = resolve_tenant
+          @tags = Tag.for_tenant(tenant).ordered
+
+          if params[:q].present?
+            @tags = @tags.search_by_name(params[:q])
+          end
+
+          respond_to do |format|
+            format.html
+            format.json { render json: @tags.limit(10).map { |t| {id: t.id, name: t.name, colour: t.display_colour} } }
+          end
+        end
+
+        def new
+          @tag = Tag.new
+        end
+
+        def create
+          tenant = resolve_tenant
+          @tag = Tag.new(tag_params.merge(tenant: tenant))
+
+          if @tag.save
+            redirect_to admin_tags_path, success: "Tag created."
+          else
+            render :new, status: :unprocessable_entity
+          end
+        end
+
+        def edit
+        end
+
+        def update
+          if @tag.update(tag_params)
+            redirect_to admin_tags_path, success: "Tag updated."
+          else
+            render :edit, status: :unprocessable_entity
+          end
+        end
+
+        def destroy
+          @tag.destroy
+          redirect_to admin_tags_path, success: "Tag deleted."
+        end
+
+        private
+
+        def set_tag
+          @tag = Tag.for_tenant(resolve_tenant).find(params[:id])
+        end
+
+        def tag_params
+          params.require(:tag).permit(:name, :colour)
+        end
+
+        def set_initial_breadcrumb
+          add_breadcrumb "Settings", admin_settings_path
+          add_breadcrumb "Tags", admin_tags_path
+        end
+
+        def resolve_tenant
+          return ActsAsTenant.current_tenant if defined?(ActsAsTenant) && ActsAsTenant.current_tenant
+          nil
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/test_sessions_controller.rb

@@ -18,19 +18,18 @@ module Panda
         def create
           user = Panda::Core::User.find(params[:user_id])
 
-          # Check if user is admin (mimics real OAuth behavior)
-          unless user.admin?
-            # Non-admin users are redirected to login with error (mimics real OAuth flow)
+          # Mirror real SessionsController: admin users always pass,
+          # non-admin users checked via authorization_policy
+          policy = Panda::Core.config.authorization_policy
+          unless user.admin? || policy.call(user, :access_admin, nil)
             flash[:alert] = "You do not have permission to access the admin area."
-            # Keep flash for one more request to survive redirect in tests
             flash.keep(:alert) if Rails.env.test?
-            # Use string path since route helpers aren't available in ActionController::Base
             redirect_to "#{Panda::Core.config.admin_path || "/admin"}/login", allow_other_host: false, status: :found
             return
           end
 
           # Set session (mimics real OAuth callback)
-          session[:user_id] = user.id
+          session[Panda::Core::ADMIN_SESSION_KEY] = user.id
           Panda::Core::Current.user = user
 
           # Support custom redirect path for test flexibility