collavre_plan 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1f4d20acde286797f3e083741480a5c654a0c93f9a674c09cedfc5bc7865f55
+  data.tar.gz: 81034f4bd8a3e0c6b36bd8d59786fbae8f5f0e141fcf34c29d88fce8feadf199
+SHA512:
+  metadata.gz: 6a366c4ef91d21b2caba0215f42ac7a1489b9b5ed251039da6baf12858b7f0de7e0cca533a3783d7d21f3839aa642811dc86e62a75522333f882a3bd1d30652f
+  data.tar.gz: e75dd6df51d244be43629f6ac461493810c71d61e6b4db42d8261d1dd574c71deb1b50b328cfc8ce5015c4ac2a10c0d7e55dde085f880d6a29cfb37e9ab1c9af

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/setup"
+require "bundler/gem_tasks"

data/app/components/collavre/plans_timeline_component.html.erb

@@ -0,0 +1,14 @@
+<div class="plans-timeline-wrapper">
+  <button id="timeline-today-btn" class="btn btn-xs" type="button"><%= t('collavre.plans.today', default: '오늘') %></button>
+  <div id="plans-timeline" class="horizontal-timeline" data-plans='<%= raw plan_data.to_json %>' data-start-date="<%= @start_date %>" data-end-date="<%= @end_date %>" data-delete-confirm="<%= t('collavre.plans.delete_confirm', default: 'Are you sure?') %>"></div>
+</div>
+<hr>
+<div class="plan-form-container">
+<%= form_with(model: Collavre::Plan.new, url: CollavrePlan::Engine.routes.url_helpers.plans_path, local: true, id: 'new-plan-form') do |form| %>
+    <%= form.hidden_field :creative_id, id: 'plan-creative-id' %>
+    <input type="text" id="plan-select-creative-input" placeholder="<%= t('collavre.plans.select_creative', default: 'Select Creative') %>" autocomplete="off">
+    <%= form.date_field :start_date, placeholder: t('collavre.plans.start_date'), id: 'plan-start-date' %>
+    <%= form.date_field :target_date, placeholder: t('collavre.plans.target_date'), id: 'plan-target-date' %>
+    <%= form.submit t('collavre.plans.add_plan'), id: 'add-plan-btn', class: 'btn btn-sm btn-primary', disabled: true %>
+<% end %>
+</div>

data/app/components/collavre/plans_timeline_component.rb

@@ -0,0 +1,53 @@
+module Collavre
+class PlansTimelineComponent < ViewComponent::Base
+  # Accepts pre-filtered plans and calendar_events from the controller
+  def initialize(plans:, calendar_events: Collavre::CalendarEvent.none)
+    @start_date = Date.current - 30
+    @end_date = Date.current + 30
+    @plans = plans
+    @calendar_events = calendar_events
+  end
+
+  attr_reader :plans, :calendar_events, :start_date, :end_date
+
+  # Called after component enters render context - safe to use helpers here
+  def plan_data
+    @plan_data ||= @plans.map { |plan| plan_item(plan) } + @calendar_events.map { |event| calendar_item(event) }
+  end
+
+  private
+
+  def plan_item(plan)
+    {
+      id: plan.id,
+      name: (plan.creative&.effective_description(nil, false) || plan.name.presence || I18n.l(plan.target_date)),
+      created_at: plan.created_at.to_date,
+      start_date: plan.start_date,
+      target_date: plan.target_date,
+      progress: plan.progress,
+      path: plan_creatives_path(plan),
+      deletable: plan.owner_id == Current.user&.id
+    }
+  end
+
+  def calendar_item(event)
+    {
+      id: "calendar_event_#{event.id}",
+      name: event.summary.presence || I18n.l(event.start_time.to_date),
+      created_at: event.start_time.to_date,
+      target_date: event.end_time.to_date,
+      progress: event.creative&.progress || 0,
+      path: event.creative ? helpers.collavre.creative_path(event.creative) : event.html_link,
+      deletable: event.user_id == Current.user&.id
+    }
+  end
+
+  def plan_creatives_path(plan)
+    if helpers.params[:id].present?
+      helpers.collavre.creative_path(helpers.params[:id], tags: [ plan.id ])
+    else
+      helpers.collavre.creatives_path(tags: [ plan.id ])
+    end
+  end
+end
+end

data/app/controllers/collavre_plan/application_controller.rb

@@ -0,0 +1,4 @@
+module CollavrePlan
+  class ApplicationController < Collavre::ApplicationController
+  end
+end

data/app/controllers/collavre_plan/creative_plans_controller.rb

