panda-core 0.12.5 → 1.1.0

data/app/models/panda/core/user.rb

@@ -4,9 +4,19 @@ module Panda
   module Core
     class User < ApplicationRecord
       include HasUUID
+      include HasMetadata
+
+      metadata_field :internal, type: :boolean, filterable: true,
+        label: "Visibility", default_scope: :external,
+        filter_options: [["All Users", ""], ["Staff Users", "internal"], ["External Users", "external"]]
 
       self.table_name = "panda_core_users"
 
+      # Associations
+      has_many :user_activities, class_name: "Panda::Core::UserActivity", dependent: :destroy
+      has_many :user_sessions, class_name: "Panda::Core::UserSession", dependent: :destroy
+      belongs_to :invited_by, class_name: "Panda::Core::User", optional: true
+
       # Active Storage attachment for avatar with variants
       has_one_attached :avatar do |attachable|
         attachable.variant :thumb, resize_to_limit: [50, 50], preprocessed: true
@@ -29,30 +39,62 @@ module Panda
       scope :admins, -> {
         where(admin_column => true)
       }
+      scope :enabled, -> { where(enabled: true) }
+      scope :disabled, -> { where(enabled: false) }
+      scope :invited, -> { where.not(invitation_token: nil).where(invitation_accepted_at: nil) }
+      scope :active_recently, -> { where(last_login_at: 30.days.ago..) }
+      scope :search, ->(query) {
+        return all if query.blank?
+        where("name ILIKE :q OR email ILIKE :q", q: "%#{sanitize_sql_like(query)}%")
+      }
 
       def self.find_or_create_from_auth_hash(auth_hash)
         user = find_by(email: auth_hash.info.email.downcase)
 
-        # Handle avatar for both new and existing users
         avatar_url = auth_hash.info.image
         if user
-          # Update avatar if URL has changed or no avatar is attached
-          if avatar_url.present? && (avatar_url != user.oauth_avatar_url || !user.avatar.attached?)
-            AttachAvatarService.call(user: user, avatar_url: avatar_url)
+          has_stored_avatar = begin
+            user.avatar.attached?
+          rescue
+            false
+          end
+
+          if avatar_url.present?
+            # Update image_url with latest OAuth URL only if no local avatar is stored
+            user.update_column(:image_url, avatar_url) unless has_stored_avatar
+
+            # Skip OAuth avatar download when user has a manually uploaded avatar
+            # (indicated by oauth_avatar_url being nil while an avatar is attached)
+            manually_uploaded = has_stored_avatar && user.oauth_avatar_url.nil?
+            unless manually_uploaded
+              # Try to download and store avatar if URL changed or no avatar attached
+              if avatar_url != user.oauth_avatar_url || !has_stored_avatar
+                AttachAvatarService.call(user: user, avatar_url: avatar_url)
+              end
+            end
           end
           return user
         end
 
+        # Check if user creation is restricted (e.g. invite-only mode)
+        restrict = Panda::Core.config.restrict_user_creation
+        restricted = restrict.respond_to?(:call) ? restrict.call(auth_hash) : restrict
+        if restricted
+          user = new(email: auth_hash.info.email.downcase, name: auth_hash.info.name || "Unknown User")
+          user.errors.add(:base, "No account exists for this email address. Please contact your administrator.")
+          return user
+        end
+
         attributes = {
           :email => auth_hash.info.email.downcase,
           :name => auth_hash.info.name || "Unknown User",
-          :image_url => auth_hash.info.image,
+          :image_url => avatar_url,
           admin_column => User.count.zero? # First user is admin
         }
 
         user = create!(attributes)
 
-        # Attach avatar for new user
+        # Attach avatar for new user (will clear image_url on success)
         if avatar_url.present?
           AttachAvatarService.call(user: user, avatar_url: avatar_url)
         end
@@ -77,7 +119,42 @@ module Panda
       alias_method :is_admin=, :admin=
 
       def active_for_authentication?
-        true
+        enabled?
+      end
+
+      def enable!
+        update!(enabled: true)
+      end
+
+      def disable!
+        update!(enabled: false)
+      end
+
+      def enabled?
+        self[:enabled] != false
+      end
+
+      def invite!(invited_by:)
+        update!(
+          invitation_token: SecureRandom.urlsafe_base64(32),
+          invitation_sent_at: Time.current,
+          invited_by: invited_by
+        )
+      end
+
+      def accept_invitation!
+        update!(
+          invitation_accepted_at: Time.current,
+          invitation_token: nil
+        )
+      end
+
+      def track_login!(request)
+        update!(
+          last_login_at: Time.current,
+          last_login_ip: request.remote_ip,
+          login_count: (login_count || 0) + 1
+        )
       end
 
       # Returns the URL for the user's avatar
