collavre 0.1.0

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

@@ -0,0 +1,131 @@
+module Collavre
+module Creatives
+  class PathExporter
+    Entry = Struct.new(
+      :creative_id,
+      :progress,
+      :path,
+      :path_with_ids,
+      :path_with_ids_and_progress,
+      :full_path_with_ids,
+      :full_path_with_ids_and_progress,
+      :leaf,
+      keyword_init: true
+    )
+
+    def initialize(creative, use_effective_origin: true)
+      @creative = use_effective_origin ? creative.effective_origin : creative
+    end
+
+    def paths
+      entries.map(&:path)
+    end
+
+    def paths_with_ids
+      entries.map(&:path_with_ids)
+    end
+
+    def paths_with_ids_and_progress
+      entries.map(&:path_with_ids_and_progress)
+    end
+
+    def path_for(id)
+      entry_map[id.to_i]&.path
+    end
+
+    def path_with_ids_for(id)
+      entry_map[id.to_i]&.path_with_ids
+    end
+
+    def path_with_ids_and_progress_for(id)
+      entry_map[id.to_i]&.path_with_ids_and_progress
+    end
+
+    def full_paths_with_ids
+      entries.map(&:full_path_with_ids)
+    end
+
+    def full_paths_with_ids_and_progress
+      entries.map(&:full_path_with_ids_and_progress)
+    end
+
+    def full_path_with_ids_for(id)
+      entry_map[id.to_i]&.full_path_with_ids
+    end
+
+    def full_path_with_ids_and_progress_for(id)
+      entry_map[id.to_i]&.full_path_with_ids_and_progress
+    end
+
+    def full_paths_with_ids_and_progress_with_leaf
+      entries.map do |entry|
+        {
+          path: entry.full_path_with_ids_and_progress,
+          leaf: entry.leaf
+        }
+      end
+    end
+
+    private
+
+    def entries
+      @entries ||= begin
+        results = []
+        traverse(@creative, [], [], [], results)
+        results
+      end
+    end
+
+    def entry_map
+      @entry_map ||= entries.index_by(&:creative_id)
+    end
+
+    def traverse(node, ancestors, ancestors_with_ids, ancestors_with_ids_and_progress, results)
+      label = extract_label(node)
+      label_with_id = "[#{node.id}] #{label}"
+      label_with_progress = label_with_progress(node, label_with_id)
+      current_path = (ancestors + [ label ]).join(" > ")
+      current_path_with_ids = (ancestors_with_ids + [ label_with_id ]).join(" > ")
+      current_path_with_ids_and_progress = (ancestors_with_ids_and_progress + [ label_with_progress ]).join(" > ")
+
+      children = node.children.order(:sequence).to_a
+
+      results << Entry.new(
+        creative_id: node.id,
+        progress: node.progress,
+        path: current_path,
+        path_with_ids: label_with_id,
+        path_with_ids_and_progress: label_with_progress,
+        full_path_with_ids: current_path_with_ids,
+        full_path_with_ids_and_progress: current_path_with_ids_and_progress,
+        leaf: children.empty?
+      )
+
+      children.each do |child|
+        traverse(
+          child,
+          ancestors + [ label ],
+          ancestors_with_ids + [ label_with_id ],
+          ancestors_with_ids_and_progress + [ label_with_progress ],
+          results
+        )
+      end
+    end
+
+    def extract_label(creative)
+      html = creative.effective_description(nil, true).to_s
+      sanitized = ActionView::Base.full_sanitizer.sanitize(html).to_s
+      text = sanitized.gsub(/[\r\n]+/, " ").squeeze(" ").strip
+      text.presence || "Creative ##{creative.id}"
+    end
+
+    def label_with_progress(node, base_label)
+      progress = node.progress
+      return base_label if progress.nil?
+
+      percentage = (progress.to_f * 100).round
+      "#{base_label} (progress #{percentage}%)"
+    end
+  end
+end
+end

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

