@multiplatform.one/backoffice 7.23.2 → 7.24.0

package/src/quickEntry/QuickEntryDialog.screen.spec.tsx

@@ -0,0 +1,143 @@
+// Desk quick entry (MPO-414): required fields validate inline, Create inserts
+// and hands back the server name, and doctypes that do not quick-enter route
+// to the full form without drawing the dialog.
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { fireEvent, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { BackofficeProvider, type BackofficeFrappeConfig } from "../config/BackofficeProvider";
+import { createMemoryNavigator } from "../navigation/navigator";
+import type { DoctypeMeta } from "../shared/useDoctypeMeta";
+import { QuickEntryDialog } from "./QuickEntryDialog";
+
+const todoMeta: DoctypeMeta = {
+  name: "ToDo",
+  module: "Desk",
+  quick_entry: 1,
+  autoname: "hash",
+  fields: [
+    { fieldname: "description", fieldtype: "Small Text", label: "Description", reqd: 1 },
+    {
+      fieldname: "priority",
+      fieldtype: "Select",
+      label: "Priority",
+      options: "High\nMedium\nLow",
+      bold: 1,
+      default: "Medium",
+    },
+    { fieldname: "status", fieldtype: "Select", label: "Status", options: "Open\nClosed" },
+  ],
+  permissions: [{ role: "All", read: 1, write: 1, create: 1 }],
+};
+
+const invoiceMeta: DoctypeMeta = {
+  name: "Sales Invoice",
+  module: "Accounts",
+  quick_entry: 0,
+  fields: [{ fieldname: "customer", fieldtype: "Data", label: "Customer", reqd: 1 }],
+  permissions: [{ role: "All", read: 1, write: 1, create: 1 }],
+};
+
+let host = 0;
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function renderDialog(meta: DoctypeMeta, frappe: Partial<BackofficeFrappeConfig> = {}) {
+  host += 1;
+  const onOpenChange = vi.fn();
+  const onCreated = vi.fn();
+  const onEditFullForm = vi.fn();
+  const fixtures = new InMemoryFixtureProvider({ [meta.name]: [] });
+  renderWithProviders(
+    <BackofficeProvider
+      frappe={{ baseURL: `https://quick-entry-${host}.screen.spec.test`, fixtures, ...frappe }}
+      navigation={createMemoryNavigator("/backoffice")}
+    >
+      <QuickEntryDialog
+        doctype={meta.name}
+        open
+        onOpenChange={onOpenChange}
+        onCreated={onCreated}
+        onEditFullForm={onEditFullForm}
+        metaOverride={meta}
+      />
+    </BackofficeProvider>,
+  );
+  return { fixtures, onOpenChange, onCreated, onEditFullForm };
+}
+
+function descriptionInput(): HTMLTextAreaElement | HTMLInputElement {
+  const field = screen.getByLabelText("Description", { exact: false });
+  return (
+    field instanceof HTMLTextAreaElement || field instanceof HTMLInputElement
+      ? field
+      : field.querySelector("textarea, input")
+  ) as HTMLTextAreaElement;
+}
+
+describe("QuickEntryDialog", () => {
+  it("holds Create while a required field is empty", async () => {
+    const { onCreated, onOpenChange } = renderDialog(todoMeta);
+    fireEvent.click(await screen.findByTestId("quick-entry-create"));
+    expect(await screen.findByText("Description is required")).toBeTruthy();
+    expect(onCreated).not.toHaveBeenCalled();
+    expect(onOpenChange).not.toHaveBeenCalledWith(false);
+  });
+
+  it("inserts the draft and hands back the created name", async () => {
+    const { fixtures, onCreated, onOpenChange } = renderDialog(todoMeta);
+    await screen.findByTestId("quick-entry-form");
+    fireEvent.change(descriptionInput(), { target: { value: "Call the vendor" } });
+    fireEvent.click(screen.getByTestId("quick-entry-create"));
+    await waitFor(() => expect(onCreated).toHaveBeenCalledTimes(1));
+    const created = await fixtures.getList("ToDo");
+    expect(created).toHaveLength(1);
+    expect(created[0]?.description).toBe("Call the vendor");
+    expect(onCreated).toHaveBeenCalledWith(created[0]?.name);
+    expect(onOpenChange).toHaveBeenLastCalledWith(false);
+  });
+
+  it("shows a server rejection inline and stays open", async () => {
+    vi.stubGlobal("fetch", async (input: string | URL | Request) => {
+      const url = new URL(String(input instanceof Request ? input.url : input));
+      if (url.pathname.endsWith(".create_doc")) {
+        return new Response(
+          JSON.stringify({
+            exc_type: "ValidationError",
+            exception: "frappe.exceptions.ValidationError: Vendor calls are closed today",
+          }),
+          { status: 417, headers: { "content-type": "application/json" } },
+        );
+      }
+      return new Response(JSON.stringify({ data: [] }), {
+        headers: { "content-type": "application/json" },
+      });
+    });
+    const { onCreated, onOpenChange } = renderDialog(todoMeta, { fixtures: undefined });
+    await screen.findByTestId("quick-entry-form");
+    fireEvent.change(descriptionInput(), { target: { value: "Call the vendor" } });
+    fireEvent.click(screen.getByTestId("quick-entry-create"));
+    const error = await screen.findByTestId("quick-entry-error", {}, { timeout: 5000 });
+    expect(error.textContent).toBe("Vendor calls are closed today");
+    expect(onCreated).not.toHaveBeenCalled();
+    expect(onOpenChange).not.toHaveBeenCalledWith(false);
+  });
+
+  it("routes a doctype that does not quick-enter to the full form", async () => {
+    const { onEditFullForm, onOpenChange } = renderDialog(invoiceMeta);
+    await waitFor(() => expect(onEditFullForm).toHaveBeenCalledTimes(1));
+    expect(onOpenChange).toHaveBeenCalledWith(false);
+    expect(screen.queryByTestId("quick-entry-form")).toBeNull();
+    expect(screen.queryByText("New Sales Invoice")).toBeNull();
+  });
+
+  it("escapes to the full form from the footer", async () => {
+    const { onEditFullForm, onOpenChange } = renderDialog(todoMeta);
+    fireEvent.click(await screen.findByTestId("quick-entry-edit-full-form"));
+    expect(onOpenChange).toHaveBeenCalledWith(false);
+    expect(onEditFullForm).toHaveBeenCalledTimes(1);
+  });
+});

package/src/report/DoctypeReportView.screen.spec.tsx

@@ -0,0 +1,154 @@
+// The desk report view (MPO-414): rows from the live collection, a row press
+// opens the form, the per-column filter row and the ?f= base filters narrow
+// the result, the desk scope is ANDed in, and Save As round-trips ?report=.
+import React from "react";
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { fireEvent, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { BackofficeProvider } from "../config/BackofficeProvider";
+import { DeskScopeProvider } from "../desk/scope";
+import { createMemoryNavigator, type MemoryNavigator } from "../navigation/navigator";
+import type { FrappeFilters } from "../shared/types";
+import { DoctypeReportView } from "./DoctypeReportView";
+
+const orderMeta = {
+  name: "QaReportOrder",
+  doctype: "DocType",
+  module: "QA",
+  title_field: "customer",
+  sort_field: "modified",
+  sort_order: "DESC",
+  fields: [
+    { fieldname: "customer", fieldtype: "Data", label: "Customer", in_list_view: 1 },
+    { fieldname: "amount", fieldtype: "Currency", label: "Amount", in_list_view: 1 },
+    {
+      fieldname: "region",
+      fieldtype: "Select",
+      label: "Region",
+      options: "North\nSouth",
+      in_standard_filter: 1,
+    },
+    {
+      fieldname: "status",
+      fieldtype: "Select",
+      label: "Status",
+      options: "Draft\nPaid",
+      in_list_view: 1,
+    },
+  ],
+  permissions: [{ role: "All", read: 1 }],
+};
+
+const orders = [
+  ["QA-ORD-0001", "ACME Corp", "North", "Paid", 1],
+  ["QA-ORD-0002", "Globex", "South", "Draft", 2],
+  ["QA-ORD-0003", "Initech", "North", "Draft", 3],
+].map(([name, customer, region, status, day]) => ({
+  name: String(name),
+  doctype: "QaReportOrder",
+  customer,
+  amount: 1000,
+  region,
+  status,
+  modified: `2026-08-0${day} 09:00:00`,
+}));
+
+let run = 0;
+
+function renderReport(
+  props: { filtersParam?: string; scope?: FrappeFilters; doctype?: string } = {},
+): MemoryNavigator {
+  run += 1;
+  const navigation = createMemoryNavigator("/backoffice/qareportorder/view/report");
+  renderWithProviders(
+    <BackofficeProvider
+      frappe={{
+        baseURL: `https://doctype-report-${run}.spec.test`,
+        fixtures: new InMemoryFixtureProvider({
+          DocType: [orderMeta, { ...orderMeta, name: "QaReportEmpty" }],
+          QaReportOrder: orders,
+          QaReportEmpty: [],
+        }),
+      }}
+      navigation={navigation}
+    >
+      <DeskScopeProvider scope={props.scope}>
+        <DoctypeReportView
+          doctype={props.doctype ?? "QaReportOrder"}
+          filtersParam={props.filtersParam}
+        />
+      </DeskScopeProvider>
+    </BackofficeProvider>,
+  );
+  return navigation;
+}
+
+function rowNames(): string[] {
+  return Array.from(
+    document.querySelectorAll('[data-report-row="true"]'),
+    (row) => row.getAttribute("aria-label") ?? "",
+  );
+}
+
+async function rowsAre(names: string[]) {
+  await waitFor(() => expect(rowNames().sort()).toEqual([...names].sort()), { timeout: 5000 });
+}
+
+describe("<DoctypeReportView />", () => {
+  it("draws a row per record and opens the form on press", async () => {
+    const navigation = renderReport();
+    await rowsAre(["QA-ORD-0001", "QA-ORD-0002", "QA-ORD-0003"]);
+    fireEvent.click(screen.getByText("Globex"));
+    expect(navigation.getLocation().path).toBe("/backoffice/qareportorder/QA-ORD-0002");
+  });
+
+  it("narrows the rows from the column filter row and clears it again", async () => {
+    renderReport();
+    await rowsAre(["QA-ORD-0001", "QA-ORD-0002", "QA-ORD-0003"]);
+    fireEvent.change(await screen.findByRole("textbox", { name: "Filter Region" }), {
+      target: { value: "North" },
+    });
+    await rowsAre(["QA-ORD-0001", "QA-ORD-0003"]);
+    fireEvent.click(screen.getByRole("button", { name: /Clear column filters \(1\)/ }));
+    await rowsAre(["QA-ORD-0001", "QA-ORD-0002", "QA-ORD-0003"]);
+  });
+
+  it("applies the ?f= base filters and drops them from the address on clear", async () => {
+    const navigation = renderReport({
+      filtersParam: encodeURIComponent(JSON.stringify([["status", "=", "Draft"]])),
+    });
+    await rowsAre(["QA-ORD-0002", "QA-ORD-0003"]);
+    fireEvent.click(screen.getByRole("button", { name: "Clear filters" }));
+    await rowsAre(["QA-ORD-0001", "QA-ORD-0002", "QA-ORD-0003"]);
+    expect(navigation.getLocation().path).toBe("/backoffice/qareportorder/view/report");
+  });
+
+  it("ANDs the desk scope in, with nothing to clear", async () => {
+    renderReport({ scope: [["region", "=", "South"]] });
+    await rowsAre(["QA-ORD-0002"]);
+    expect(screen.queryByRole("button", { name: "Clear filters" })).toBeNull();
+  });
+
+  it("says so when the doctype has no records", async () => {
+    renderReport({ doctype: "QaReportEmpty" });
+    expect(await screen.findByText("No results", {}, { timeout: 5000 })).toBeTruthy();
+    expect(screen.getByText("There are no QaReportEmpty records yet")).toBeTruthy();
+  });
+
+  it("saves the current report under a name and selects it", async () => {
+    const navigation = renderReport();
+    await rowsAre(["QA-ORD-0001", "QA-ORD-0002", "QA-ORD-0003"]);
+    fireEvent.click(screen.getByRole("button", { name: "Save As…" }));
+    fireEvent.change(await screen.findByRole("textbox", { name: "New report name" }), {
+      target: { value: "Weekly Northern" },
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+    await waitFor(() => expect(navigation.getLocation().params.report).toBe("Weekly Northern"), {
+      timeout: 5000,
+    });
+    expect(
+      await screen.findByRole("button", { name: "Report: Weekly Northern" }, { timeout: 5000 }),
+    ).toBeTruthy();
+  });
+});

package/src/shell/WorkspaceSidebar.tsx

@@ -167,15 +167,16 @@ function WorkspaceNav({ sections }: { sections: SidebarSection[] }) {
           {sections.map((section, sectionIdx) => (
             <YStack key={section.title ?? sectionIdx} {...knobProps.gap}>
               {section.title ? (
-                <SizableText
-                  size="$2"
-                  fontWeight="400"
-                  textTransform="uppercase"
-                  color="$color11"
-                  marginHorizontal={rowPad}
-                >
-                  {section.title}
-                </SizableText>
+                <YStack paddingHorizontal={rowPad}>
+                  <SizableText
+                    size="$2"
+                    fontWeight="400"
+                    textTransform="uppercase"
+                    color="$color11"
+                  >
+                    {section.title}
+                  </SizableText>
+                </YStack>
               ) : null}
               <YStack>
                 {section.items.map((item, itemIdx) => {

package/src/views/CalendarView.screen.spec.tsx

@@ -0,0 +1,241 @@
+// The calendar view (MPO-414): a Calendar View settings doc picks the date
+// axis, an event opens its form, the selector writes ?field=, and a day click
+// starts a record prefilled with that day only for a session that may create
+// (MPO-390).
+import React from "react";
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { act, fireEvent, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { BackofficeProvider } from "../config/BackofficeProvider";
+import { createMemoryNavigator, type MemoryNavigator } from "../navigation/navigator";
+import { CalendarView } from "./CalendarView";
+
+const eventMeta = {
+  name: "QaCalEvent",
+  doctype: "DocType",
+  module: "QA",
+  fields: [
+    { fieldname: "subject", fieldtype: "Data", label: "Subject", in_list_view: 1 },
+    { fieldname: "created_on", fieldtype: "Date", label: "Created On" },
+    { fieldname: "scheduled_at", fieldtype: "Datetime", label: "Scheduled At" },
+    { fieldname: "wrap_up_at", fieldtype: "Datetime", label: "Wrap Up At" },
+  ],
+  permissions: [{ role: "All", read: 1 }],
+};
+
+const multiMeta = {
+  name: "QaCalMulti",
+  doctype: "DocType",
+  module: "QA",
+  title_field: "title",
+  fields: [
+    { fieldname: "title", fieldtype: "Data", label: "Title", in_list_view: 1 },
+    { fieldname: "due_date", fieldtype: "Date", label: "Due Date" },
+    { fieldname: "follow_up_on", fieldtype: "Date", label: "Follow Up On" },
+  ],
+  permissions: [{ role: "All", read: 1 }],
+};
+
+const noDateMeta = {
+  name: "QaCalNone",
+  doctype: "DocType",
+  module: "QA",
+  fields: [{ fieldname: "subject", fieldtype: "Data", label: "Subject", in_list_view: 1 }],
+  permissions: [{ role: "All", read: 1 }],
+};
+
+const moveMeta = {
+  name: "Poke Move",
+  doctype: "DocType",
+  title_field: "move_name",
+  fields: [
+    { fieldname: "move_name", fieldtype: "Data", label: "Move Name", in_list_view: 1 },
+    { fieldname: "learned_on", fieldtype: "Date", label: "Learned On" },
+  ],
+  permissions: [
+    { role: "Pokemon Editor", read: 1, write: 1, create: 1, delete: 1 },
+    { role: "Guest", read: 1 },
+  ],
+};
+
+function dayKey(date: Date): string {
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+
+const today = dayKey(new Date());
+
+const events = [
+  {
+    name: "QCE-001",
+    doctype: "QaCalEvent",
+    subject: "Team sync",
+    created_on: "2020-01-01",
+    scheduled_at: `${today} 09:00:00`,
+    wrap_up_at: `${today} 10:00:00`,
+  },
+];
+
+const calendarViewDoc = {
+  name: "QaCalEvent Calendar",
+  doctype: "Calendar View",
+  reference_doctype: "QaCalEvent",
+  subject_field: "subject",
+  start_date_field: "scheduled_at",
+  end_date_field: "wrap_up_at",
+};
+
+let run = 0;
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function renderFixtureCalendar(doctype: string, dateField?: string): MemoryNavigator {
+  run += 1;
+  const navigation = createMemoryNavigator("/backoffice");
+  renderWithProviders(
+    <BackofficeProvider
+      frappe={{
+        baseURL: `https://calendar-view-${run}.spec.test`,
+        fixtures: new InMemoryFixtureProvider({
+          DocType: [eventMeta, multiMeta, noDateMeta],
+          "Calendar View": [calendarViewDoc],
+          QaCalEvent: events,
+          QaCalMulti: [],
+        }),
+      }}
+      navigation={navigation}
+    >
+      <CalendarView doctype={doctype} dateField={dateField} />
+    </BackofficeProvider>,
+  );
+  return navigation;
+}
+
+function json(body: unknown) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function renderBenchCalendar(roles: string[]) {
+  run += 1;
+  let rolesAnswered = false;
+  vi.stubGlobal("fetch", async (input: string | URL | Request) => {
+    const url = new URL(String(input instanceof Request ? input.url : input));
+    const method = url.pathname.replace(/^\/api\/method\//, "");
+    if (method === "frappe.auth.get_logged_user") return json({ message: "user@pokemon.test" });
+    if (method === "frappe.core.doctype.user.user.get_roles") {
+      rolesAnswered = true;
+      return json({ message: roles });
+    }
+    if (method === "frappe.desk.form.load.getdoctype") return json({ docs: [moveMeta] });
+    if (url.pathname === `/api/resource/${encodeURIComponent("Poke Move")}`) {
+      return json({
+        data: [{ name: "m1", doctype: "Poke Move", move_name: "tackle", learned_on: today }],
+      });
+    }
+    return json({ data: [], message: [] });
+  });
+  const navigation = createMemoryNavigator("/backoffice");
+  renderWithProviders(
+    <BackofficeProvider
+      frappe={{ baseURL: `https://calendar-view-bench-${run}.spec.test` }}
+      navigation={navigation}
+    >
+      <CalendarView doctype="Poke Move" />
+    </BackofficeProvider>,
+  );
+  return { navigation, rolesAnswered: () => rolesAnswered };
+}
+
+async function todayCell(): Promise<HTMLElement> {
+  return waitFor(
+    () => {
+      const cell = document.querySelector(`[data-calendar-day="${today}"]`);
+      expect(cell).toBeTruthy();
+      return cell as HTMLElement;
+    },
+    { timeout: 5000 },
+  );
+}
+
+function draggable(title: string): boolean {
+  let node: HTMLElement | null = screen.getByText(title);
+  for (let depth = 0; node && depth < 6; depth += 1) {
+    if (node.className.includes("_cur-grab")) return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+
+async function settle(ms = 300) {
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  });
+}
+
+describe("<CalendarView />", () => {
+  it("lays events on the settings doc's axis and opens the form on press", async () => {
+    const navigation = renderFixtureCalendar("QaCalEvent");
+    expect(
+      await screen.findByLabelText("Choose calendar date field", {}, { timeout: 5000 }),
+    ).toHaveProperty("textContent", "Scheduled At");
+    fireEvent.click(await screen.findByText("Team sync", {}, { timeout: 5000 }));
+    expect(navigation.getLocation().path).toBe("/backoffice/qacalevent/QCE-001");
+  });
+
+  it("writes the picked date field into ?field=", async () => {
+    const navigation = renderFixtureCalendar("QaCalMulti");
+    fireEvent.click(
+      await screen.findByLabelText("Choose calendar date field", {}, { timeout: 5000 }),
+    );
+    fireEvent.click(await screen.findByText("Follow Up On", {}, { timeout: 5000 }));
+    await waitFor(() => expect(navigation.getLocation().params.field).toBe("follow_up_on"));
+    expect(navigation.getLocation().path).toBe("/backoffice/qacalmulti/view/calendar");
+  });
+
+  it("starts a record prefilled with the clicked day", async () => {
+    const navigation = renderFixtureCalendar("QaCalMulti");
+    fireEvent.click(await todayCell());
+    await waitFor(() => expect(navigation.getLocation().path).toBe("/backoffice/qacalmulti/new"));
+    const prefill = navigation.getLocation().params.d;
+    expect(JSON.parse(String(prefill))).toEqual({ due_date: today });
+  });
+
+  it("offers the list back when the doctype has no date field", async () => {
+    const navigation = renderFixtureCalendar("QaCalNone");
+    expect(await screen.findByText("Calendar not available", {}, { timeout: 5000 })).toBeTruthy();
+    fireEvent.click(screen.getByText("Back to list"));
+    expect(navigation.getLocation().path).toBe("/backoffice/qacalnone");
+  });
+
+  it("lets an editor move events and start a record from a day on a live bench", async () => {
+    const bench = renderBenchCalendar(["Pokemon Editor", "Guest"]);
+    const cell = await todayCell();
+    await screen.findByText("tackle", {}, { timeout: 5000 });
+    await waitFor(() => expect(bench.rolesAnswered()).toBe(true), { timeout: 5000 });
+    await waitFor(() => expect(draggable("tackle")).toBe(true));
+    fireEvent.click(cell);
+    await waitFor(() =>
+      expect(bench.navigation.getLocation().path).toBe("/backoffice/poke-move/new"),
+    );
+  });
+
+  it("neither moves events nor starts a record for a reader on a live bench", async () => {
+    const bench = renderBenchCalendar(["Guest"]);
+    const cell = await todayCell();
+    await screen.findByText("tackle", {}, { timeout: 5000 });
+    await settle();
+    expect(draggable("tackle")).toBe(false);
+    fireEvent.click(cell);
+    await settle(100);
+    expect(bench.navigation.getLocation().path).toBe("/backoffice");
+    expect(bench.rolesAnswered()).toBe(true);
+  });
+});

package/src/views/CalendarView.tsx

@@ -9,7 +9,12 @@
 // Event click opens the form; day/slot click starts a new document
 // prefilled with the clicked date (`?d=` param on the /new route).
 import { XStack, YStack } from "@multiplatform.one/components";
-import { FrappeCalendar, type FrappeCalendarProps } from "@multiplatform.one/frappe-ui";
+import {
+  FrappeCalendar,
+  useDocRights,
+  useFrappeConfig,
+  type FrappeCalendarProps,
+} from "@multiplatform.one/frappe-ui";
 import { formatCalendarDate, useResolvedKnobs } from "@multiplatform.one/theme";
 import type { ReactElement } from "react";
 import { useTranslation } from "react-i18next";
@@ -73,6 +78,7 @@ export function CalendarView({
   const connection = useViewConnection();
   const { meta, isLoading: isMetaLoading, error: metaError } = useViewMeta(doctype);
   const settings = useCalendarViewSettings(connection, doctype);
+  const { rights } = useDocRights(useFrappeConfig(), meta);
 
   if (isMetaLoading || settings.isLoading) return <ViewLoading />;
   if (metaError && !meta) return <ViewError doctype={doctype} error={metaError} />;
@@ -168,16 +174,18 @@ export function CalendarView({
         defaultView="month"
         showNavigation
         showViewSwitcher
+        enableEventDrag={rights.write}
         onEventClick={(doc) => {
           if (doc.name) navigator.navigate(paths.form(doctype, doc.name));
         }}
         // Desk parity: desk seeds its new-event form with the clicked day
         // (and slot time in week/day grids) — the date rides the `?d=`
         // prefill param into the create form, shaped to the field's type.
-        // `onSlotCreate` overrides; the default is gated by `newDoc`.
+        // `onSlotCreate` overrides; the default is gated by `newDoc` and the
+        // session's create right.
         onDateClick={
           onSlotCreate ??
-          (newDoc.enabled
+          (newDoc.enabled && rights.create
             ? (date) =>
                 navigator.navigate(
                   paths.newDoc(doctype, { [dateField]: toFrappeDateValue(date, dateFieldType) }),