@@ -85,16 +162,17 @@ module Panda
       # @param size [Symbol] The variant size (:thumb, :small, :medium, :large, or nil for original)
       # @return [String, nil] The avatar URL or nil if no avatar available
       def avatar_url(size: nil)
-        if avatar.attached?
-          if size && [:thumb, :small, :medium, :large].include?(size)
-            Rails.application.routes.url_helpers.rails_blob_path(avatar.variant(size), only_path: true)
-          else
-            Rails.application.routes.url_helpers.rails_blob_path(avatar, only_path: true)
-          end
-        elsif self[:image_url].present?
-          # Fallback to OAuth provider URL if no avatar is attached yet
-          self[:image_url]
+        return self[:image_url].presence unless avatar.attached?
+
+        helpers = Rails.application.routes.url_helpers
+        if size && [:thumb, :small, :medium, :large].include?(size)
+          helpers.rails_representation_path(avatar.variant(size), only_path: true)
+        else
+          helpers.rails_blob_path(avatar.blob, only_path: true)
         end
+      rescue => e
+        Rails.logger.error("Error generating avatar URL for user #{id}: #{e.message}\n#{e.backtrace&.first(3)&.join("\n")}")
+        self[:image_url].presence
       end
 
       private

data/app/models/panda/core/user_activity.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    class UserActivity < ApplicationRecord
+      include HasUUID
+
+      self.table_name = "panda_core_user_activities"
+
+      belongs_to :user, class_name: "Panda::Core::User"
+
+      validates :action, presence: true
+
+      scope :recent, -> { order(created_at: :desc) }
+      scope :for_user, ->(user) { where(user: user) }
+      scope :by_action, ->(action) { where(action: action) }
+      scope :today, -> { where(created_at: Time.current.beginning_of_day..) }
+      scope :this_week, -> { where(created_at: Time.current.beginning_of_week..) }
+
+      # Log a user activity with optional request context
+      def self.log!(user:, action:, resource: nil, metadata: {}, request: nil)
+        attrs = {
+          user: user,
+          action: action.to_s,
+          metadata: metadata
+        }
+
+        if resource
+          attrs[:resource_type] = resource.class.name
+          attrs[:resource_id] = resource.id
+        end
+
+        if request
+          attrs[:ip_address] = request.remote_ip
+          attrs[:user_agent] = request.user_agent
+        end
+
+        create!(attrs)
+      end
+    end
+  end
+end

data/app/models/panda/core/user_session.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    class UserSession < ApplicationRecord
+      include HasUUID
+
+      self.table_name = "panda_core_user_sessions"
+
+      belongs_to :user, class_name: "Panda::Core::User"
+      belongs_to :revoked_by, class_name: "Panda::Core::User", optional: true
+
+      validates :session_id, presence: true, uniqueness: true
+
+      scope :active_sessions, -> { where(active: true, revoked_at: nil) }
+      scope :revoked_sessions, -> { where(active: false) }
+      scope :for_user, ->(user) { where(user: user) }
+      scope :recent, -> { order(last_active_at: :desc) }
+
+      # Revoke a session (e.g. admin force-logout)
+      def revoke!(admin:)
+        update!(
+          active: false,
+          revoked_at: Time.current,
+          revoked_by: admin
+        )
+      end
+
+      # Update last activity timestamp
+      def touch_activity!
+        update!(last_active_at: Time.current)
+      end
+    end
+  end
+end

data/app/services/panda/core/attach_avatar_service.rb

@@ -15,11 +15,19 @@ module Panda
 
       def call
         return success if @avatar_url.blank?
-        return success if @avatar_url == @user.oauth_avatar_url && @user.avatar.attached?
+
+        avatar_attached = begin
+          @user.avatar.attached?
+        rescue
+          false
+        end
+        return success if @avatar_url == @user.oauth_avatar_url && avatar_attached
 
         begin
           download_and_attach_avatar
-          @user.update_column(:oauth_avatar_url, @avatar_url)
+          # Record which OAuth URL was downloaded and clear image_url since
+          # we now have a local ActiveStorage copy
+          @user.update_columns(oauth_avatar_url: @avatar_url, image_url: nil)
           success(avatar_attached: true)
         rescue => e
           Rails.logger.error("Failed to attach avatar for user #{@user.id}: #{e.message}")
