@canmingir/link 1.1.0

package/minimal/src/api/calendar.js

@@ -0,0 +1,115 @@
+import { useMemo } from 'react';
+import useSWR, { mutate } from 'swr';
+
+import { fetcher, endpoints } from 'src/utils/axios';
+
+// ----------------------------------------------------------------------
+
+const URL = endpoints.calendar;
+
+const options = {
+  revalidateIfStale: false,
+  revalidateOnFocus: false,
+  revalidateOnReconnect: false,
+};
+
+export function useGetEvents() {
+  const { data, isLoading, error, isValidating } = useSWR(URL, fetcher, options);
+
+  const memoizedValue = useMemo(() => {
+    const events = data?.events.map((event) => ({
+      ...event,
+      textColor: event.color,
+    }));
+
+    return {
+      events: events || [],
+      eventsLoading: isLoading,
+      eventsError: error,
+      eventsValidating: isValidating,
+      eventsEmpty: !isLoading && !data?.events.length,
+    };
+  }, [data?.events, error, isLoading, isValidating]);
+
+  return memoizedValue;
+}
+
+// ----------------------------------------------------------------------
+
+export async function createEvent(eventData) {
+  /**
+   * Work on server
+   */
+  // const data = { eventData };
+  // await axios.post(URL, data);
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const events = [...currentData.events, eventData];
+
+      return {
+        ...currentData,
+        events,
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function updateEvent(eventData) {
+  /**
+   * Work on server
+   */
+  // const data = { eventData };
+  // await axios.put(endpoints.calendar, data);
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const events = currentData.events.map((event) =>
+        event.id === eventData.id ? { ...event, ...eventData } : event
+      );
+
+      return {
+        ...currentData,
+        events,
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function deleteEvent(eventId) {
+  /**
+   * Work on server
+   */
+  // const data = { eventId };
+  // await axios.patch(endpoints.calendar, data);
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const events = currentData.events.filter((event) => event.id !== eventId);
+
+      return {
+        ...currentData,
+        events,
+      };
+    },
+    false
+  );
+}

package/minimal/src/api/chat.js

@@ -0,0 +1,206 @@
+import { useMemo } from 'react';
+import keyBy from 'lodash/keyBy';
+import useSWR, { mutate } from 'swr';
+
+import axios, { fetcher, endpoints } from 'src/utils/axios';
+
+// ----------------------------------------------------------------------
+
+const options = {
+  revalidateIfStale: false,
+  revalidateOnFocus: false,
+  revalidateOnReconnect: false,
+};
+
+export function useGetContacts() {
+  const URL = [endpoints.chat, { params: { endpoint: 'contacts' } }];
+
+  const { data, isLoading, error, isValidating } = useSWR(URL, fetcher, options);
+
+  const memoizedValue = useMemo(
+    () => ({
+      contacts: data?.contacts || [],
+      contactsLoading: isLoading,
+      contactsError: error,
+      contactsValidating: isValidating,
+      contactsEmpty: !isLoading && !data?.contacts.length,
+    }),
+    [data?.contacts, error, isLoading, isValidating]
+  );
+
+  return memoizedValue;
+}
+
+// ----------------------------------------------------------------------
+
+export function useGetConversations() {
+  const URL = [endpoints.chat, { params: { endpoint: 'conversations' } }];
+
+  const { data, isLoading, error, isValidating } = useSWR(URL, fetcher, options);
+
+  const memoizedValue = useMemo(() => {
+    const byId = keyBy(data?.conversations, 'id') || {};
+    const allIds = Object.keys(byId) || [];
+
+    return {
+      conversations: {
+        byId,
+        allIds,
+      },
+      conversationsLoading: isLoading,
+      conversationsError: error,
+      conversationsValidating: isValidating,
+      conversationsEmpty: !isLoading && !allIds.length,
+    };
+  }, [data?.conversations, error, isLoading, isValidating]);
+
+  return memoizedValue;
+}
+
+// ----------------------------------------------------------------------
+
+export function useGetConversation(conversationId) {
+  const URL = conversationId
+    ? [endpoints.chat, { params: { conversationId, endpoint: 'conversation' } }]
+    : '';
+
+  const { data, isLoading, error, isValidating } = useSWR(URL, fetcher, options);
+
+  const memoizedValue = useMemo(
+    () => ({
+      conversation: data?.conversation,
+      conversationLoading: isLoading,
+      conversationError: error,
+      conversationValidating: isValidating,
+    }),
+    [data?.conversation, error, isLoading, isValidating]
+  );
+
+  return memoizedValue;
+}
+
+// ----------------------------------------------------------------------
+
+export async function sendMessage(conversationId, messageData) {
+  const CONVERSATIONS_URL = [endpoints.chat, { params: { endpoint: 'conversations' } }];
+
+  const CONVERSATION_URL = [
+    endpoints.chat,
+    {
+      params: { conversationId, endpoint: 'conversation' },
+    },
+  ];
+
+  /**
+   * Work on server
+   */
+  // const data = { conversationId, messageData };
+  // await axios.put(endpoints.chat, data);
+
+  /**
+   * Work in local
+   */
+  mutate(
+    CONVERSATION_URL,
+    (currentData) => {
+      const { conversation: currentConversation } = currentData;
+
+      const conversation = {
+        ...currentConversation,
+        messages: [...currentConversation.messages, messageData],
+      };
+
+      return {
+        conversation,
+      };
+    },
+    false
+  );
+
+  /**
+   * Work in local
+   */
+  mutate(
+    CONVERSATIONS_URL,
+    (currentData) => {
+      const { conversations: currentConversations } = currentData;
+
+      const conversations = currentConversations.map((conversation) =>
+        conversation.id === conversationId
+          ? {
+              ...conversation,
+              messages: [...conversation.messages, messageData],
+            }
+          : conversation
+      );
+
+      return {
+        conversations,
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function createConversation(conversationData) {
+  const URL = [endpoints.chat, { params: { endpoint: 'conversations' } }];
+
+  /**
+   * Work on server
+   */
+  const data = { conversationData };
+  const res = await axios.post(endpoints.chat, data);
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const conversations = [...currentData.conversations, conversationData];
+      return {
+        ...currentData,
+        conversations,
+      };
+    },
+    false
+  );
+
+  return res.data;
+}
+
+// ----------------------------------------------------------------------
+
+export async function clickConversation(conversationId) {
+  const URL = endpoints.chat;
+
+  /**
+   * Work on server
+   */
+  // await axios.get(URL, { params: { conversationId, endpoint: 'mark-as-seen' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    [
+      URL,
+      {
+        params: { endpoint: 'conversations' },
+      },
+    ],
+    (currentData) => {
+      const conversations = currentData.conversations.map((conversation) =>
+        conversation.id === conversationId ? { ...conversation, unreadCount: 0 } : conversation
+      );
+
+      return {
+        ...currentData,
+        conversations,
+      };
+    },
+    false
+  );
+}

package/minimal/src/api/kanban.js

@@ -0,0 +1,401 @@
+import { useMemo } from 'react';
+import useSWR, { mutate } from 'swr';
+
+import { fetcher, endpoints } from 'src/utils/axios';
+
+// ----------------------------------------------------------------------
+
+const URL = endpoints.kanban;
+
+const options = {
+  revalidateIfStale: false,
+  revalidateOnFocus: false,
+  revalidateOnReconnect: false,
+};
+
+export function useGetBoard() {
+  const { data, isLoading, error, isValidating } = useSWR(URL, fetcher, options);
+
+  const memoizedValue = useMemo(
+    () => ({
+      board: data?.board,
+      boardLoading: isLoading,
+      boardError: error,
+      boardValidating: isValidating,
+      boardEmpty: !isLoading && !data?.board.ordered.length,
+    }),
+    [data?.board, error, isLoading, isValidating]
+  );
+
+  return memoizedValue;
+}
+
+// ----------------------------------------------------------------------
+
+export async function createColumn(columnData) {
+  /**
+   * Work on server
+   */
+  // const data = { columnData };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'create-column' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      const columns = {
+        ...board.columns,
+        // add new column in board.columns
+        [columnData.id]: columnData,
+      };
+
+      // add new column in board.ordered
+      const ordered = [...board.ordered, columnData.id];
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+          ordered,
+        },
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function updateColumn(columnId, columnName) {
+  /**
+   * Work on server
+   */
+  // const data = { columnId, columnName };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'update-column' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      // current column
+      const column = board.columns[columnId];
+
+      const columns = {
+        ...board.columns,
+        // update column in board.columns
+        [column.id]: {
+          ...column,
+          name: columnName,
+        },
+      };
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+        },
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function moveColumn(newOrdered) {
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      // update ordered in board.ordered
+      const ordered = newOrdered;
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          ordered,
+        },
+      };
+    },
+    false
+  );
+
+  /**
+   * Work on server
+   */
+  // const data = { newOrdered };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'move-column' } });
+}
+
+// ----------------------------------------------------------------------
+
+export async function clearColumn(columnId) {
+  /**
+   * Work on server
+   */
+  // const data = { columnId };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'clear-column' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      const { tasks } = board;
+
+      // current column
+      const column = board.columns[columnId];
+
+      // delete tasks in board.tasks
+      column.taskIds.forEach((key) => {
+        delete tasks[key];
+      });
+
+      const columns = {
+        ...board.columns,
+        [column.id]: {
+          ...column,
+          // delete task in column
+          taskIds: [],
+        },
+      };
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+          tasks,
+        },
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function deleteColumn(columnId) {
+  /**
+   * Work on server
+   */
+  // const data = { columnId };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'delete-column' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      const { columns, tasks } = board;
+
+      // current column
+      const column = columns[columnId];
+
+      // delete column in board.columns
+      delete columns[columnId];
+
+      // delete tasks in board.tasks
+      column.taskIds.forEach((key) => {
+        delete tasks[key];
+      });
+
+      // delete column in board.ordered
+      const ordered = board.ordered.filter((id) => id !== columnId);
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+          tasks,
+          ordered,
+        },
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function createTask(columnId, taskData) {
+  /**
+   * Work on server
+   */
+  // const data = { columnId, taskData };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'create-task' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      // current column
+      const column = board.columns[columnId];
+
+      const columns = {
+        ...board.columns,
+        [columnId]: {
+          ...column,
+          // add task in column
+          taskIds: [...column.taskIds, taskData.id],
+        },
+      };
+
+      // add task in board.tasks
+      const tasks = {
+        ...board.tasks,
+        [taskData.id]: taskData,
+      };
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+          tasks,
+        },
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function updateTask(taskData) {
+  /**
+   * Work on server
+   */
+  // const data = { taskData };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'update-task' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      const tasks = {
+        ...board.tasks,
+        // add task in board.tasks
+        [taskData.id]: taskData,
+      };
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          tasks,
+        },
+      };
+    },
+    false
+  );
+}
+
+// ----------------------------------------------------------------------
+
+export async function moveTask(updateColumns) {
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      // update board.columns
+      const columns = updateColumns;
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+        },
+      };
+    },
+    false
+  );
+
+  /**
+   * Work on server
+   */
+  // const data = { updateColumns };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'move-task' } });
+}
+
+// ----------------------------------------------------------------------
+
+export async function deleteTask(columnId, taskId) {
+  /**
+   * Work on server
+   */
+  // const data = { columnId, taskId };
+  // await axios.post(endpoints.kanban, data, { params: { endpoint: 'delete-task' } });
+
+  /**
+   * Work in local
+   */
+  mutate(
+    URL,
+    (currentData) => {
+      const { board } = currentData;
+
+      const { tasks } = board;
+
+      // current column
+      const column = board.columns[columnId];
+
+      const columns = {
+        ...board.columns,
+        [column.id]: {
+          ...column,
+          // delete tasks in column
+          taskIds: column.taskIds.filter((id) => id !== taskId),
+        },
+      };
+
+      // delete tasks in board.tasks
+      delete tasks[taskId];
+
+      return {
+        ...currentData,
+        board: {
+          ...board,
+          columns,
+          tasks,
+        },
+      };
+    },
+    false
+  );
+}