akfatimeline 1.0.4 → 1.0.6

package/public/dist/dist/hooks/useDragAndDrop.js

@@ -0,0 +1,80 @@
+// src/hooks/useDragAndDrop.js
+import { useState } from "react";
+import { parseDate } from "../utils/dateUtils"; // Named import
+
+const useDragAndDrop = (initialEvents = []) => {
+    const [isDragging, setIsDragging] = useState(false);
+    const [dragStart, setDragStart] = useState(null);
+    const [dragEnd, setDragEnd] = useState(null);
+    const [events, setEvents] = useState(initialEvents);
+
+    // Sürükleme başlat
+    const startDrag = (resourceId, date) => {
+        setIsDragging(true);
+        setDragStart({ resourceId, date });
+        setDragEnd({ resourceId, date });
+    };
+
+    // Sürükleme hareketi
+    const updateDrag = (resourceId, date) => {
+        if (!isDragging) return;
+        setDragEnd({ resourceId, date });
+    };
+
+    // Sürükleme bitişi
+    const endDrag = (dates) => {
+        if (!isDragging || !dragStart || !dragEnd) return;
+        if (dragStart.resourceId !== dragEnd.resourceId) {
+            resetDrag();
+            return;
+        }
+
+        const startDateIndex = dates.findIndex(
+            (d) => parseDate(d.fullDate).toDateString() === parseDate(dragStart.date.fullDate).toDateString()
+        );
+        const endDateIndex = dates.findIndex(
+            (d) => parseDate(d.fullDate).toDateString() === parseDate(dragEnd.date.fullDate).toDateString()
+        );
+
+        if (startDateIndex === -1 || endDateIndex === -1) {
+            resetDrag();
+            return;
+        }
+
+        const sortedStartIndex = Math.min(startDateIndex, endDateIndex);
+        const sortedEndIndex = Math.max(startDateIndex, endDateIndex);
+        const startDate = dates[sortedStartIndex].fullDate;
+        const endDate = dates[sortedEndIndex].fullDate;
+
+        const newEvent = {
+            id: Date.now(),
+            title: "Yeni Etkinlik",
+            resourceId: dragStart.resourceId,
+            startDate: startDate,
+            endDate: endDate,
+            color: "#ff7f50",
+        };
+
+        setEvents((prev) => [...prev, newEvent]);
+        resetDrag();
+    };
+
+    const resetDrag = () => {
+        setIsDragging(false);
+        setDragStart(null);
+        setDragEnd(null);
+    };
+
+    return {
+        events,
+        isDragging,
+        dragStart,
+        dragEnd,
+        startDrag,
+        updateDrag,
+        endDrag,
+        setEvents,
+    };
+};
+
+export default useDragAndDrop;

package/public/dist/dist/hooks/useEventDragDrop.js