@@ -0,0 +1,69 @@
+module CollavrePlan
+  class CreativePlansController < ApplicationController
+    before_action :require_authentication
+
+    def create
+      result = tagger.apply
+      respond_to do |format|
+        format.html do
+          flash[result.success? ? :notice : :alert] = translate_message(
+            result,
+            success_key: "collavre.creatives.index.plan_tags_applied",
+            success_default: "Plan tags applied to selected creatives.",
+            failure_key: "collavre.creatives.index.plan_tag_failed",
+            failure_default: "Please select a plan and at least one creative."
+          )
+          redirect_back fallback_location: Collavre::Engine.routes.url_helpers.creatives_path(select_mode: 1)
+        end
+        format.json do
+          if result.success?
+            render json: { message: translate_message(result, success_key: "collavre.creatives.index.plan_tags_applied", success_default: "Plan tags applied.", failure_key: "", failure_default: "") }, status: :ok
+          else
+            render json: { error: translate_message(result, success_key: "", success_default: "", failure_key: "collavre.creatives.index.plan_tag_failed", failure_default: "Failed to apply plan.") }, status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
+    def destroy
+      result = tagger.remove
+      respond_to do |format|
+        format.html do
+          flash[result.success? ? :notice : :alert] = translate_message(
+            result,
+            success_key: "collavre.creatives.index.plan_tags_removed",
+            success_default: "Plan tag removed from selected creatives.",
+            failure_key: "collavre.creatives.index.plan_tag_remove_failed",
+            failure_default: "Please select a plan and at least one creative."
+          )
+          redirect_back fallback_location: Collavre::Engine.routes.url_helpers.creatives_path(select_mode: 1)
+        end
+        format.json do
+          if result.success?
+            render json: { message: translate_message(result, success_key: "collavre.creatives.index.plan_tags_removed", success_default: "Plan tag removed.", failure_key: "", failure_default: "") }, status: :ok
+          else
+            render json: { error: translate_message(result, success_key: "", success_default: "", failure_key: "collavre.creatives.index.plan_tag_remove_failed", failure_default: "Failed to remove plan.") }, status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
+    private
+
+    def tagger
+      Collavre::Creatives::PlanTagger.new(plan_id: params[:plan_id], creative_ids: parsed_creative_ids, user: Current.user)
+    end
+
+    def parsed_creative_ids
+      params[:creative_ids].to_s.split(",").map(&:strip).reject(&:blank?)
+    end
+
+    def translate_message(result, success_key:, success_default:, failure_key:, failure_default:)
+      if result.success?
+        I18n.t(success_key, default: success_default)
+      else
+        I18n.t(failure_key, default: failure_default)
+      end
+    end
+  end
+end

data/app/controllers/collavre_plan/plans_controller.rb

