collavre 0.1.0

data/app/services/collavre/creatives/filter_pipeline.rb

@@ -0,0 +1,196 @@
+module Collavre
+module Creatives
+  class FilterPipeline
+    Result = Struct.new(
+      :matched_ids,
+      :allowed_ids,
+      :progress_map,
+      :overall_progress,
+      keyword_init: true
+    )
+
+    # 필터 클래스 목록 - 순서대로 적용
+    FILTERS = [
+      Filters::ProgressFilter,
+      Filters::TagFilter,
+      Filters::SearchFilter,
+      Filters::CommentFilter,
+      Filters::DateFilter,
+      Filters::AssigneeFilter
+    ].freeze
+
+    def initialize(user:, params:, scope:)
+      @user = user
+      @params = params
+      @scope = scope
+    end
+
+    def call
+      matched_ids = apply_filters
+      return empty_result if matched_ids.empty?
+
+      # 조상 포함
+      allowed_ids = resolve_ancestors(matched_ids)
+
+      # O(1) 권한 필터링
+      allowed_ids = filter_by_permission(allowed_ids)
+
+      progress_map, overall = calculate_progress(allowed_ids, matched_ids)
+
+      Result.new(
+        matched_ids: matched_ids.to_set,
+        allowed_ids: allowed_ids.map(&:to_s).to_set,
+        progress_map: progress_map,
+        overall_progress: overall
+      )
+    end
+
+    def any_filter_active?
+      FILTERS.any? { |klass| klass.new(params: params, scope: scope).active? }
+    end
+
+    private
+
+    attr_reader :user, :params, :scope
+
+    def apply_filters
+      active_filters = FILTERS
+        .map { |klass| klass.new(params: params, scope: scope) }
+        .select(&:active?)
+
+      # 필터가 없으면 전체 반환
+      return scope.pluck(:id) if active_filters.empty?
+
+      # 모든 필터의 교집합
+      matched_sets = active_filters.map { |f| f.match.to_set }
+      matched_sets.reduce(:&).to_a
+    end
+
+    def resolve_ancestors(matched_ids)
+      ancestors = CreativeHierarchy
+        .where(descendant_id: matched_ids)
+        .pluck(:ancestor_id)
+
+      all_related = (matched_ids + ancestors).uniq
+
+      # Include Linked Creatives that reference any of these as origin
+      # (so they appear as virtual parents in the tree)
+      linked_to_related = Creative
+        .where(origin_id: all_related)
+        .pluck(:id)
+
+      return all_related if linked_to_related.empty?
+
+      # Also include ancestors of those Linked Creatives
+      linked_ancestors = CreativeHierarchy
+        .where(descendant_id: linked_to_related)
+        .pluck(:ancestor_id)
+
+      (all_related + linked_to_related + linked_ancestors).uniq
+    end
+
+    def filter_by_permission(ids)
+      # O(1) 캐시 테이블 조회
+      # no_access가 public share보다 우선하므로 별도 처리 필요
+      accessible_ids = Set.new
+
+      if user
+        # 사용자별 캐시 엔트리 확인
+        user_entries = CreativeSharesCache
+          .where(creative_id: ids, user_id: user.id)
+          .pluck(:creative_id, :permission)
+
+        user_accessible = []
+        user_denied = Set.new
+        user_entries.each do |cid, perm|
+          # perm is a string from enum (e.g., "no_access", "read")
+          if perm == "no_access"
+            user_denied << cid
+          else
+            user_accessible << cid
+          end
+        end
+        accessible_ids.merge(user_accessible)
+
+        # public share 확인 (no_access로 거부된 것 제외)
+        public_ids = CreativeSharesCache
+          .where(creative_id: ids, user_id: nil)
+          .where.not(permission: :no_access)
+          .pluck(:creative_id)
+        accessible_ids.merge(public_ids - user_denied.to_a)
+
+        # Fallback: owned creatives (for fixtures)
+        owned_ids = Creative.where(id: ids, user_id: user.id).pluck(:id)
+        accessible_ids.merge(owned_ids)
+      else
+        # 비로그인: public share만
+        accessible_ids = CreativeSharesCache
+          .where(creative_id: ids, user_id: nil)
+          .where.not(permission: :no_access)
+          .pluck(:creative_id)
+          .to_set
+      end
+
+      accessible_ids.to_a
+    end
+
+    def calculate_progress(allowed_ids, matched_ids)
+      return [ {}, 0.0 ] if allowed_ids.empty?
+
+      # Find "leaf-most" nodes: nodes that are NOT ancestors of other nodes in matched_ids
+      # These are the relevant nodes for overall progress calculation
+      superfluous_ancestors = CreativeHierarchy
+        .where(ancestor_id: matched_ids.to_a, descendant_id: matched_ids.to_a)
+        .where("generations > 0")
+        .pluck(:ancestor_id)
+        .uniq
+
+      relevant_ids = matched_ids.to_a - superfluous_ancestors
+
+      # Get progress values for all allowed creatives
+      creatives = Creative.where(id: allowed_ids).includes(:origin)
+      progress_values = creatives.to_h do |c|
+        # Shell Creative uses origin's progress
+        progress = c.origin_id.present? ? c.origin&.progress : c.progress
+        [ c.id, progress || 0.0 ]
+      end
+
+      # Calculate overall progress from relevant (leaf-most) nodes only
+      relevant_progress = relevant_ids.map { |id| progress_values[id] || 0.0 }
+      overall = relevant_progress.any? ? relevant_progress.sum / relevant_progress.size : 0.0
+
+      # Build progress_map: for each allowed_id, calculate average of its relevant descendants
+      relationships = CreativeHierarchy
+        .where(ancestor_id: allowed_ids, descendant_id: relevant_ids)
+        .pluck(:ancestor_id, :descendant_id)
+
+      aggregation = Hash.new { |h, k| h[k] = [] }
+      relationships.each do |anc_id, desc_id|
+        val = progress_values[desc_id]
+        aggregation[anc_id] << val if val
+      end
+
+      progress_map = {}
+      aggregation.each do |anc_id, values|
+        progress_map[anc_id.to_s] = values.sum / values.size
+      end
+
+      # Also include nodes that are in relevant_ids themselves
+      relevant_ids.each do |id|
+        progress_map[id.to_s] ||= progress_values[id] || 0.0
+      end
+
+      [ progress_map, overall ]
+    end
+
+    def empty_result
+      Result.new(
+        matched_ids: Set.new,
+        allowed_ids: Set.new,
+        progress_map: {},
+        overall_progress: 0.0
+      )
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/assignee_filter.rb

