realtimex-crm 0.1.2

package/src/components/atomic-crm/providers/commons/activity.ts

@@ -0,0 +1,174 @@
+import type { DataProvider, Identifier } from "ra-core";
+
+import {
+  COMPANY_CREATED,
+  CONTACT_CREATED,
+  CONTACT_NOTE_CREATED,
+  DEAL_CREATED,
+  DEAL_NOTE_CREATED,
+} from "../../consts";
+import type {
+  Activity,
+  Company,
+  Contact,
+  ContactNote,
+  Deal,
+  DealNote,
+} from "../../types";
+
+// FIXME: Requires 5 large queries to get the latest activities.
+// Replace with a server-side view or a custom API endpoint.
+export async function getActivityLog(
+  dataProvider: DataProvider,
+  companyId?: Identifier,
+  salesId?: Identifier,
+) {
+  const companyFilter = {} as any;
+  if (companyId) {
+    companyFilter.id = companyId;
+  } else if (salesId) {
+    companyFilter["sales_id@in"] = `(${salesId})`;
+  }
+
+  const filter = {} as any;
+  if (companyId) {
+    filter.company_id = companyId;
+  } else if (salesId) {
+    filter["sales_id@in"] = `(${salesId})`;
+  }
+
+  const [newCompanies, newContactsAndNotes, newDealsAndNotes] =
+    await Promise.all([
+      getNewCompanies(dataProvider, companyFilter),
+      getNewContactsAndNotes(dataProvider, filter),
+      getNewDealsAndNotes(dataProvider, filter),
+    ]);
+  return (
+    [...newCompanies, ...newContactsAndNotes, ...newDealsAndNotes]
+      // sort by date desc
+      .sort((a, b) =>
+        a.date && b.date ? a.date.localeCompare(b.date) * -1 : 0,
+      )
+      // limit to 250 activities
+      .slice(0, 250)
+  );
+}
+
+const getNewCompanies = async (
+  dataProvider: DataProvider,
+  filter: any,
+): Promise<Activity[]> => {
+  const { data: companies } = await dataProvider.getList<Company>("companies", {
+    filter,
+    pagination: { page: 1, perPage: 250 },
+    sort: { field: "created_at", order: "DESC" },
+  });
+  return companies.map((company) => ({
+    id: `company.${company.id}.created`,
+    type: COMPANY_CREATED,
+    company_id: company.id,
+    company,
+    sales_id: company.sales_id,
+    date: company.created_at,
+  }));
+};
+
+async function getNewContactsAndNotes(
+  dataProvider: DataProvider,
+  filter: any,
+): Promise<Activity[]> {
+  const { data: contacts } = await dataProvider.getList<Contact>("contacts", {
+    filter,
+    pagination: { page: 1, perPage: 250 },
+    sort: { field: "first_seen", order: "DESC" },
+  });
+
+  const recentContactNotesFilter = {} as any;
+  if (filter.sales_id) {
+    recentContactNotesFilter.sales_id = filter.sales_id;
+  }
+  if (filter.company_id) {
+    // No company_id field in contactNote, filtering by related contacts instead.
+    // This filter is only valid if a company has less than 250 contact.
+    const contactIds = contacts.map((contact) => contact.id).join(",");
+    recentContactNotesFilter["contact_id@in"] = `(${contactIds})`;
+  }
+
+  const { data: contactNotes } = await dataProvider.getList<ContactNote>(
+    "contactNotes",
+    {
+      filter: recentContactNotesFilter,
+      pagination: { page: 1, perPage: 250 },
+      sort: { field: "date", order: "DESC" },
+    },
+  );
+
+  const newContacts = contacts.map((contact) => ({
+    id: `contact.${contact.id}.created`,
+    type: CONTACT_CREATED,
+    company_id: contact.company_id,
+    sales_id: contact.sales_id,
+    contact,
+    date: contact.first_seen,
+  }));
+
+  const newContactNotes = contactNotes.map((contactNote) => ({
+    id: `contactNote.${contactNote.id}.created`,
+    type: CONTACT_NOTE_CREATED,
+    sales_id: contactNote.sales_id,
+    contactNote,
+    date: contactNote.date,
+  }));
+
+  return [...newContacts, ...newContactNotes];
+}
+
+async function getNewDealsAndNotes(
+  dataProvider: DataProvider,
+  filter: any,
+): Promise<Activity[]> {
+  const { data: deals } = await dataProvider.getList<Deal>("deals", {
+    filter,
+    pagination: { page: 1, perPage: 250 },
+    sort: { field: "created_at", order: "DESC" },
+  });
+
+  const recentDealNotesFilter = {} as any;
+  if (filter.sales_id) {
+    recentDealNotesFilter.sales_id = filter.sales_id;
+  }
+  if (filter.company_id) {
+    // No company_id field in dealNote, filtering by related deals instead.
+    // This filter is only valid if a deal has less than 250 notes.
+    const dealIds = deals.map((deal) => deal.id).join(",");
+    recentDealNotesFilter["deal_id@in"] = `(${dealIds})`;
+  }
+
+  const { data: dealNotes } = await dataProvider.getList<DealNote>(
+    "dealNotes",
+    {
+      filter: recentDealNotesFilter,
+      pagination: { page: 1, perPage: 250 },
+      sort: { field: "date", order: "DESC" },
+    },
+  );
+
+  const newDeals = deals.map((deal) => ({
+    id: `deal.${deal.id}.created`,
+    type: DEAL_CREATED,
+    company_id: deal.company_id,
+    sales_id: deal.sales_id,
+    deal,
+    date: deal.created_at,
+  }));
+
+  const newDealNotes = dealNotes.map((dealNote) => ({
+    id: `dealNote.${dealNote.id}.created`,
+    type: DEAL_NOTE_CREATED,
+    sales_id: dealNote.sales_id,
+    dealNote,
+    date: dealNote.date,
+  }));
+
+  return [...newDeals, ...newDealNotes];
+}