@@ -0,0 +1,170 @@
+module CollavrePlan
+  class PlansController < ApplicationController
+    def index
+      center = if params[:date].present?
+                  Date.parse(params[:date]) rescue Date.current
+      else
+                  Date.current
+      end
+      start_date = center - 30
+      end_date = center + 30
+      @plans = Collavre::Plan.joins(:creative)
+                   .where("target_date >= ? AND DATE(creatives.created_at) <= ?", start_date, end_date)
+                   .order(Arel.sql("DATE(creatives.created_at) ASC"))
+                   .select { |plan| plan.readable_by?(Current.user) }
+      calendar_scope = Collavre::CalendarEvent.includes(:creative)
+                                    .where("DATE(start_time) <= ? AND DATE(end_time) >= ?", end_date, start_date)
+                                    .order(:start_time)
+      events_in_scope = calendar_scope.to_a
+      own_events = events_in_scope.select { |event| event.user_id == Current.user.id }
+      shared_events = events_in_scope.reject { |event| event.user_id == Current.user.id }
+                                     .select { |event| event.creative&.has_permission?(Current.user, :write) }
+      @calendar_events = (own_events + shared_events).uniq.sort_by(&:start_time)
+      respond_to do |format|
+        format.html do
+          render html: render_to_string(Collavre::PlansTimelineComponent.new(plans: @plans, calendar_events: @calendar_events), layout: false)
+        end
+        format.json do
+          plan_jsons = @plans.map { |p| plan_json(p) }
+          event_jsons = @calendar_events.map { |e| calendar_json(e) }
+          render json: plan_jsons + event_jsons
+        end
+      end
+    end
+
+    def create
+      @plan = Collavre::Plan.new(plan_params)
+      @plan.owner = Current.user
+      if @plan.save
+        respond_to do |format|
+          format.html do
+            redirect_back fallback_location: main_app.root_path, notice: t("collavre.plans.created")
+          end
+          format.json do
+            render json: plan_json(@plan), status: :created
+          end
+        end
+      else
+        respond_to do |format|
+          format.html do
+            flash[:alert] = @plan.errors.full_messages.join(", ")
+            redirect_back fallback_location: main_app.root_path
+          end
+          format.json do
+            render json: { errors: @plan.errors.full_messages }, status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
+    def destroy
+      @plan = Collavre::Plan.find(params[:id])
+      return render_forbidden unless plan_editable_by_current_user?
+
+      @plan.destroy
+      respond_to do |format|
+        format.html do
+          redirect_back fallback_location: main_app.root_path,
+                        notice: t("collavre.plans.deleted", default: "Plan deleted.")
+        end
+        format.json { head :no_content }
+      end
+    end
+
+    def update
+      @plan = Collavre::Plan.find(params[:id])
+      return render_forbidden unless plan_editable_by_current_user?
+
+      if @plan.update(plan_update_params)
+        respond_to do |format|
+          format.html do
+            redirect_back fallback_location: main_app.root_path,
+                          notice: t("collavre.plans.updated", default: "Plan updated.")
+          end
+          format.json do
+            render json: plan_json(@plan, creative_id: params[:creative_id] || @plan.creative_id), status: :ok
+          end
+        end
+      else
+        respond_to do |format|
+          format.html do
+            flash[:alert] = @plan.errors.full_messages.join(", ")
+            redirect_back fallback_location: main_app.root_path
+          end
+          format.json do
+            render json: { errors: @plan.errors.full_messages }, status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
+    private
+
+    def plan_params
+      params.require(:plan).permit(:target_date, :start_date, :creative_id)
+    end
+
+    def plan_update_params
+      params.require(:plan).permit(:target_date, :start_date)
+    end
+
+    def plan_editable_by_current_user?
+      return true if @plan.owner_id == Current.user&.id
+      return true if @plan.creative&.has_permission?(Current.user, :write)
+
+      tagged_creative = Collavre::Creative.find_by(id: params[:creative_id])
+      return false unless tagged_creative
+      return false unless @plan.tags.exists?(creative_id: tagged_creative.id)
+
+      tagged_creative.has_permission?(Current.user, :write)
+    end
+
+    def render_forbidden
+      respond_to do |format|
+        format.html do
+          redirect_back fallback_location: main_app.root_path,
+                        alert: t("collavre.plans.update_forbidden", default: "You do not have permission to update this plan.")
+        end
+        format.json do
+          render json: { error: "forbidden" }, status: :forbidden
+        end
+      end
+    end
+
+    def plan_json(plan, creative_id: nil)
+      {
+        id: plan.id,
+        name: (plan.creative&.effective_description(nil, false) || plan.name.presence || I18n.l(plan.target_date)),
+        created_at: plan.created_at.to_date,
+        start_date: plan.start_date,
+        target_date: plan.target_date,
+        progress: plan.progress,
+        path: plan_creatives_path(plan, creative_id: creative_id),
+        deletable: plan.owner_id == Current.user&.id
+      }
+    end
+
+    def calendar_json(event)
+      {
+        id: "calendar_event_#{event.id}",
+        name: event.summary.presence || I18n.l(event.start_time.to_date),
+        created_at: event.start_time.to_date,
+        target_date: event.end_time.to_date,
+        progress: event.creative&.progress || 0,
+        path: event.creative ? Collavre::Engine.routes.url_helpers.creative_path(event.creative) : event.html_link,
+        deletable: event.user_id == Current.user&.id
+      }
+    end
+
+    def plan_creatives_path(plan, creative_id: nil)
+      collavre_routes = Collavre::Engine.routes.url_helpers
+      if creative_id.present?
+        collavre_routes.creative_path(creative_id, tags: [ plan.id ])
+      elsif params[:id].present?
+        collavre_routes.creative_path(params[:id], tags: [ plan.id ])
+      else
+        collavre_routes.creatives_path(tags: [ plan.id ])
+      end
+    end
+  end
+end

data/app/javascript/collavre_plan.js

@@ -0,0 +1,8 @@
+// CollavrePlan Engine - Main Entry Point
+
+// Import side-effect modules
+import "./modules/plans_timeline"
+import "./modules/plans_menu"
+
+// Export controller registration
+export { registerControllers } from "./controllers"

data/app/javascript/controllers/creatives/set_plan_modal_controller.js