@@ -0,0 +1,126 @@
+import { useState } from "react";
+
+const useEventDragDrop = (events, setEvents, setDropInfo) => {
+  const [draggingEvent, setDraggingEvent] = useState(null);
+  const [dragOffset, setDragOffset] = useState(0);
+  const [mode, setMode] = useState(null); // "drag" veya "extend"
+
+  const handleDragStart = (event, eventId) => {
+    if (mode === "extend") return; // Uzatma modundaysa taşıma işlemini başlatma
+
+    event.stopPropagation();
+
+    const eventElement = event.target;
+    const eventRect = eventElement.getBoundingClientRect();
+    const offset = event.clientX - eventRect.left;
+
+    setDraggingEvent(eventId);
+    setDragOffset(offset);
+    setMode("drag"); // Modu taşıma olarak ayarla
+
+    const draggedEvent = events.find((evt) => evt.id === eventId);
+    if (draggedEvent) {
+      console.log("Dragging Event Start:", draggedEvent.startDate);
+      console.log("Dragging Event End:", draggedEvent.endDate);
+    }
+  };
+
+  const handleExtendStart = (event, eventId) => {
+    event.stopPropagation();
+
+    setDraggingEvent(eventId);
+    setMode("extend"); // Modu uzatma olarak ayarla
+  };
+
+  const handleDragOver = (event) => {
+    event.preventDefault();
+  };
+
+  const handleDrop = (event, resourceId, targetDate) => {
+    event.preventDefault();
+  
+    if (mode === "drag" && draggingEvent) {
+      const draggedEvent = events.find((evt) => evt.id === draggingEvent);
+  
+      if (draggedEvent) {
+        const duration = draggedEvent.endDate - draggedEvent.startDate;
+        const cellWidth = event.target.offsetWidth || 30;
+        const offsetDays = Math.floor(dragOffset / cellWidth);
+        const newStartDate = new Date(targetDate.getTime() - offsetDays * 24 * 60 * 60 * 1000);
+        const newEndDate = new Date(newStartDate.getTime() + duration);
+  
+        // Callback kontrolü ve loglama
+        if (setDropInfo) {
+          console.log("setDropInfo is being called with:", {
+            id: draggingEvent,
+            newResourceId: resourceId,
+            newStartDate,
+            newEndDate,
+          });
+          setDropInfo({
+            id: draggingEvent,
+            newResourceId: resourceId,
+            newStartDate,
+            newEndDate,
+          });
+        }
+  
+        // Event güncellemesi
+        setEvents((prevEvents) =>
+          prevEvents.map((evt) =>
+            evt.id === draggingEvent
+              ? {
+                  ...evt,
+                  resourceId,
+                  startDate: newStartDate,
+                  endDate: newEndDate,
+                }
+              : evt
+          )
+        );
+      }
+    }
+  
+    setDraggingEvent(null);
+    setDragOffset(0);
+    setMode(null);
+  };
+  
+
+  const handleExtend = (event, eventId, newEndDate) => {
+    if (mode !== "extend" || draggingEvent !== eventId) return;
+
+    setEvents((prevEvents) =>
+      prevEvents.map((evt) =>
+        evt.id === eventId
+          ? {
+              ...evt,
+              endDate: newEndDate,
+            }
+          : evt
+      )
+    );
+
+    console.log("Extended Event ID:", eventId, "New End Date:", newEndDate);
+
+    setDraggingEvent(null);
+    setMode(null);
+  };
+
+  const handleDragEnd = () => {
+    setDraggingEvent(null);
+    setDragOffset(0);
+    setMode(null);
+  };
+
+  return {
+    handleDragStart,
+    handleExtendStart,
+    handleDragOver,
+    handleDrop,
+    handleExtend,
+    handleDragEnd,
+  };
+};
+
+export default useEventDragDrop;

package/public/dist/dist/hooks/useExtendEvent.js

@@ -0,0 +1,28 @@
+import { useCallback } from "react";
+
+const useExtendEvent = (events, setEvents) => {
+  /**
+   * Etkinliği uzatmak veya kısaltmak için kullanılan işlev.
+   * @param {number} eventId - Güncellenmesi gereken etkinliğin ID'si.
+   * @param {Date} newEndDate - Etkinliğin yeni bitiş tarihi.
+   */
+  const extendEvent = useCallback(
+    (eventId, newEndDate) => {
+      setEvents((prevEvents) =>
+        prevEvents.map((event) =>
+          event.id === eventId
+            ? {
+                ...event,
+                endDate: newEndDate, // Yeni bitiş tarihini günceller
+              }
+            : event // Diğer etkinlikler aynı kalır
+        )
+      );
+    },
+    [setEvents]
+  );
+
+  return { extendEvent };
+};
+
+export default useExtendEvent;

package/public/dist/dist/utils/dateUtils.js