@@ -0,0 +1,30 @@
+module Collavre
+module Creatives
+  module Filters
+    class AssigneeFilter < BaseFilter
+      def active?
+        params[:assignee_id].present? || params[:unassigned].present?
+      end
+
+      def match
+        if params[:unassigned] == "true"
+          # owner가 없는 Label을 가진 creative 또는 태그가 없는 creative
+          with_null_owner = scope.left_joins(tags: :label)
+                                 .where(labels: { owner_id: nil })
+                                 .pluck(:id)
+          without_tags = scope.left_joins(:tags)
+                              .where(tags: { id: nil })
+                              .pluck(:id)
+          (with_null_owner + without_tags).uniq
+        else
+          assignee_ids = Array(params[:assignee_id]).map(&:to_i)
+          scope.joins(tags: :label)
+               .where(labels: { owner_id: assignee_ids })
+               .distinct
+               .pluck(:id)
+        end
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/base_filter.rb

@@ -0,0 +1,24 @@
+module Collavre
+module Creatives
+  module Filters
+    class BaseFilter
+      def initialize(params:, scope:)
+        @params = params
+        @scope = scope
+      end
+
+      def active?
+        raise NotImplementedError
+      end
+
+      def match
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :params, :scope
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/comment_filter.rb

@@ -0,0 +1,21 @@
+module Collavre
+module Creatives
+  module Filters
+    class CommentFilter < BaseFilter
+      def active?
+        params[:has_comments].present? || params[:comment].present?
+      end
+
+      def match
+        has_comments = params[:has_comments] == "true" || params[:comment] == "true"
+
+        if has_comments
+          scope.joins(:comments).distinct.pluck(:id)
+        else
+          scope.left_joins(:comments).where(comments: { id: nil }).pluck(:id)
+        end
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/date_filter.rb