package/src/components/atomic-crm/providers/commons/canAccess.ts

@@ -0,0 +1,26 @@
+// FIXME: This should be exported from the ra-core package
+type CanAccessParams<
+  RecordType extends Record<string, any> = Record<string, any>,
+> = {
+  action: string;
+  resource: string;
+  record?: RecordType;
+};
+
+export const canAccess = <
+  RecordType extends Record<string, any> = Record<string, any>,
+>(
+  role: string,
+  params: CanAccessParams<RecordType>,
+) => {
+  if (role === "admin") {
+    return true;
+  }
+
+  // Non admins can't access the sales resource
+  if (params.resource === "sales") {
+    return false;
+  }
+
+  return true;
+};

package/src/components/atomic-crm/providers/commons/getCompanyAvatar.spec.ts

@@ -0,0 +1,20 @@
+import type { Company } from "../../types";
+import { getCompanyAvatar } from "./getCompanyAvatar";
+
+it("should return favicon URL if website url exist", async () => {
+  const website = "https://example.com";
+  const record: Partial<Company> = { website };
+
+  const avatarUrl = await getCompanyAvatar(record);
+  expect(avatarUrl).toStrictEqual({
+    src: "https://favicon.show/example.com",
+    title: "Company favicon",
+  });
+});
+
+it("should return null if no website is provided", async () => {
+  const record: Partial<Company> = {};
+
+  const avatarUrl = await getCompanyAvatar(record);
+  expect(avatarUrl).toBeNull();
+});

package/src/components/atomic-crm/providers/commons/getCompanyAvatar.ts