@@ -0,0 +1,36 @@
+// src/utils/dateUtils.js
+
+/**
+ * "dd/mm/yyyy" formatındaki bir tarih string'ini Date objesine dönüştürür.
+ * Eğer dateInput bir string değilse, direkt Date objesini döndürür.
+ * @param {string | Object | Date} dateInput - "dd/mm/yyyy" formatında tarih stringi veya {fullDate: Date, display: string} objesi veya Date objesi.
+ * @returns {Date} - Date objesi.
+ */
+export const parseDate = (dateInput) => {
+  if (dateInput instanceof Date) {
+    return dateInput;
+  }
+  if (typeof dateInput === 'string') {
+    const [day, month, year] = dateInput.split("/").map(Number);
+    return new Date(year, month - 1, day);
+  } else if (typeof dateInput === 'object' && dateInput.fullDate instanceof Date) {
+    return new Date(dateInput.fullDate.getTime() + dateInput.fullDate.getTimezoneOffset() * 60000);
+  } else {
+    console.error("parseDate received invalid input:", dateInput);
+    return new Date(); // veya hata fırlat
+  }
+};
+
+/**
+ * Bir tarihin belirli bir aralık içinde olup olmadığını kontrol eder.
+ * @param {string | Object | Date} date - "dd/mm/yyyy" formatında tarih stringi, {fullDate: Date, display: string} objesi veya Date objesi.
+ * @param {string | Object | Date} startDate - "dd/mm/yyyy" formatında başlangıç tarihi stringi, {fullDate: Date, display: string} objesi veya Date objesi.
+ * @param {string | Object | Date} endDate - "dd/mm/yyyy" formatında bitiş tarihi stringi, {fullDate: Date, display: string} objesi veya Date objesi.
+ * @returns {boolean} - Tarih aralık içinde ise true, değilse false.
+ */
+export const isDateInRange = (date, startDate, endDate) => {
+  const d = parseDate(date);
+  const start = parseDate(startDate);
+  const end = parseDate(endDate);
+  return d >= start && d <= end;
+};

package/public/dist/dist/utils/filterTimelineData.js

@@ -0,0 +1,21 @@
+const filterTimelineData = (dates, startDate, dayCount) => {
+    const startIndex = dates.findIndex(
+      (date) => date.fullDate.toISOString().split("T")[0] === startDate
+    );
+  
+    if (startIndex === -1) {
+      console.warn("Seçilen başlangıç tarihi bulunamadı.");
+      return { filteredDates: [] };
+    }
+  
+    const filteredDates = dates.slice(startIndex, startIndex + dayCount);
+  
+    return {
+      filteredDates,
+      startIndex,
+      endIndex: startIndex + dayCount - 1,
+    };
+  };
+  
+  export default filterTimelineData;
+  

package/public/dist/dist/utils/timelineUtils.js

@@ -0,0 +1,40 @@
+// src/utils/timelineUtils.js
+
+export const generateTimelineData = (startYear, endYear) => {
+    const dayNames = ["Paz", "Pzt", "Sal", "Çar", "Per", "Cum", "Cmt"];
+    const monthNames = [
+      "Ocak", "Şubat", "Mart", "Nisan", "Mayıs", "Haziran",
+      "Temmuz", "Ağustos", "Eylül", "Ekim", "Kasım", "Aralık",
+    ];
+  
+    const dates = [];
+    const monthHeaders = [];
+  
+    for (let year = startYear; year <= endYear; year++) {
+      for (let month = 1; month <= 12; month++) {
+        const daysInMonth = new Date(year, month, 0).getDate();
+        const startIndex = dates.length;
+  
+        for (let day = 1; day <= daysInMonth; day++) {
+          const date = new Date(year, month - 1, day);
+          const dayName = dayNames[date.getDay()];
+          dates.push({
+            fullDate: date,
+            display: `${day} ${dayName}`,
+          });
+        }
+  
+        const endIndex = dates.length - 1;
+        monthHeaders.push({
+          monthName: monthNames[month - 1],
+          year,
+          startIndex,
+          endIndex,
+          totalDays: endIndex - startIndex + 1,
+        });
+      }
+    }
+  
+    return { dates, monthHeaders };
+  };
+  

package/src/App.js