@@ -0,0 +1,194 @@
+module Collavre
+module Creatives
+  class PermissionCacheBuilder
+    # Creative 생성 시 소유자 캐시 추가
+    def self.cache_owner(creative)
+      return unless creative.user_id
+
+      CreativeSharesCache.upsert(
+        {
+          creative_id: creative.id,
+          user_id: creative.user_id,
+          permission: CreativeShare.permissions[:admin],
+          source_share_id: nil
+        },
+        unique_by: [ :creative_id, :user_id ],
+        update_only: [ :permission, :source_share_id ]
+      )
+    end
+
+    # Creative user_id 변경 시 호출
+    def self.update_owner(creative, old_user_id, new_user_id)
+      # 기존 소유자의 owner 캐시 삭제 (source_share_id가 nil인 것만)
+      if old_user_id
+        CreativeSharesCache.where(
+          creative_id: creative.id,
+          user_id: old_user_id,
+          source_share_id: nil
+        ).delete_all
+      end
+
+      # 새 소유자 캐시 추가
+      cache_owner(creative) if new_user_id
+    end
+
+    # CreativeShare 생성/업데이트 시 호출
+    def self.propagate_share(creative_share)
+      return if creative_share.destroyed?
+
+      creative = creative_share.creative
+      user_id = creative_share.user_id
+      permission = creative_share.permission
+
+      # 해당 creative + 모든 자손 ID (closure_tree 사용)
+      all_descendant_ids = [ creative.id ] + creative.descendant_ids
+
+      # "closest share wins" 의미론 적용:
+      # 이 share의 자손 중 더 가까운 share가 있는 creative는 제외
+      # (더 가까운 share가 해당 서브트리를 담당)
+      # no_access도 closer share로 인정 (public share보다 우선)
+      closer_share_creative_ids = CreativeShare
+        .where(user_id: user_id)
+        .where(creative_id: creative.descendant_ids)  # 이 creative의 strict descendants에 있는 share들
+        .where.not(id: creative_share.id)  # 자기 자신 제외
+        .pluck(:creative_id)
+
+      # 더 가까운 share가 있는 creative와 그 자손들은 제외
+      excluded_ids = Set.new
+      if closer_share_creative_ids.any?
+        excluded_ids = CreativeHierarchy
+          .where(ancestor_id: closer_share_creative_ids)
+          .pluck(:descendant_id)
+          .to_set
+      end
+
+      ids_to_update = all_descendant_ids.reject { |id| excluded_ids.include?(id) }
+
+      return if ids_to_update.empty?
+
+      permission_value = CreativeShare.permissions[permission]
+
+      # Handle NULL user_id (public shares) separately since SQLite treats NULL as distinct in unique indexes
+      if user_id.nil?
+        ids_to_update.each do |cid|
+          CreativeSharesCache.find_or_initialize_by(creative_id: cid, user_id: nil).tap do |cache|
+            cache.assign_attributes(
+              permission: permission_value,
+              source_share_id: creative_share.id
+            )
+            cache.save!
+          end
+        end
+      else
+        records = ids_to_update.map do |cid|
+          {
+            creative_id: cid,
+            user_id: user_id,
+            permission: permission_value,
+            source_share_id: creative_share.id
+          }
+        end
+
+        # Single bulk operation instead of N individual saves
+        CreativeSharesCache.upsert_all(
+          records,
+          unique_by: [ :creative_id, :user_id ],
+          update_only: [ :permission, :source_share_id ]
+        )
+      end
+    end
+
+    # CreativeShare 삭제 시 호출
+    def self.remove_share(creative_share)
+      CreativeSharesCache.where(source_share_id: creative_share.id).delete_all
+
+      # 삭제 후 조상에서 다른 share가 있으면 다시 전파
+      rebuild_from_ancestors(creative_share.creative, creative_share.user_id)
+    end
+
+    # Public wrapper for rebuild_from_ancestors (used by PermissionCacheJob)
+    def self.rebuild_from_ancestors_for_user(creative, user_id)
+      rebuild_from_ancestors(creative, user_id)
+    end
+
+    # CreativeShare의 creative_id 또는 user_id 변경 시 이전 위치/사용자에 대해 호출
+    # 특정 사용자의 캐시를 서브트리에서 재구축 (조상 + 서브트리 내 직접 share 모두 고려)
+    # user_id는 nil (public share)일 수 있음
+    def self.rebuild_user_cache_for_subtree(creative, user_id)
+      return unless creative
+
+      descendant_ids = [ creative.id ] + creative.descendant_ids
+
+      # 해당 사용자의 캐시만 삭제 (owner entries 유지를 위해 source_share_id가 있는 것만)
+      CreativeSharesCache.where(creative_id: descendant_ids, user_id: user_id)
+                         .where.not(source_share_id: nil)
+                         .delete_all
+
+      # 조상에서 해당 사용자의 share 찾아서 전파
+      rebuild_from_ancestors(creative, user_id)
+
+      # 서브트리 내의 해당 사용자 직접 share들도 재적용
+      # no_access도 포함 - 캐시에 저장하여 public share를 override
+      CreativeShare.where(creative_id: descendant_ids, user_id: user_id)
+                   .find_each { |share| propagate_share(share) }
+    end
+
+    # Creative parent_id 변경 시 호출
+    def self.rebuild_for_creative(creative)
+      descendant_ids = creative.self_and_descendant_ids
+
+      # 해당 creative와 자손들의 캐시 삭제 (share 기반만 - owner entries 유지)
+      CreativeSharesCache.where(creative_id: descendant_ids)
+                         .where.not(source_share_id: nil)
+                         .delete_all
+
+      # 새 부모 기준으로 조상 share 전파
+      rebuild_from_ancestors_for_subtree(creative)
+
+      # 이동된 서브트리 내의 직접 share들 재적용
+      # (closest-share-wins 의미론으로 올바르게 전파됨)
+      # no_access도 포함 - 캐시에 저장하여 public share를 override
+      CreativeShare.where(creative_id: descendant_ids)
+                   .find_each { |share| propagate_share(share) }
+
+      # 소유자 캐시 재확인 (혹시 누락된 경우)
+      creative.self_and_descendants.each do |c|
+        cache_owner(c) if c.user_id
+      end
+    end
+
+    class << self
+      private
+
+      def rebuild_from_ancestors(creative, user_id)
+        # 조상들 중 해당 user에 대한 share 찾기 (가장 가까운 조상 우선)
+        # no_access도 포함 - 캐시에 저장하여 public share를 override
+        ancestor_ids = creative.ancestor_ids
+        return if ancestor_ids.empty?
+
+        ancestor_share = CreativeShare
+          .where(creative_id: ancestor_ids, user_id: user_id)
+          .joins("INNER JOIN creative_hierarchies ch ON creative_shares.creative_id = ch.ancestor_id")
+          .where("ch.descendant_id = ?", creative.id)
+          .order("ch.generations ASC")
+          .first
+
+        propagate_share(ancestor_share) if ancestor_share
+      end
+
+      def rebuild_from_ancestors_for_subtree(creative)
+        ancestor_ids = creative.ancestor_ids
+        return if ancestor_ids.empty?
+
+        # 조상들의 모든 share 가져오기
+        # no_access도 포함 - 캐시에 저장하여 public share를 override
+        ancestor_shares = CreativeShare.where(creative_id: ancestor_ids)
+
+        ancestor_shares.each do |share|
+          propagate_share(share)
+        end
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,42 @@
+module Collavre
+  module Creatives
+    class PermissionChecker
+      def initialize(creative, user)
+        @creative = creative
+        @user = user
+      end
+
+      def allowed?(required_permission = :read)
+        base = creative.origin_id.nil? ? creative : creative.origin
+
+        # Owner always has admin permission (fallback for fixtures and missing cache entries)
+        return true if base.user_id == user&.id
+
+        # O(1) 캐시 테이블 조회
+        # 사용자별 엔트리를 먼저 확인 (no_access가 public share보다 우선)
+        if user
+          user_entry = CreativeSharesCache.find_by(creative_id: base.id, user_id: user.id)
+          if user_entry
+            # no_access는 명시적 거부 - public share가 있어도 차단
+            return false if user_entry.no_access?
+            return permission_rank(user_entry.permission) >= permission_rank(required_permission)
+          end
+        end
+
+        # 사용자별 엔트리 없으면 public share 확인
+        public_entry = CreativeSharesCache.find_by(creative_id: base.id, user_id: nil)
+        return false unless public_entry
+
+        permission_rank(public_entry.permission) >= permission_rank(required_permission)
+      end
+
+      private
+
+      attr_reader :creative, :user
+
+      def permission_rank(value)
+        CreativeShare.permissions[value.to_s]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Collavre
+module Creatives
+  class PlanTagger
+    Result = Struct.new(:success?, :message, keyword_init: true)
+
+    def initialize(plan_id:, creative_ids: [])
+      @plan = Plan.find_by(id: plan_id)
+      @creative_ids = Array(creative_ids).map(&:presence).compact
+    end
+
+    def apply
+      return failure("Please select a plan and at least one creative.") unless valid?
+
+      creatives.find_each do |creative|
+        creative.tags.find_or_create_by(label: plan, creative_id: creative.id)
+      end
+
+      success("Plan tags applied to selected creatives.")
+    end
+
+    def remove
+      return failure("Please select a plan and at least one creative.") unless valid?
+
+      creatives.find_each do |creative|
+        tag = creative.tags.find_by(label: plan, creative_id: creative.id)
+        tag&.destroy
+      end
+
+      success("Plan tag removed from selected creatives.")
+    end
+
+    private
+
+    attr_reader :plan, :creative_ids
+
+    def creatives
+      Creative.where(id: creative_ids)
+    end
+
+    def valid?
+      plan.present? && creative_ids.any?
+    end
+
+    def success(message)
+      Result.new(success?: true, message: message)
+    end
+
+    def failure(message)
+      Result.new(success?: false, message: message)
+    end
+  end
+end
+end

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