@@ -0,0 +1,21 @@
+import type { Company } from "../../types";
+
+// Main function to get the avatar URL
+export async function getCompanyAvatar(record: Partial<Company>): Promise<{
+  src: string;
+  title: string;
+} | null> {
+  // TODO: Step 1: Try to get image from LinkedIn.
+
+  // Step 2: Fallback to the favicon from website domain
+  if (!record.website) {
+    return null;
+  }
+  const websiteUrlWithoutScheme = record.website
+    .replace(/^https?:\/\//, "")
+    .replace(/\/$/, "");
+  return {
+    src: `https://favicon.show/${websiteUrlWithoutScheme}`,
+    title: "Company favicon",
+  };
+}

package/src/components/atomic-crm/providers/commons/getContactAvatar.spec.ts

@@ -0,0 +1,80 @@
+import { webcrypto } from "node:crypto";
+
+import type { Contact, EmailAndType } from "../../types";
+import { getContactAvatar, hash } from "./getContactAvatar";
+
+Object.defineProperty(globalThis, "crypto", {
+  value: webcrypto,
+});
+
+it("should return gravatar URL for anthony@marmelab.com", async () => {
+  const email: EmailAndType[] = [
+    { email: "anthony@marmelab.com", type: "Work" },
+  ];
+  const record: Partial<Contact> = { email_jsonb: email };
+
+  const avatarUrl = await getContactAvatar(record);
+  const hashedEmail = await hash(email[0].email);
+  expect(avatarUrl).toBe(
+    `https://www.gravatar.com/avatar/${hashedEmail}?d=404`,
+  );
+});
+
+it("should return favicon URL if gravatar does not exist", async () => {
+  const email: EmailAndType[] = [
+    { email: "no-gravatar@gravatar.com", type: "Work" },
+  ];
+  const record: Partial<Contact> = { email_jsonb: email };
+
+  const avatarUrl = await getContactAvatar(record);
+  expect(avatarUrl).toBe("https://gravatar.com/favicon.ico");
+});
+
+it("should not return favicon URL if not domain not allowed", async () => {
+  const email: EmailAndType[] = [
+    { email: "no-gravatar@gmail.com", type: "Work" },
+  ];
+  const record: Partial<Contact> = { email_jsonb: email };
+
+  const avatarUrl = await getContactAvatar(record);
+  expect(avatarUrl).toBeNull();
+});
+
+it("should return null if no email is provided", async () => {
+  const record: Partial<Contact> = {};
+
+  const avatarUrl = await getContactAvatar(record);
+  expect(avatarUrl).toBeNull();
+});
+
+it("should return null if an empty array is provided", async () => {
+  const email: EmailAndType[] = [];
+  const record: Partial<Contact> = { email_jsonb: email };
+
+  const avatarUrl = await getContactAvatar(record);
+  expect(avatarUrl).toBeNull();
+});
+
+it("should return null if email has no gravatar or validate domain", async () => {
+  const email: EmailAndType[] = [
+    { email: "anthony@fake-domain-marmelab.com", type: "Work" },
+  ];
+  const record: Partial<Contact> = { email_jsonb: email };
+
+  const avatarUrl = await getContactAvatar(record);
+  expect(avatarUrl).toBeNull();
+});
+
+it("should return gravatar URL for 2nd email if 1st email has no gravatar nor valid domain", async () => {
+  const email: EmailAndType[] = [
+    { email: "anthony@fake-domain-marmelab.com", type: "Work" },
+    { email: "anthony@marmelab.com", type: "Work" },
+  ];
+  const record: Partial<Contact> = { email_jsonb: email };
+
+  const avatarUrl = await getContactAvatar(record);
+  const hashedEmail = await hash(email[1].email);
+  expect(avatarUrl).toBe(
+    `https://www.gravatar.com/avatar/${hashedEmail}?d=404`,
+  );
+});

package/src/components/atomic-crm/providers/commons/getContactAvatar.ts

@@ -0,0 +1,70 @@
+import { fetchWithTimeout } from "../../misc/fetchWithTimeout";
+import { DOMAINS_NOT_SUPPORTING_FAVICON } from "../../misc/unsupportedDomains.const";
+import type { Contact } from "../../types";
+
+export async function hash(string: string) {
+  const utf8 = new TextEncoder().encode(string);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", utf8);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray
+    .map((bytes) => bytes.toString(16).padStart(2, "0"))
+    .join("");
+  return hashHex;
+}
+
+// Helper function to get the Gravatar URL
+async function getGravatarUrl(email: string): Promise<string> {
+  const hashEmail = await hash(email);
+  return `https://www.gravatar.com/avatar/${hashEmail}?d=404`;
+}
+
+// Helper function to get the favicon URL
+async function getFaviconUrl(domain: string): Promise<string | null> {
+  if (DOMAINS_NOT_SUPPORTING_FAVICON.includes(domain)) {
+    return null;
+  }
+
+  try {
+    const faviconUrl = `https://${domain}/favicon.ico`;
+    const response = await fetchWithTimeout(faviconUrl);
+    if (response.ok) {
+      return faviconUrl;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+// Main function to get the avatar URL
+export async function getContactAvatar(
+  record: Partial<Contact>,
+): Promise<string | null> {
+  if (!record.email_jsonb || !record.email_jsonb.length) {
+    return null;
+  }
+
+  for (const { email } of record.email_jsonb) {
+    // Step 1: Try to get Gravatar image
+    const gravatarUrl = await getGravatarUrl(email);
+    try {
+      const gravatarResponse = await fetch(gravatarUrl);
+      if (gravatarResponse.ok) {
+        return gravatarUrl;
+      }
+    } catch {
+      // Gravatar not found
+    }
+
+    // Step 2: Try to get favicon from email domain
+    const domain = email.split("@")[1];
+    const faviconUrl = await getFaviconUrl(domain);
+    if (faviconUrl) {
+      return faviconUrl;
+    }
+
+    // TODO: Step 3: Try to get image from LinkedIn.
+  }
+
+  return null;
+}

package/src/components/atomic-crm/providers/commons/mergeContacts.ts

@@ -0,0 +1,185 @@
+import type { Identifier, DataProvider } from "ra-core";
+
+import type { Contact, Task, Deal, ContactNote } from "../../types";
+
+/**
+ * Merge one contact (loser) into another contact (winner).
+ *
+ * This function copies properties from the loser to the winner contact,
+ * transfers all associated data (tasks, notes, deals) from the loser to the winner,
+ * and deletes the loser contact.
+ */
+export const mergeContacts = async (
+  loserId: Identifier,
+  winnerId: Identifier,
+  dataProvider: DataProvider,
+) => {
+  // Fetch both contacts using dataProvider to get fresh data
+  const { data: winnerContact } = await dataProvider.getOne<Contact>(
+    "contacts",
+    { id: winnerId },
+  );
+  const { data: loserContact } = await dataProvider.getOne<Contact>(
+    "contacts",
+    { id: loserId },
+  );
+
+  if (!winnerContact || !loserContact) {
+    throw new Error("Could not fetch contacts");
+  }
+
+  // 1. Reassign all tasks from loser to winner
+  const { data: loserTasks } = await dataProvider.getManyReference<Task>(
+    "tasks",
+    {
+      target: "contact_id",
+      id: loserId,
+      pagination: { page: 1, perPage: 1000 },
+      sort: { field: "id", order: "ASC" },
+      filter: {},
+    },
+  );
+
+  const taskUpdates =
+    loserTasks?.map((task) =>
+      dataProvider.update("tasks", {
+        id: task.id,
+        data: { contact_id: winnerId },
+        previousData: task,
+      }),
+    ) || [];
+
+  // 2. Reassign all notes from loser to winner
+  const { data: loserNotes } = await dataProvider.getManyReference<ContactNote>(
+    "contactNotes",
+    {
+      target: "contact_id",
+      id: loserId,
+      pagination: { page: 1, perPage: 1000 },
+      sort: { field: "id", order: "ASC" },
+      filter: {},
+    },
+  );
+
+  const noteUpdates =
+    loserNotes?.map((note) =>
+      dataProvider.update<ContactNote>("contactNotes", {
+        id: note.id,
+        data: { contact_id: winnerId },
+        previousData: note,
+      }),
+    ) || [];
+
+  // 3. Change contact in deals - replace loser ID with winner ID in contact_ids array
+  const { data: loserDeals } = await dataProvider.getList<Deal>("deals", {
+    filter: { "contact_ids@cs": `{${loserId}}` },
+    pagination: { page: 1, perPage: 1000 },
+    sort: { field: "id", order: "ASC" },
+  });
+
+  const dealUpdates =
+    loserDeals?.map((deal) => {
+      const newContactIds = deal.contact_ids
+        .filter((id) => id !== loserId)
+        .concat(winnerId)
+        .filter(
+          (id: Identifier, index: number, self: Identifier[]) =>
+            self.indexOf(id) === index,
+        ); // Remove duplicates
+
+      return dataProvider.update<Deal>("deals", {
+        id: deal.id,
+        data: { contact_ids: newContactIds },
+        previousData: deal,
+      });
+    }) || [];
+
+  // 4. Update winner contact with loser data
+  const mergedEmails = mergeObjectArraysUnique(
+    winnerContact.email_jsonb || [],
+    loserContact.email_jsonb || [],
+    (email) => email.email,
+  );
+
+  const mergedPhones = mergeObjectArraysUnique(
+    winnerContact.phone_jsonb || [],
+    loserContact.phone_jsonb || [],
+    (phone) => phone.number,
+  );
+
+  const winnerUpdate = dataProvider.update<Contact>("contacts", {
+    id: winnerId,
+    data: {
+      avatar:
+        winnerContact.avatar && winnerContact.avatar.src
+          ? winnerContact.avatar
+          : loserContact.avatar,
+      gender: winnerContact.gender ?? loserContact.gender,
+      first_name: winnerContact.first_name ?? loserContact.first_name,
+      last_name: winnerContact.last_name ?? loserContact.last_name,
+      title: winnerContact.title ?? loserContact.title,
+      company_id: winnerContact.company_id ?? loserContact.company_id,
+      email_jsonb: mergedEmails,
+      phone_jsonb: mergedPhones,
+      linkedin_url: winnerContact.linkedin_url || loserContact.linkedin_url,
+      background: winnerContact.background ?? loserContact.background,
+      has_newsletter:
+        winnerContact.has_newsletter ?? loserContact.has_newsletter,
+      first_seen: winnerContact.first_seen ?? loserContact.first_seen,
+      last_seen:
+        winnerContact.last_seen > loserContact.last_seen
+          ? winnerContact.last_seen
+          : loserContact.last_seen,
+      sales_id: winnerContact.sales_id ?? loserContact.sales_id,
+      tags: mergeArraysUnique(
+        winnerContact.tags || [],
+        loserContact.tags || [],
+      ),
+    },
+    previousData: winnerContact,
+  });
+
+  // Execute all updates
+  await Promise.all([
+    ...taskUpdates,
+    ...noteUpdates,
+    ...dealUpdates,
+    winnerUpdate,
+  ]);
+
+  // 5. Delete the loser contact
+  await dataProvider.delete<Contact>("contacts", {
+    id: loserId,
+    previousData: loserContact,
+  });
+};
+
+// Helper functions to merge arrays and remove duplicates
+
+// For primitive arrays like tags
+const mergeArraysUnique = <T>(arr1: T[], arr2: T[]): T[] => [
+  ...new Set([...arr1, ...arr2]),
+];
+
+// For object arrays like emails and phones
+function mergeObjectArraysUnique<T>(
+  arr1: T[],
+  arr2: T[],
+  getKey: (item: T) => string,
+): T[] {
+  const map = new Map<string, T>();
+
+  arr1.forEach((item) => {
+    const key = getKey(item);
+    if (key) map.set(key, item);
+  });
+
+  arr2.forEach((item) => {
+    const key = getKey(item);
+    if (key && !map.has(key)) {
+      map.set(key, item);
+    }
+  });
+
+  return Array.from(map.values());
+}

package/src/components/atomic-crm/providers/fakerest/authProvider.ts

@@ -0,0 +1,74 @@
+import type { AuthProvider } from "ra-core";
+
+import type { Sale } from "../../types";
+import { canAccess } from "../commons/canAccess";
+import { dataProvider } from "./dataProvider";
+
+export const DEFAULT_USER = {
+  id: 0,
+  first_name: "Jane",
+  last_name: "Doe",
+  email: "janedoe@atomic.dev",
+  password: "demo",
+  administrator: true,
+  avatar: {
+    src: "data:image/jpeg;base64,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",
+  },
+} as const;
+
+export const USER_STORAGE_KEY = "user";
+
+localStorage.setItem(USER_STORAGE_KEY, JSON.stringify({ ...DEFAULT_USER }));
+
+async function getUser(email: string) {
+  const sales = await dataProvider.getList("sales", {
+    pagination: { page: 1, perPage: 200 },
+    sort: { field: "name", order: "ASC" },
+  });
+
+  if (!sales.data.length) {
+    return { ...DEFAULT_USER };
+  }
+
+  const user = sales.data.find((sale) => sale.email === email);
+  if (!user || user.disabled) {
+    return { ...DEFAULT_USER };
+  }
+  return user;
+}
+
+export const authProvider: AuthProvider = {
+  login: async ({ email }) => {
+    const user = await getUser(email);
+    localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(user));
+    return Promise.resolve();
+  },
+  logout: () => {
+    localStorage.removeItem(USER_STORAGE_KEY);
+    return Promise.resolve();
+  },
+  checkError: () => Promise.resolve(),
+  checkAuth: () =>
+    localStorage.getItem(USER_STORAGE_KEY)
+      ? Promise.resolve()
+      : Promise.reject(),
+  canAccess: async ({ signal: _signal, ...params }) => {
+    // Get the current user
+    const userItem = localStorage.getItem(USER_STORAGE_KEY);
+    const localUser = userItem ? (JSON.parse(userItem) as Sale) : null;
+    if (!localUser) return false;
+
+    // Compute access rights from the sale role
+    const role = localUser.administrator ? "admin" : "user";
+    return canAccess(role, params);
+  },
+  getIdentity: () => {
+    const userItem = localStorage.getItem(USER_STORAGE_KEY);
+    const user = userItem ? (JSON.parse(userItem) as Sale) : null;
+    return Promise.resolve({
+      id: user?.id ?? 0,
+      fullName: user ? `${user.first_name} ${user.last_name}` : "Jane Doe",
+      avatar: user?.avatar?.src,
+    });
+  },
+};