@@ -3,7 +3,7 @@ import Timeline from "./components/Timeline/Timeline";
 import EventTooltip from "./components/Timeline/EventTooltip"; // Tooltip bileşenini import ediyoruz
 
 const App = () => {
-  const programDate = "2025-01-02";
+  const programDate = "2025-01-08";
 
   const events = [
     {
@@ -200,6 +200,8 @@ const resources = [
         setDropInfo={handleDropInfo} // Callback'i buradan bağlıyoruz
         onExtendInfo={handleExtendInfo} // Uzatma bilgisi
         onCreateEventInfo={handleCreateEventInfo} // Yeni etkinlik bilgisi
+        indicatorDate="2025-01-09" // İstediğiniz tarihi gönderin
+
       />
     </div>
   );

package/src/components/Timeline/Indicator.js

@@ -2,12 +2,9 @@ import React from "react";
 
 const Indicator = ({ todayIndex, totalDays }) => {
   if (todayIndex < 0 || todayIndex >= totalDays) {
-    console.log("Indicator not visible: Out of bounds");
     return null; // Bugün timeline dışında ise çizgiyi gösterme
   }
 
-
-
   return (
     <div
       style={{

package/src/components/Timeline/Timeline.js

@@ -44,8 +44,8 @@ const Timeline = ({
   tooltipComponent: TooltipComponent, // Özelleştirilebilir Tooltip bileşeni
   tempEventStyle = {},
   eventStyleResolver = () => ({}),
-
-  onToday,
+  indicatorDate = new Date(),
+    onToday,
   onAdvance,
   onRetreat,
   onMonthAdvance,
@@ -125,10 +125,15 @@ const Timeline = ({
   const filteredDates =
     startIndex !== -1 ? dates.slice(startIndex, Math.min(endIndex, dates.length)) : [];
 
-  const today = programDate ? new Date(programDate) : new Date();
-  const todayIndex = filteredDates.findIndex(
-    (d) => new Date(d.fullDate).toDateString() === today.toDateString()
-  );
+    const today = programDate ? new Date(programDate) : new Date();
+    today.setDate(today.getDate() - 3);
+    
+
+    
+    const todayIndex = filteredDates.findIndex(
+      (d) => new Date(d.fullDate).toDateString() === new Date(indicatorDate).toDateString()
+    );
+
   const totalDays = filteredDates.length;
 
   // ---------------------------------------------------------
@@ -152,11 +157,12 @@ const Timeline = ({
   };
 
   const handleToday = () => {
-    const today = new Date();
-    today.setDate(today.getDate() - 3); // Bugünden 3 gün öncesini ayarla
+    const today = programDate ? new Date(programDate) : new Date();
+    today.setDate(today.getDate() - 3); // Program tarihinden 3 gün öncesini ayarla
     setSelectedDate(today);
   };
   
+  
 
   const handleAdvance = () => {
     setSelectedDate((prev) => new Date(prev.getTime() + 5 * 24 * 60 * 60 * 1000));
@@ -262,9 +268,8 @@ const Timeline = ({
               events={localEvents}
               setEvents={setLocalEvents}
               onEventClick={onEventClick}
-              todayIndex={filteredDates.findIndex(
-                (d) => new Date(d.fullDate).toDateString() === new Date().toDateString()
-              )}
+              
+              todayIndex={todayIndex}
               indicatorOn={indicatorOn}
               resourceSettings={resourceSettings}
               toggleGroupCollapse={toggleGroupCollapse}

package/src/components/Timeline/TimelineContent.js

@@ -202,7 +202,6 @@ const TimelineContent = ({
     const newEndDate = new Date((originalEndDate ?? new Date()).getTime());
     newEndDate.setDate(newEndDate.getDate() + daysToAdd);
 
-    console.log(">>> Extending ID:", extendingEvent.id, "=>", newEndDate);
 
     setEvents((prev) =>
       prev.map((evt) => (evt.id === extendingEvent.id ? { ...evt, endDate: newEndDate } : evt))