@@ -0,0 +1,124 @@
+import { Controller } from '@hotwired/stimulus'
+
+// Self-contained controller: attaches to the modal wrapper element
+// and listens for 'plan:open-modal' on document for cross-element communication.
+export default class extends Controller {
+  static targets = ['modal', 'form', 'idsInput', 'planSelect']
+  static values = {
+    selectOne: String,
+    selectPlan: String,
+  }
+
+  connect() {
+    this._openHandler = () => this._open()
+    document.addEventListener('plan:open-modal', this._openHandler)
+  }
+
+  disconnect() {
+    document.removeEventListener('plan:open-modal', this._openHandler)
+  }
+
+  // Called via document event from the set-plan button
+  _open() {
+    if (!this.hasModalTarget) return
+    this.modalTarget.style.display = 'flex'
+    document.body.classList.add('no-scroll')
+  }
+
+  // Can still be called via data-action for elements inside the controller scope
+  open(event) {
+    event.preventDefault()
+    this._open()
+  }
+
+  close(event) {
+    if (event) event.preventDefault()
+    if (!this.hasModalTarget) return
+    this.modalTarget.style.display = 'none'
+    document.body.classList.remove('no-scroll')
+  }
+
+  backdrop(event) {
+    if (event.target === this.modalTarget) {
+      this.close(event)
+    }
+  }
+
+  async submit(event) {
+    event.preventDefault()
+    if (!this.hasFormTarget || !this.hasIdsInputTarget) return
+    const ids = this.selectedIds()
+
+    if (ids.length === 0) {
+      this.alert(this.selectOneValue)
+      return
+    }
+
+    const planId = this.planSelectTarget.value
+    if (!planId) {
+      this.alert(this.selectPlanValue)
+      return
+    }
+
+    await this.performRequest(this.formTarget.action, 'POST', {
+      plan_id: planId,
+      creative_ids: ids.join(',')
+    })
+  }
+
+  async remove(event) {
+    event.preventDefault()
+    const ids = this.selectedIds()
+    if (ids.length === 0) {
+      this.alert(this.selectOneValue)
+      return
+    }
+
+    const planId = this.planSelectTarget.value
+    if (!planId) {
+      this.alert(this.selectPlanValue)
+      return
+    }
+
+    await this.performRequest(event.currentTarget.dataset.removePath, 'DELETE', {
+      plan_id: planId,
+      creative_ids: ids.join(',')
+    })
+  }
+
+  async performRequest(url, method, body) {
+    try {
+      const csrfToken = document.querySelector('meta[name="csrf-token"]')?.content
+      const response = await fetch(url, {
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'X-CSRF-Token': csrfToken
+        },
+        body: JSON.stringify(body)
+      })
+
+      if (response.ok) {
+        const data = await response.json()
+        this.alert(data.message)
+        this.close()
+      } else {
+        const data = await response.json()
+        this.alert(data.error || 'Operation failed')
+      }
+    } catch (error) {
+      console.error(error)
+      this.alert('An unexpected error occurred.')
+    }
+  }
+
+  selectedIds() {
+    return Array.from(document.querySelectorAll('.select-creative-checkbox:checked')).map((checkbox) => checkbox.value)
+  }
+
+  alert(message) {
+    if (!message) return
+    window.alert(message)
+  }
+}

data/app/javascript/controllers/index.js

@@ -0,0 +1,6 @@
+// CollavrePlan Engine Controllers
+import CreativesSetPlanModalController from "./creatives/set_plan_modal_controller"
+
+export function registerControllers(application) {
+  application.register("creatives--set-plan-modal", CreativesSetPlanModalController)
+}

data/app/javascript/modules/plans_menu.js

@@ -0,0 +1,50 @@
+// Plans menu functionality
+// Handles the plans menu button click and lazy-loads plans data
+
+import { notifyPopupOpen, onOtherPopupOpen } from 'collavre/lib/gnb_popup_manager'
+
+const POPUP_ID = 'plans-menu'
+let initialized = false
+
+function initPlansMenu() {
+  if (initialized) return
+  initialized = true
+
+  document.addEventListener('turbo:load', function() {
+    const btns = document.querySelectorAll('.plans-menu-btn')
+    const area = document.getElementById('plans-list-area')
+    let loaded = false
+    const timeline = document.getElementById('plans-timeline')
+
+    function closePlans() {
+      if (area) area.style.display = 'none'
+    }
+
+    onOtherPopupOpen(POPUP_ID, closePlans)
+
+    btns.forEach(function(btn) {
+      btn.addEventListener('click', function() {
+        if (area.style.display === 'none') {
+          notifyPopupOpen(POPUP_ID)
+          area.style.display = 'block'
+          if (!loaded) {
+            const plansUrl = area.dataset.plansUrl || '/plans.json'
+            fetch(plansUrl)
+              .then(function(r) { return r.json() })
+              .then(function(plans) {
+                if (timeline) { timeline.dataset.plans = JSON.stringify(plans) }
+                if (window.initPlansTimeline && timeline) {
+                  window.initPlansTimeline(timeline)
+                }
+                loaded = true
+              })
+          }
+        } else {
+          area.style.display = 'none'
+        }
+      })
+    })
+  })
+}
+
+initPlansMenu()