@@ -0,0 +1,58 @@
+module Collavre
+module Creatives
+  module Filters
+    class DateFilter < BaseFilter
+      def active?
+        params[:due_before].present? ||
+          params[:due_after].present? ||
+          params[:has_due_date].present?
+      end
+
+      def match
+        # Label의 target_date 기반 필터링
+        if params[:has_due_date] == "false"
+          # target_date가 없는 creative
+          # 1. creatives with labels that have no target_date
+          # 2. creatives with no tags at all
+          with_null_date = scope.left_joins(tags: :label)
+                                .where(labels: { target_date: nil })
+                                .pluck(:id)
+          without_tags = scope.left_joins(:tags)
+                              .where(tags: { id: nil })
+                              .pluck(:id)
+          return (with_null_date + without_tags).uniq
+        end
+
+        result = scope.joins(:tags)
+                      .joins("INNER JOIN labels ON tags.label_id = labels.id")
+
+        if params[:has_due_date] == "true"
+          result = result.where.not(labels: { target_date: nil })
+        end
+
+        if params[:due_before].present?
+          if (due_before = safe_parse_date(params[:due_before]))
+            result = result.where("labels.target_date <= ?", due_before)
+          end
+        end
+
+        if params[:due_after].present?
+          if (due_after = safe_parse_date(params[:due_after]))
+            result = result.where("labels.target_date >= ?", due_after)
+          end
+        end
+
+        result.distinct.pluck(:id)
+      end
+
+      private
+
+      def safe_parse_date(value)
+        Date.iso8601(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/progress_filter.rb

@@ -0,0 +1,25 @@
+module Collavre
+module Creatives
+  module Filters
+    class ProgressFilter < BaseFilter
+      def active?
+        params[:min_progress].present? || params[:max_progress].present?
+      end
+
+      def match
+        min_val = params[:min_progress].presence&.to_f
+        max_val = params[:max_progress].presence&.to_f
+
+        # Linked Creatives use origin's progress, regular creatives use their own
+        query = scope
+          .joins("LEFT JOIN creatives origins ON creatives.origin_id = origins.id")
+
+        effective_progress = "COALESCE(origins.progress, creatives.progress)"
+        query = query.where("#{effective_progress} >= ?", min_val) if min_val
+        query = query.where("#{effective_progress} <= ?", max_val) if max_val
+        query.pluck("creatives.id")
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/search_filter.rb

@@ -0,0 +1,28 @@
+module Collavre
+module Creatives
+  module Filters
+    class SearchFilter < BaseFilter
+      def active?
+        params[:search].present?
+      end
+
+      def match
+        query = "%#{sanitize_like(params[:search])}%"
+
+        # Search in description OR comments.content
+        scope
+          .left_joins(:comments)
+          .where("creatives.description LIKE :q OR comments.content LIKE :q", q: query)
+          .distinct
+          .pluck(:id)
+      end
+
+      private
+
+      def sanitize_like(str)
+        str.to_s.gsub(/[%_]/) { |m| "\\#{m}" }
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/filters/tag_filter.rb

@@ -0,0 +1,16 @@
+module Collavre
+module Creatives
+  module Filters
+    class TagFilter < BaseFilter
+      def active?
+        params[:tags].present?
+      end
+
+      def match
+        tag_ids = Array(params[:tags]).map(&:to_s)
+        scope.joins(:tags).where(tags: { label_id: tag_ids }).pluck(:id)
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/importer.rb

@@ -0,0 +1,47 @@
+module Collavre
+module Creatives
+  class Importer
+    class Error < StandardError; end
+    class UnsupportedFile < Error; end
+
+    MARKDOWN_MIME_TYPES = %w[text/markdown text/x-markdown application/octet-stream].freeze
+    PPT_MIME_TYPES = %w[
+      application/vnd.ms-powerpoint
+      application/vnd.openxmlformats-officedocument.presentationml.presentation
+    ].freeze
+
+    def initialize(file:, user:, parent: nil)
+      @file = file
+      @user = user
+      @parent = parent
+    end
+
+    def call
+      raise Error, "File required" if file.blank?
+
+      case mime_type
+      when *MARKDOWN_MIME_TYPES
+        content = read_file_content
+        MarkdownImporter.import(content, parent: parent, user: user, create_root: true)
+      when *PPT_MIME_TYPES
+        PptImporter.import(file.tempfile, parent: parent, user: user, create_root: true, filename: file.original_filename)
+      else
+        raise UnsupportedFile, "Invalid file type"
+      end
+    end
+
+    private
+
+    attr_reader :file, :user, :parent
+
+    def mime_type
+      file.content_type.presence || Rack::Mime.mime_type(File.extname(file.original_filename.to_s))
+    end
+
+    def read_file_content
+      file.rewind
+      file.read.to_s.force_encoding("UTF-8")
+    end
+  end
+end
+end

data/app/services/collavre/creatives/index_query.rb

@@ -0,0 +1,191 @@
+module Collavre
+module Creatives
+  class IndexQuery
+    Result = Struct.new(
+      :creatives,
+      :parent_creative,
+      :shared_creative,
+      :shared_list,
+      :overall_progress,
+      :allowed_creative_ids,
+      :progress_map,
+      keyword_init: true
+    )
+
+    def initialize(user:, params: {})
+      @user = user
+      @params = params.with_indifferent_access
+    end
+
+    def call
+      result = resolve_creatives
+      shared_creative = result[:parent] || result[:creatives]&.first
+      shared_list = shared_creative ? shared_creative.all_shared_users : []
+
+      Result.new(
+        creatives: result[:creatives],
+        parent_creative: result[:parent],
+        shared_creative: shared_creative,
+        shared_list: shared_list,
+        overall_progress: result[:overall_progress] || 0,
+        allowed_creative_ids: result[:allowed_ids],
+        progress_map: result[:progress_map]
+      )
+    end
+
+    private
+
+    attr_reader :user, :params
+
+    def resolve_creatives
+      if any_filter_active?
+        handle_filtered_query
+      elsif params[:id]
+        handle_id_query
+      else
+        handle_root_query
+      end
+    end
+
+    def any_filter_active?
+      params[:tags].present? ||
+        params[:min_progress].present? ||
+        params[:max_progress].present? ||
+        params[:search].present? ||
+        params[:comment] == "true" ||
+        params[:has_comments].present? ||
+        params[:due_before].present? ||
+        params[:due_after].present? ||
+        params[:has_due_date].present? ||
+        params[:assignee_id].present? ||
+        params[:unassigned].present?
+    end
+
+    def handle_filtered_query
+      scope = determine_scope
+
+      result = FilterPipeline.new(
+        user: user,
+        params: params,
+        scope: scope
+      ).call
+
+      return empty_result if result.matched_ids.empty?
+
+      # For search/comment filters, return matched items directly (flat results sorted by relevance)
+      # For other filters (tags, progress), return tree start nodes
+      if params[:search].present? || params[:comment] == "true"
+        matched_creatives = Creative.where(id: result.matched_ids.to_a)
+          .order(:sequence)
+          .select { |c| readable?(c) }
+
+        # Sort by comment updated_at for comment filter
+        if params[:comment] == "true"
+          matched_creatives = matched_creatives.sort_by { |c| c.comments.maximum(:updated_at) || c.updated_at }.reverse
+        end
+
+        parent = params[:id] ? Creative.find_by(id: params[:id]) : nil
+        {
+          creatives: matched_creatives,
+          parent: parent,
+          allowed_ids: result.allowed_ids,
+          overall_progress: result.overall_progress,
+          progress_map: result.progress_map
+        }
+      else
+        start_nodes = determine_start_nodes(result.allowed_ids)
+        parent = params[:id] ? Creative.find_by(id: params[:id]) : nil
+        {
+          creatives: start_nodes,
+          parent: parent,
+          allowed_ids: result.allowed_ids,
+          overall_progress: result.overall_progress,
+          progress_map: result.progress_map
+        }
+      end
+    end
+
+    def handle_id_query
+      creative = Creative.find_by(id: params[:id])
+      return empty_result unless creative && readable?(creative)
+
+      {
+        creatives: creative.children_with_permission(user, :read),
+        parent: creative,
+        allowed_ids: nil,
+        overall_progress: nil,
+        progress_map: nil
+      }
+    end
+
+    def handle_root_query
+      {
+        creatives: Creative.where(user: user).roots,
+        parent: nil,
+        allowed_ids: nil,
+        overall_progress: nil,
+        progress_map: nil
+      }
+    end
+
+    def determine_scope
+      if params[:id]
+        base = Creative.find_by(id: params[:id])&.effective_origin
+        return Creative.none unless base
+
+        # Use subqueries instead of loading IDs into memory
+        # 1. Actual descendants (via creative_hierarchies)
+        descendants_subquery = CreativeHierarchy
+          .where(ancestor_id: base.id)
+          .select(:descendant_id)
+
+        # 2. Linked descendants: origins of shell creatives -> their descendants
+        # First, find shell creatives in the subtree
+        shells_in_subtree = Creative
+          .where("creatives.id IN (?)", descendants_subquery)
+          .where.not(origin_id: nil)
+          .select(:origin_id)
+
+        # Then, get descendants of those origins
+        linked_descendants_subquery = CreativeHierarchy
+          .where("ancestor_id IN (?)", shells_in_subtree)
+          .select(:descendant_id)
+
+        # Combine both subqueries (use creatives.id to avoid ambiguity with joins)
+        Creative.where(
+          "creatives.id IN (?) OR creatives.id IN (?)",
+          descendants_subquery,
+          linked_descendants_subquery
+        )
+      else
+        Creative.where(origin_id: nil)  # Only real creatives (not shells)
+      end
+    end
+
+    def determine_start_nodes(allowed_ids)
+      allowed_ids_array = allowed_ids.map { |id| id.to_s.to_i }
+      allowed_ids_set = allowed_ids.to_set
+
+      if params[:id]
+        parent = Creative.find_by(id: params[:id])
+        return [] unless parent && readable?(parent)
+
+        parent.children.where(id: allowed_ids_array).order(:sequence).to_a
+      else
+        # Root view: only show creatives with parent_id = nil
+        # This prevents Linked Creatives (which have parent_id) from appearing at root
+        # even if their ancestors are not in allowed_ids
+        Creative.where(id: allowed_ids_array, parent_id: nil).order(:sequence).to_a
+      end
+    end
+
+    def readable?(creative)
+      creative.user == user || creative.has_permission?(user, :read)
+    end
+
+    def empty_result
+      { creatives: [], parent: nil, allowed_ids: Set.new, overall_progress: 0, progress_map: {} }
+    end
+  end
+end
+end