@@ -0,0 +1,89 @@
+require "set"
+
+module Collavre
+  module Creatives
+    class ProgressService
+      def initialize(creative)
+        @creative = creative
+      end
+
+      def update_progress_from_children!
+        if creative.children.any?
+          # Use Ruby calculation to get effective progress (handling delegation for linked creatives)
+          # instead of SQL average which reads potentially stale DB columns.
+          new_progress = creative.children.map(&:progress).sum.to_f / creative.children.size
+          creative.update(progress: new_progress)
+        else
+          creative.update(progress: 0)
+        end
+      end
+
+      def update_parent_progress!(visited_ids = Set.new)
+        return if visited_ids.include?(creative.id)
+        visited_ids.add(creative.id)
+
+        creative.linked_creatives.find_each do |linked|
+          # Linked creatives delegate progress to origin.
+          # We don't update them directly (forbidden by validation).
+          # We must ensure their PARENTS are updated.
+          # Recurse with visited_ids to prevent cycles.
+          ProgressService.new(linked).update_parent_progress!(visited_ids)
+        end
+        parent = creative.parent
+        return unless parent
+
+        begin
+          parent.reload
+        rescue ActiveRecord::RecordNotFound
+          return
+        end
+        new_progress = if parent.children.any?
+                         parent.children.map(&:progress).sum.to_f / parent.children.size
+        else
+                         0
+        end
+
+        # Avoid infinite recursion
+        if (parent.progress - new_progress).abs > 0.0001
+          parent.update(progress: new_progress)
+        end
+      end
+
+      def progress_for_tags(tag_ids, user)
+        return creative.progress if tag_ids.blank?
+
+        tag_ids = Array(tag_ids).map(&:to_s)
+        visible_children = creative.children_with_permission(user)
+        child_values = visible_children.map do |child|
+          self.class.new(child).progress_for_tags(tag_ids, user)
+        end.compact
+
+        if child_values.any?
+          child_values.sum.to_f / child_values.size
+        else
+          own_label_ids = creative.tags.pluck(:label_id).map(&:to_s)
+          if (own_label_ids & tag_ids).any?
+            visible_children.any? ? 1.0 : creative.progress
+          end
+        end
+      end
+
+      # `tagged_ids` should be a Set of creative IDs tagged with the plan.
+      def progress_for_plan(tagged_ids)
+        child_values = creative.children.map do |child|
+          self.class.new(child).progress_for_plan(tagged_ids)
+        end.compact
+
+        if child_values.any?
+          child_values.sum.to_f / child_values.size
+        elsif tagged_ids.include?(creative.id)
+          creative.children.any? ? 1.0 : creative.progress
+        end
+      end
+
+      private
+
+      attr_reader :creative
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+module Collavre
+module Creatives
+  class Reorderer
+    class Error < StandardError; end
+
+    LinkDropResult = Struct.new(:new_creative, :parent, :direction, keyword_init: true)
+
+    def initialize(user:)
+      @user = user
+    end
+
+    def reorder(dragged_id:, target_id:, direction:)
+      dragged, target = fetch_creatives(dragged_id, target_id)
+      validate_direction!(direction)
+      raise Error, "Invalid creatives" unless dragged && target
+
+      if direction == "child"
+        reorder_as_child(dragged, target)
+      else
+        reorder_as_sibling(dragged, target, direction)
+      end
+
+      true
+    end
+
+    def reorder_multiple(dragged_ids:, target_id:, direction:)
+      ids = Array(dragged_ids).map(&:presence).compact
+      validate_direction!(direction)
+      raise Error, "Invalid creatives" if ids.empty?
+
+      target = Creative.find_by(id: target_id)
+      raise Error, "Invalid creatives" unless target
+
+      dragged_lookup = Creative.where(id: ids).index_by { |creative| creative.id.to_s }
+      ordered_dragged = ids.map { |id| dragged_lookup[id.to_s] }.compact
+      raise Error, "Invalid creatives" unless ordered_dragged.size == ids.size
+
+      if ordered_dragged.any? { |creative| creative.id == target.id }
+        raise Error, "Invalid creatives"
+      end
+
+      target_ancestor_ids = target.ancestors.pluck(:id)
+      if ordered_dragged.any? { |creative| target_ancestor_ids.include?(creative.id) }
+        raise Error, "Invalid creatives"
+      end
+
+      if direction == "child"
+        reorder_multiple_as_child(ordered_dragged, target)
+      else
+        reorder_multiple_as_sibling(ordered_dragged, target, direction)
+      end
+
+      true
+    rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved => e
+      raise Error, e.message
+    end
+
+    def link_drop(dragged_id:, target_id:, direction:)
+      dragged, target = fetch_creatives(dragged_id, target_id)
+      validate_direction!(direction)
+      raise Error, "Invalid creatives" unless dragged && target
+
+      origin = dragged.effective_origin
+      new_parent = direction == "child" ? target : target.parent
+
+      if new_parent.present?
+        origin_descendant_ids = origin.self_and_descendants.pluck(:id)
+
+        new_parent.self_and_ancestors.each do |ancestor|
+          ancestor_origin_id = ancestor.origin_id.presence || ancestor.id
+
+          if origin_descendant_ids.include?(ancestor_origin_id)
+            raise Error, "Invalid creatives"
+          end
+        end
+      end
+
+      new_creative = nil
+      Creative.transaction do
+        new_creative = Creative.create!(
+          origin_id: origin.id,
+          parent: new_parent,
+          user: new_parent&.user || user
+        )
+
+        siblings = sibling_scope(new_parent)
+        siblings.reject! { |s| s.id == new_creative.id }
+
+        if direction == "child"
+          siblings << new_creative
+        else
+          target_index = siblings.index { |s| s.id == target.id } || 0
+          insert_index = direction == "up" ? target_index : target_index + 1
+          insert_index = [ [ insert_index, 0 ].max, siblings.size ].min
+          siblings.insert(insert_index, new_creative)
+        end
+
+        resequence!(siblings)
+      end
+
+      LinkDropResult.new(new_creative: new_creative, parent: new_parent, direction: direction)
+    rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved => e
+      raise Error, e.message
+    end
+
+    private
+
+    attr_reader :user
+
+    def fetch_creatives(dragged_id, target_id)
+      [ Creative.find_by(id: dragged_id), Creative.find_by(id: target_id) ]
+    end
+
+    def validate_direction!(direction)
+      raise Error, "Invalid direction" unless %w[up down child].include?(direction)
+    end
+
+    def reorder_as_child(dragged, target)
+      dragged.update!(parent: target)
+      siblings = target.children.order(:sequence).to_a
+      siblings.reject! { |s| s.id == dragged.id }
+      siblings << dragged
+      resequence!(siblings)
+    end
+
+    def reorder_as_sibling(dragged, target, direction)
+      if dragged.parent_id != target.parent_id
+        dragged.update!(parent: target.parent)
+      end
+
+      siblings = sibling_scope(dragged.parent)
+      siblings.reject! { |s| s.id == dragged.id }
+      target_index = siblings.index { |s| s.id == target.id }
+      new_index = direction == "up" ? target_index : target_index.to_i + 1
+      siblings.insert(new_index, dragged)
+      resequence!(siblings)
+    end
+
+    def reorder_multiple_as_child(dragged_creatives, target)
+      Creative.transaction do
+        siblings = target.children.order(:sequence).to_a
+        dragged_ids = dragged_creatives.map(&:id)
+        siblings.reject! { |s| dragged_ids.include?(s.id) }
+
+        dragged_creatives.each do |dragged|
+          dragged.update!(parent: target)
+        end
+
+        siblings.concat(dragged_creatives)
+        resequence!(siblings)
+      end
+    end
+
+    def reorder_multiple_as_sibling(dragged_creatives, target, direction)
+      Creative.transaction do
+        parent = target.parent
+        siblings = sibling_scope(parent)
+        dragged_ids = dragged_creatives.map(&:id)
+        siblings.reject! { |s| dragged_ids.include?(s.id) }
+
+        dragged_creatives.each do |dragged|
+          dragged.update!(parent: parent)
+        end
+
+        target_index = siblings.index { |s| s.id == target.id }
+        raise Error, "Invalid creatives" if target_index.nil?
+
+        insert_index = direction == "up" ? target_index : target_index + 1
+        insert_index = [ [ insert_index, 0 ].max, siblings.size ].min
+
+        siblings.insert(insert_index, *dragged_creatives)
+        resequence!(siblings)
+      end
+    end
+
+    def sibling_scope(parent)
+      parent ? parent.children.order(:sequence).to_a : Creative.roots.order(:sequence).to_a
+    end
+
+    def resequence!(creatives)
+      creatives.each_with_index do |creative, idx|
+        creative.update_column(:sequence, idx)
+      end
+    end
+  end
+end
+end