@@ -48,7 +56,11 @@ module Panda
 
           filename = "avatar_#{@user.id}_#{Time.current.to_i}.webp"
 
-          # Attach the optimized avatar
+          # Purge any existing avatar first to prevent duplicate attachment records.
+          # has_one_attached should auto-purge, but explicit purge guards against
+          # race conditions and failed async purge jobs leaving orphaned records.
+          @user.avatar.purge if @user.avatar.attached?
+
           @user.avatar.attach(
             io: optimized_file,
             filename: filename,

data/app/services/panda/core/csv_import_service.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    class CSVImportService
+      attr_reader :import_session
+
+      def initialize(import_session)
+        @import_session = import_session
+      end
+
+      def call
+        import_session.update!(status: "importing", started_at: Time.current)
+        rows = import_session.file_rows
+        import_session.update!(total_rows: rows.size)
+
+        klass = import_session.importable_class
+        mapping = import_session.column_mapping
+        tenant_attrs = build_tenant_attrs
+
+        rows.each_with_index do |row, index|
+          process_row(klass, row, mapping, tenant_attrs, index + 2) # +2 for header + 1-based
+        end
+
+        import_session.update!(status: "complete", completed_at: Time.current)
+      rescue => e
+        import_session.update!(status: "failed", completed_at: Time.current)
+        Rails.logger.error("[CSVImportService] Import #{import_session.id} failed: #{e.message}")
+        raise
+      end
+
+      private
+
+      def process_row(klass, row, mapping, tenant_attrs, row_number)
+        attrs, parse_errors = klass.import_row(row, mapping)
+
+        if parse_errors.any?
+          log_error(row_number, parse_errors)
+          import_session.increment!(:error_count)
+        else
+          record = klass.new(attrs.merge(tenant_attrs))
+          if record.save
+            import_session.increment!(:imported_count)
+          else
+            log_error(row_number, record.errors.full_messages)
+            import_session.increment!(:error_count)
+          end
+        end
+
+        import_session.increment!(:processed_rows)
+      end
+
+      def log_error(row_number, errors)
+        log = import_session.errors_log || []
+        log << {row: row_number, errors: errors}
+        import_session.update_column(:errors_log, log)
+      end
+
+      def build_tenant_attrs
+        return {} unless import_session.tenant
+        {tenant: import_session.tenant}
+      end
+    end
+  end
+end

data/app/services/panda/core/file_categorizer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    class FileCategorizer
+      # Maps [record_type, attachment_name] to category slug
+      ATTACHMENT_CATEGORY_MAP = {
+        ["Panda::Core::User", "avatar"] => "user-avatars",
+        ["Panda::CMS::Page", "og_image"] => "page-images",
+        ["Panda::CMS::Post", "og_image"] => "post-images",
+        ["Panda::CMS::FormSubmission", "files"] => "form-uploads",
+        ["Panda::Social::InstagramPost", "image"] => "social-media"
+      }.freeze
+
+      # Categorize a blob by looking up its attachment's record type and name
+      def categorize_attachment(attachment)
+        slug = slug_for_attachment(attachment)
+        return unless slug
+
+        categorize_blob(attachment.blob, category_slug: slug)
+      end
+
+      # Directly assign a blob to a category by slug
+      def categorize_blob(blob, category_slug:)
+        category = Panda::Core::FileCategory.find_by(slug: category_slug)
+        return unless category
+
+        Panda::Core::FileCategorization.find_or_create_by!(
+          file_category: category,
+          blob_id: blob.id
+        )
+      end
+
+      # Register additional mappings from other engines (e.g. panda-cms-pro)
+      def self.register_mapping(record_type, attachment_name, category_slug)
+        @custom_mappings ||= {}
+        @custom_mappings[[record_type, attachment_name]] = category_slug
+      end
+
+      def self.custom_mappings
+        @custom_mappings || {}
+      end
+
+      private
+
+      def slug_for_attachment(attachment)
+        key = [attachment.record_type, attachment.name]
+        ATTACHMENT_CATEGORY_MAP[key] || self.class.custom_mappings[key]
+      end
+    end
+  end
+end

data/app/services/panda/core/file_parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "csv"
+require "stringio"
+
+module Panda
+  module Core
+    class FileParser
+      class UnsupportedFormatError < StandardError; end
+
+      SUPPORTED_EXTENSIONS = %w[.csv .tsv .xlsx].freeze
+
+      def initialize(filename, content)
+        @filename = filename
+        @content = content
+        @extension = File.extname(filename).downcase
+      end
+
+      def headers
+        @headers ||= parse.first
+      end
+
+      def rows
+        @rows ||= parse.last
+      end
+
+      def self.supported?(filename)
+        ext = File.extname(filename).downcase
+        SUPPORTED_EXTENSIONS.include?(ext)
+      end
+
+      def self.xls?(filename)
+        File.extname(filename).downcase == ".xls"
+      end
+
+      private
+
+      def parse
+        @parsed ||= case @extension
+        when ".csv"
+          parse_csv
+        when ".tsv"
+          parse_tsv
+        when ".xlsx"
+          parse_xlsx
+        else
+          raise UnsupportedFormatError, "Unsupported file format: #{@extension}"
+        end
+      end
+
+      def parse_csv
+        parsed = CSV.parse(@content, headers: true)
+        headers = parsed.headers
+        rows = parsed.map(&:to_h)
+        [headers, rows]
+      end
+
+      def parse_tsv
+        parsed = CSV.parse(@content, headers: true, col_sep: "\t")
+        headers = parsed.headers
+        rows = parsed.map(&:to_h)
+        [headers, rows]
+      end
+
+      def parse_xlsx
+        require "xsv"
+
+        workbook = Xsv.open(StringIO.new(@content))
+        sheet = workbook.sheets.first
+        sheet.parse_headers!
+
+        [sheet.headers, sheet.to_a]
+      end
+    end
+  end
+end

data/app/services/panda/core/invite_user_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    class InviteUserService < Services::BaseService
+      def initialize(email:, name:, invited_by:, admin: false)
+        @email = email.to_s.downcase.strip
+        @name = name.to_s.strip
+        @invited_by = invited_by
+        @admin = admin
+      end
+
+      def call
+        return failure(["Email is required"]) if @email.blank?
+        return failure(["Name is required"]) if @name.blank?
+
+        existing_user = User.find_by(email: @email)
+        return failure(["A user with this email already exists"]) if existing_user
+
+        user = User.new(
+          email: @email,
+          name: @name,
+          admin: @admin,
+          enabled: true
+        )
+
+        unless user.save
+          return failure(user.errors.full_messages)
+        end
+
+        user.invite!(invited_by: @invited_by)
+
+        UserActivity.log!(
+          user: @invited_by,
+          action: "invited_user",
+          resource: user,
+          metadata: {invited_email: @email, admin: @admin}
+        )
+
+        success(user: user)
+      end
+    end
+  end
+end

data/app/services/panda/core/presence_service.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    class PresenceService
+      def self.record_presence(resource, user_id)
+        attrs = {
+          presenceable_type: resource.class.name,
+          presenceable_id: resource.id,
+          user_id: user_id
+        }
+
+        result = Presence.upsert(
+          attrs.merge(last_seen_at: Time.current),
+          unique_by: %i[presenceable_type presenceable_id user_id],
+          returning: %w[id]
+        )
+
+        record_id = result.first&.fetch("id") { raise "Upsert did not return an ID" }
+        Presence.find(record_id)
+      end
+
+      def self.remove_presence(resource, user_id)
+        Presence.where(
+          presenceable_type: resource.class.name,
+          presenceable_id: resource.id,
+          user_id: user_id
+        ).delete_all
+      end
+
+      def self.current_editors(resource)
+        Presence
+          .for_resource(resource)
+          .active(Presence::PRESENCE_TTL)
+          .includes(:user)
+          .map do |presence|
+            {
+              user_id: presence.user_id,
+              user_name: presence.user.name.presence || presence.user.email
+            }
+          end
+      end
+
+      def self.cleanup_stale!
+        Presence.stale(Presence::PRESENCE_TTL).delete_all
+      end
+    end
+  end
+end

data/app/views/layouts/panda/core/admin.html.erb

@@ -1,76 +1,6 @@
-<%= render "panda/core/shared/header", html_class: "h-full bg-white" %>
-<div class="flex h-full" id="panda-container">
-  <div class="absolute top-0 w-full lg:flex lg:fixed lg:inset-y-0 lg:z-50 lg:flex-col lg:w-72">
-    <div class="flex overflow-y-auto flex-col gap-y-5 px-4 pb-4 max-h-16 bg-gradient-admin lg:max-h-full grow" data-transition-enter="transition-all ease-in-out duration-300" data-transition-enter-from="m-h-16" data-transition-enter-to="max-h-full" data-transition-leave="transition-all ease-in-out duration-300" data-transition-leave-from="max-h-full" data-transition-leave-to="max-h-16">
-      <%= render "panda/core/admin/shared/sidebar" %>
-    </div>
-  </div>
-  <div class="flex flex-col flex-1 mt-16 ml-0 lg:mt-0 lg:ml-72" id="panda-inner-container" <% if content_for :sidebar %> data-controller="toggle" data-action="keydown.esc@window->toggle#hide keydown.escape@window->toggle#hide" tabindex="-1"<% end %>>
-  <section id="panda-main" class="flex flex-row h-full">
-    <div class="flex-1 h-full" id="panda-primary-content">
-      <%= render "panda/core/admin/shared/breadcrumbs" %>
-      <%= render "panda/core/admin/shared/flash" %>
-      <%= yield %>
-    </div>
-    <% if content_for :sidebar %>
-      <!-- Backdrop overlay -->
-      <div data-toggle-target="toggleable" class="hidden fixed inset-0 bg-gray-500/75 transition-opacity duration-500 ease-in-out dark:bg-gray-900/50 z-40"
-           data-transition-enter="transition-opacity duration-500 ease-in-out"
-           data-transition-enter-from="opacity-0"
-           data-transition-enter-to="opacity-100"
-           data-transition-leave="transition-opacity duration-500 ease-in-out"
-           data-transition-leave-from="opacity-100"
-           data-transition-leave-to="opacity-0"></div>
-
-      <!-- Slideover panel -->
-      <div data-toggle-target="toggleable" class="hidden ml-auto block size-full max-w-md transform fixed right-0 top-0 h-full z-50"
-            data-transition-enter="transform transition ease-in-out duration-500 sm:duration-700"
-            data-transition-enter-from="translate-x-full"
-            data-transition-enter-to="translate-x-0"
-            data-transition-leave="transform transition ease-in-out duration-500 sm:duration-700"
-            data-transition-leave-from="translate-x-0"
-            data-transition-leave-to="translate-x-full"
-            id="slideover">
-        <div class="relative flex h-full flex-col bg-white shadow-xl dark:bg-gray-800 dark:after:absolute dark:after:inset-y-0 dark:after:left-0 dark:after:w-px dark:after:bg-white/10">
-          <!-- Header -->
-          <div class="bg-gradient-admin px-4 py-3 sm:px-6">
-            <div class="flex items-center justify-between">
-              <h2 class="text-base font-semibold text-white" id="slideover-title"><%= yield :sidebar_title %></h2>
-              <div class="ml-3 flex items-center">
-                <button type="button" data-action="click->toggle#toggle touch->toggle#toggle" class="flex items-center gap-x-2 rounded-md px-3 py-1.5 text-white bg-white/10 hover:bg-white/20 transition-colors border border-white/20">
-                  <span class="text-sm font-semibold uppercase tracking-wide">Close</span>
-                  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" aria-hidden="true" class="size-5">
-                    <path d="M6 18 18 6M6 6l12 12" stroke-linecap="round" stroke-linejoin="round" />
-                  </svg>
-                </button>
-              </div>
-            </div>
-          </div>
-
-          <!-- Content -->
-          <div class="flex-1 overflow-y-auto">
-            <%= yield :sidebar %>
-          </div>
-
-          <!-- Footer (if present) -->
-          <% if content_for?(:sidebar_footer) %>
-            <div class="flex shrink-0 justify-end gap-x-3 border-t border-gray-200 px-4 py-4 dark:border-white/10">
-              <%= yield :sidebar_footer %>
-            </div>
-          <% end %>
-        </div>
-      </div>
-      <script>
-        window.addEventListener('keydown', function(e) {
-          if (e.key === 'Escape') {
-            document.querySelectorAll('[data-toggle-target="toggleable"]').forEach(function(el) {
-              el.classList.add('hidden');
-            });
-          }
-        });
-      </script>
-    <% end %>
-  </section>
-</div>
-</div>
-<%= render "panda/core/shared/footer" %>
+<%= render Panda::Core::Admin::MainLayoutComponent.new(
+  user: current_user,
+  breadcrumbs: breadcrumbs
+) do %>
+  <%= yield %>
+<% end %>

data/app/views/layouts/panda/core/admin_simple.html.erb

@@ -1,6 +1,6 @@
-<%= render "panda/core/shared/header", html_class: "h-full", body_class: "bg-gradient-admin" %>
+<%= render Panda::Core::Shared::HeaderComponent.new(html_class: "", body_class: "bg-gradient-admin") %>
 <%= render "panda/core/admin/shared/flash" %>
 <div class="flex flex-col items-center justify-center min-h-screen px-4">
   <%= yield %>
 </div>
-<%= render "panda/core/shared/footer" %>
+<%= render Panda::Core::Shared::FooterComponent.new %>