Debian Codegraph @

addons/web/static/tests/views/calendar/calendar_view.test.js

raw
1 import { beforeEach, expect, test } from "@odoo/hoot";
2 import {
3 Deferred,
4 advanceTime,
5 animationFrame,
6 click,
7 hover,
8 pointerDown,
9 pointerUp,
10 press,
11 queryAllRects,
12 queryAllTexts,
13 queryFirst,
14 queryOne,
15 queryRect,
16 runAllTimers,
17 } from "@odoo/hoot-dom";
18 import { mockDate, mockTimeZone } from "@odoo/hoot-mock";
19 import { Component, onRendered, onWillStart, xml } from "@odoo/owl";
20 import {
21 MockServer,
22 contains,
23 defineActions,
24 defineModels,
25 defineParams,
26 fields,
27 getMockEnv,
28 getService,
29 makeServerError,
30 mockService,
31 models,
32 mountView,
33 mountWithCleanup,
34 onRpc,
35 patchWithCleanup,
36 preloadBundle,
37 serverState,
38 validateSearch,
39 } from "@web/../tests/web_test_helpers";
40 import {
41 changeScale,
42 clickAllDaySlot,
43 clickDate,
44 clickEvent,
45 closeCwPopOver,
46 displayCalendarPanel,
47 expandCalendarView,
48 hideCalendarPanel,
49 moveEventToAllDaySlot,
50 moveEventToDate,
51 moveEventToTime,
52 navigate,
53 pickDate,
54 removeFilter,
55 resizeEventToDate,
56 resizeEventToTime,
57 selectAllDayRange,
58 selectDateRange,
59 selectHourOnPicker,
60 selectTimeRange,
61 toggleFilter,
62 toggleSectionFilter,
63 } from "./calendar_test_helpers";
64
65 import { registry } from "@web/core/registry";
66 import { zip } from "@web/core/utils/arrays";
67 import { CalendarCommonRenderer } from "@web/views/calendar/calendar_common/calendar_common_renderer";
68 import { CalendarController } from "@web/views/calendar/calendar_controller";
69 import { CalendarRenderer } from "@web/views/calendar/calendar_renderer";
70 import { calendarView } from "@web/views/calendar/calendar_view";
71 import { CalendarYearRenderer } from "@web/views/calendar/calendar_year/calendar_year_renderer";
72 import { WebClient } from "@web/webclient/webclient";
73
74 class Event extends models.Model {
75 name = fields.Char();
76 type_id = fields.Many2one({ string: "Event Type", relation: "event.type" });
77 start_date = fields.Date({ compute: "_compute_start_date", store: true, readonly: false });
78 stop_date = fields.Date({ compute: "_compute_stop_date", store: true, readonly: false });
79 start = fields.Datetime();
80 stop = fields.Datetime();
81 delay = fields.Float();
82 is_all_day = fields.Boolean();
83 user_id = fields.Many2one({ relation: "calendar.users", default: serverState.userId });
84 partner_id = fields.Many2one({ relation: "calendar.partner", related: "user_id.partner_id" });
85 attendee_ids = fields.One2many({ relation: "calendar.partner", default: [[6, 0, [1]]] });
86 color = fields.Integer({ related: "type_id.color" });
87 is_hatched = fields.Boolean();
88 is_striked = fields.Boolean();
89
90 has_access() {
91 return true;
92 }
93
94 _compute_start_date() {
95 for (const record of this) {
96 record.start_date = record.start && record.start.split(" ")[0];
97 }
98 }
99
100 _compute_stop_date() {
101 for (const record of this) {
102 record.stop_date = record.stop && record.stop.split(" ")[0];
103 }
104 }
105
106 _records = [
107 {
108 id: 1,
109 name: "event 1",
110 start: "2016-12-11 00:00:00",
111 stop: "2016-12-11 00:00:00",
112 user_id: serverState.userId,
113 partner_id: 1,
114 attendee_ids: [1, 2, 3],
115 },
116 {
117 id: 2,
118 name: "event 2",
119 start: "2016-12-12 10:55:05",
120 stop: "2016-12-12 14:55:05",
121 user_id: serverState.userId,
122 partner_id: 1,
123 attendee_ids: [1, 2],
124 },
125 {
126 id: 3,
127 name: "event 3",
128 start: "2016-12-12 15:55:05",
129 stop: "2016-12-12 16:55:05",
130 user_id: 4,
131 partner_id: 4,
132 attendee_ids: [1],
133 is_hatched: true,
134 },
135 {
136 id: 4,
137 name: "event 4",
138 start: "2016-12-14 15:55:05",
139 stop: "2016-12-14 18:55:05",
140 is_all_day: true,
141 user_id: serverState.userId,
142 partner_id: 1,
143 attendee_ids: [1],
144 is_striked: true,
145 },
146 {
147 id: 5,
148 name: "event 5",
149 start: "2016-12-13 15:55:05",
150 stop: "2016-12-20 18:55:05",
151 user_id: 4,
152 partner_id: 4,
153 attendee_ids: [2, 3],
154 is_hatched: true,
155 },
156 {
157 id: 6,
158 name: "event 6",
159 start: "2016-12-18 08:00:00",
160 stop: "2016-12-18 09:00:00",
161 user_id: serverState.userId,
162 partner_id: 1,
163 attendee_ids: [3],
164 is_hatched: true,
165 },
166 {
167 id: 7,
168 name: "event 7",
169 start: "2016-11-14 08:00:00",
170 stop: "2016-11-16 17:00:00",
171 user_id: serverState.userId,
172 partner_id: 1,
173 attendee_ids: [2],
174 },
175 ];
176
177 _views = {
178 form: `
179 <form>
180 <field name="name"/>
181 <field name="is_all_day"/>
182 <group invisible="is_all_day">
183 <field name="start"/>
184 <field name="stop"/>
185 </group>
186 <group invisible="not is_all_day">
187 <field name="start_date"/>
188 <field name="stop_date"/>
189 </group>
190 </form>
191 `,
192 "form,1": `
193 <form>
194 <field name="is_all_day" invisible="1"/>
195 <field name="start" invisible="not is_all_day"/>
196 <field name="stop" invisible="is_all_day"/>
197 </form>
198 `,
199 };
200 }
201
202 class EventType extends models.Model {
203 _name = "event.type";
204
205 name = fields.Char();
206 color = fields.Integer();
207
208 has_access() {
209 return true;
210 }
211
212 _records = [
213 { id: 1, name: "Event Type 1", color: 1 },
214 { id: 2, name: "Event Type 2", color: 2 },
215 { id: 3, name: "Event Type 3 (color 4)", color: 4 },
216 ];
217 }
218
219 class CalendarUsers extends models.Model {
220 _name = "calendar.users";
221
222 name = fields.Char();
223 partner_id = fields.Many2one({ relation: "calendar.partner" });
224 image = fields.Char();
225
226 _records = [
227 { id: serverState.userId, name: "user 1", partner_id: 1 },
228 { id: 4, name: "user 4", partner_id: 4 },
229 ];
230 }
231
232 class CalendarPartner extends models.Model {
233 _name = "calendar.partner";
234
235 name = fields.Char();
236 image = fields.Char();
237
238 _records = [
239 { id: 1, name: "partner 1", image: "AAA" },
240 { id: 2, name: "partner 2", image: "BBB" },
241 { id: 3, name: "partner 3", image: "CCC" },
242 { id: 4, name: "partner 4", image: "DDD" },
243 ];
244 }
245
246 class FilterPartner extends models.Model {
247 _name = "filter.partner";
248
249 user_id = fields.Many2one({ relation: "calendar.users" });
250 partner_id = fields.Many2one({ relation: "calendar.partner" });
251 is_checked = fields.Boolean();
252
253 _records = [
254 { id: 1, user_id: serverState.userId, partner_id: 1, is_checked: true },
255 { id: 2, user_id: serverState.userId, partner_id: 2, is_checked: true },
256 { id: 3, user_id: 4, partner_id: 3, is_checked: false },
257 ];
258 }
259
260 defineModels([Event, EventType, CalendarUsers, CalendarPartner, FilterPartner]);
261 preloadBundle("web.fullcalendar_lib");
262 beforeEach(() => {
263 mockDate("2016-12-12T08:00:00", 1);
264 const patchFullCalendarOptions = () => ({
265 get options() {
266 return Object.assign({}, super.options, {
267 longPressDelay: 0,
268 selectLongPressDelay: 0,
269 });
270 },
271 });
272 patchWithCleanup(CalendarYearRenderer.prototype, patchFullCalendarOptions());
273 patchWithCleanup(CalendarCommonRenderer.prototype, patchFullCalendarOptions());
274 });
275
276 onRpc("has_group", () => true);
277
278 /**
279 * @param {import("@odoo/hoot-dom").Target} from
280 * @param {import("@odoo/hoot-dom").Target} to
281 * @param {{
282 * start: "top" | "center" | "bottom";
283 * end: "top" | "center" | "bottom";
284 * }} [positions] specify where the touches will occur in the start and end elements
285 * (default: `"center"` for both)
286 * @returns {Promise<void>}
287 */
288 async function selectRange(from, to, positions) {
289 const startTarget = queryFirst(from);
290
291 const startRect = queryRect(startTarget);
292 const startPosition = {
293 x: startRect.width / 2,
294 y: 0,
295 };
296 if (positions?.start === "top") {
297 startPosition.y += 1;
298 } else if (positions?.start === "bottom") {
299 startPosition.y += startRect.height - 1;
300 } else {
301 startPosition.y += startRect.height / 2;
302 }
303
304 const endRect = queryRect(to);
305 const endPosition = {
306 x: endRect.width / 2,
307 y: 0,
308 };
309 if (positions?.end === "top") {
310 endPosition.y += 1;
311 } else if (positions?.end === "bottom") {
312 endPosition.y += endRect.height - 1;
313 } else {
314 endPosition.y += endRect.height / 2;
315 }
316
317 await pointerDown(startTarget, {
318 position: startPosition,
319 relative: true,
320 });
321 await animationFrame();
322
323 await hover(to, {
324 position: endPosition,
325 relative: true,
326 });
327 await animationFrame();
328
329 await pointerUp(to, {
330 position: endPosition,
331 relative: true,
332 });
333 await animationFrame();
334 }
335
336 function expectEventToBeOver(eventSelector, ranges) {
337 const eventRects = queryAllRects(eventSelector);
338 expect(eventRects.length).toBe(ranges.length);
339
340 let result = true;
341 for (const [[start, end], eventRect] of zip(ranges, eventRects)) {
342 const startDateRect = queryRect`.fc-daygrid-day[data-date="${start}"]`;
343 const endDateRect = queryRect`.fc-daygrid-day[data-date="${end}"]`;
344 const minX = startDateRect.left;
345 const maxX = endDateRect.right;
346 result &&=
347 eventRect.left >= minX &&
348 eventRect.left <= maxX &&
349 eventRect.right >= minX &&
350 eventRect.right <= maxX;
351 }
352 expect(result).toBe(true);
353 }
354
355 const checkFilterItems = async (amount) => {
356 await displayCalendarPanel();
357 expect(`.o_calendar_filter_item`).toHaveCount(amount);
358 await hideCalendarPanel();
359 };
360
361 test.tags("desktop");
362 test(`simple calendar rendering on desktop`, async () => {
363 Event._fields.partner_id = fields.Many2one({ relation: "calendar.partner" });
364 Event._records.push(
365 {
366 id: 8,
367 user_id: serverState.userId,
368 partner_id: false,
369 name: "event 7",
370 start: "2016-12-18 09:00:00",
371 stop: "2016-12-18 10:00:00",
372 attendee_ids: [2],
373 },
374 {
375 id: 9,
376 user_id: serverState.userId,
377 partner_id: false,
378 name: "event 8",
379 start: "2016-12-11 05:15:00",
380 stop: "2016-12-11 05:30:00",
381 attendee_ids: [1, 2, 3],
382 delay: 0.25,
383 }
384 );
385
386 await mountView({
387 resModel: "event",
388 type: "calendar",
389 arch: `
390 <calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="week" attendee="attendee_ids" color="partner_id" date_delay="delay">
391 <filter name="user_id" avatar_field="image"/>
392 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
393 <field name="partner_id" filters="1" invisible="1"/>
394 <field name="delay" invisible="1"/>
395 </calendar>
396 `,
397 });
398
399 // test events in different scale
400 expect(`.o_calendar_renderer .fc-view`).toHaveCount(1);
401 expect(`.o_event`).toHaveCount(0, {
402 message: "By default, only the events of the current user are displayed (0 in this case)",
403 });
404
405 await toggleSectionFilter("attendee_ids");
406 expect(`.o_event`).toHaveCount(6, {
407 message: "should display 6 events on the week (4 event + 1 is_all_day + 1 >24h is_all_day)",
408 });
409 expect(`.o_event_oneliner`).toHaveCount(1, {
410 message: "should contain 1 oneliner event (the one we add)",
411 });
412
413 await changeScale("day");
414 expect(`.o_event`).toHaveCount(2);
415 expect(`.o_calendar_sidebar .o_datetime_picker .o_selected`).toHaveCount(1);
416
417 await changeScale("month");
418 await toggleSectionFilter("attendee_ids");
419 await toggleFilter("attendee_ids", "1");
420 await toggleFilter("attendee_ids", "2");
421 expect(`.o_event`).toHaveCount(8, {
422 message:
423 "should display 7 events on the month (6 events + 2 week event - 1 'event 6' is filtered + 1 'Undefined event')",
424 });
425
426 // test filters
427 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(2);
428 expect(`.o_calendar_filter:eq(1)`).toBeVisible();
429 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item`).toHaveCount(3);
430
431 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item:eq(-1)`).not.toHaveAttribute(
432 "data-value"
433 );
434 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item:eq(-1)`).toHaveText("Undefined");
435 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item:eq(-1) label img`).toHaveCount(0);
436
437 expect(`.o_calendar_filter:eq(0)`).toBeVisible();
438 expect(`.o_calendar_filter:eq(0) .o_calendar_filter_item`).toHaveCount(2);
439 expect(`.o_calendar_filter:eq(0) .o-autocomplete`).toHaveCount(1);
440
441 await toggleFilter("attendee_ids", "1");
442 expect(`.o_event`).toHaveCount(6);
443
444 await toggleFilter("attendee_ids", "2");
445 expect(`.o_event`).toHaveCount(0);
446
447 // test search bar in filter
448 await contains(`.o_calendar_sidebar input[type=text]`).click();
449 expect(`.dropdown-item`).toHaveCount(2);
450 expect(queryAllTexts`.dropdown-item`).toEqual(["partner 3", "partner 4"]);
451
452 await contains(`.dropdown-item:eq(0)`).click();
453 expect(`.o_calendar_filter:eq(0) .o_calendar_filter_item`).toHaveCount(3);
454
455 await contains(`.o_calendar_sidebar input[type=text]`).click();
456 expect(`.dropdown-item`).toHaveCount(1);
457 expect(`.dropdown-item`).toHaveText("partner 4");
458
459 await removeFilter("attendee_ids", "2");
460 expect(`.o_calendar_filter:eq(0) .o_calendar_filter_item`).toHaveCount(2);
461 });
462
463 test.tags("mobile");
464 test(`simple calendar rendering on mobile`, async () => {
465 Event._fields.partner_id = fields.Many2one({ relation: "calendar.partner" });
466 Event._records.push(
467 {
468 id: 8,
469 user_id: serverState.userId,
470 partner_id: false,
471 name: "event 7",
472 start: "2016-12-18 09:00:00",
473 stop: "2016-12-18 10:00:00",
474 attendee_ids: [2],
475 },
476 {
477 id: 9,
478 user_id: serverState.userId,
479 partner_id: false,
480 name: "event 8",
481 start: "2016-12-11 05:15:00",
482 stop: "2016-12-11 05:30:00",
483 attendee_ids: [1, 2, 3],
484 delay: 0.25,
485 }
486 );
487
488 await mountView({
489 resModel: "event",
490 type: "calendar",
491 arch: `
492 <calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="week" attendee="attendee_ids" color="partner_id" date_delay="delay">
493 <filter name="user_id" avatar_field="image"/>
494 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
495 <field name="partner_id" filters="1" invisible="1"/>
496 <field name="delay" invisible="1"/>
497 </calendar>
498 `,
499 });
500
501 // test events in different scale
502 expect(`.o_calendar_renderer .fc-view`).toHaveCount(1);
503 expect(`.o_event`).toHaveCount(0, {
504 message: "By default, only the events of the current user are displayed (0 in this case)",
505 });
506 await toggleSectionFilter("attendee_ids");
507 await changeScale("week");
508 expect(`.o_event`).toHaveCount(6, {
509 message: "should display 6 events on the week (4 event + 1 is_all_day + 1 >24h is_all_day)",
510 });
511 expect(`.o_event_oneliner`).toHaveCount(1, {
512 message: "should contain 1 oneliner event (the one we add)",
513 });
514
515 await changeScale("day");
516 expect(`.o_event`).toHaveCount(2);
517 await changeScale("month");
518 await toggleSectionFilter("attendee_ids");
519 await toggleFilter("attendee_ids", "1");
520 await toggleFilter("attendee_ids", "2");
521 expect(`.o_event`).toHaveCount(8, {
522 message:
523 "should display 7 events on the month (6 events + 2 week event - 1 'event 6' is filtered + 1 'Undefined event')",
524 });
525
526 // test filters
527 await displayCalendarPanel();
528 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(2);
529 expect(`.o_calendar_filter:eq(1)`).toBeVisible();
530 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item`).toHaveCount(3);
531
532 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item:eq(-1)`).not.toHaveAttribute(
533 "data-value"
534 );
535 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item:eq(-1)`).toHaveText("Undefined");
536 expect(`.o_calendar_filter:eq(1) .o_calendar_filter_item:eq(-1) label img`).toHaveCount(0);
537
538 expect(`.o_calendar_filter:eq(0)`).toBeVisible();
539 expect(`.o_calendar_filter:eq(0) .o_calendar_filter_item`).toHaveCount(2);
540 expect(`.o_calendar_filter:eq(0) .o-autocomplete`).toHaveCount(1);
541 await hideCalendarPanel();
542 await toggleFilter("attendee_ids", "1");
543 expect(`.o_event`).toHaveCount(6);
544
545 await toggleFilter("attendee_ids", "2");
546 expect(`.o_event`).toHaveCount(0);
547
548 // test search bar in filter
549 await displayCalendarPanel();
550 await contains(`.o_calendar_sidebar input[type=text]`).click();
551 expect(`.dropdown-item`).toHaveCount(2);
552 expect(queryAllTexts`.dropdown-item`).toEqual(["partner 3", "partner 4"]);
553
554 await contains(`.dropdown-item:eq(0)`).click();
555 expect(`.o_calendar_filter:eq(0) .o_calendar_filter_item`).toHaveCount(3);
556
557 await contains(`.o_calendar_sidebar input[type=text]`).click();
558 expect(`.dropdown-item`).toHaveCount(1);
559 expect(`.dropdown-item`).toHaveText("partner 4");
560
561 await removeFilter("attendee_ids", "2");
562 expect(`.o_calendar_filter:eq(0) .o_calendar_filter_item`).toHaveCount(2);
563 });
564
565 test(`filter panel autocomplete: updates when typing`, async () => {
566 await mountView({
567 resModel: "event",
568 type: "calendar",
569 arch: `
570 <calendar date_start="start" date_stop="stop">
571 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
572 </calendar>
573 `,
574 });
575 await displayCalendarPanel();
576 const root = `.o_calendar_filter[data-name="attendee_ids"]`;
577 expect(`${root} .o-autocomplete--dropdown-menu`).toHaveCount(0);
578 expect(`${root} .o-autocomplete--dropdown-item`).toHaveCount(0);
579
580 await contains(`${root} .o-autocomplete--input`).click();
581 expect(`${root} .o-autocomplete--dropdown-menu`).toHaveCount(1);
582 expect(`${root} .o-autocomplete--dropdown-item`).toHaveCount(2);
583 expect(queryAllTexts(`${root} .o-autocomplete--dropdown-item`)).toEqual([
584 "partner 3",
585 "partner 4",
586 ]);
587
588 await contains(`${root} .o-autocomplete--input`).edit("partner 3", { confirm: false });
589 await advanceTime(500);
590 expect(`${root} .o-autocomplete--dropdown-menu`).toHaveCount(1);
591 expect(`${root} .o-autocomplete--dropdown-item`).toHaveCount(1);
592 expect(queryAllTexts(`${root} .o-autocomplete--dropdown-item`)).toEqual(["partner 3"]);
593
594 await contains(`${root} .o-autocomplete--input`).edit(
595 "a string that would yield to no result as it is too very much convoluted",
596 { confirm: false }
597 );
598 await advanceTime(500);
599 expect(`${root} .o-autocomplete--dropdown-menu`).toHaveCount(1);
600 expect(`${root} .o-autocomplete--dropdown-item`).toHaveCount(1);
601 expect(queryAllTexts(`${root} .o-autocomplete--dropdown-item`)).toEqual(["No records"]);
602 });
603
604 test(`check the avatar of the attendee in the calendar filter panel`, async () => {
605 CalendarPartner._views = {
606 list: `<list><field name="name"/></list>`,
607 kanban: `<kanban><templates><t name="card"><field name="name"/></t></templates></kanban>`,
608 };
609 CalendarPartner._records.push(
610 { id: 5, name: "foo partner 5" },
611 { id: 6, name: "foo partner 6" },
612 { id: 7, name: "foo partner 7" },
613 { id: 8, name: "foo partner 8" },
614 { id: 9, name: "foo partner 9" },
615 { id: 10, name: "foo partner 10" },
616 { id: 11, name: "foo partner 11" },
617 { id: 12, name: "foo partner 12" },
618 { id: 13, name: "foo partner 13" }
619 );
620
621 await mountView({
622 resModel: "event",
623 type: "calendar",
624 arch: `
625 <calendar date_start="start" date_stop="stop">
626 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" avatar_field="avatar_128"/>
627 </calendar>
628 `,
629 });
630 await displayCalendarPanel();
631 const section = `.o_calendar_filter[data-name="attendee_ids"]`;
632
633 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(1);
634 expect(`.o_calendar_filter:eq(0) .o-autocomplete`).toHaveCount(1);
635 expect(".o_calendar_filter_item:eq(-2)").not.toHaveText("partner 3");
636
637 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(0);
638 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(0);
639 await contains(`${section} .o-autocomplete--input`).click();
640 await runAllTimers();
641 expect(".o-autocomplete--dropdown-item:first-child").toHaveText("partner 3");
642 expect(`.o-autocomplete--dropdown-item:first-child .dropdown-item img`).toHaveClass("o_avatar");
643
644 await contains(".o-autocomplete--dropdown-item:first-child").click();
645 expect(".o_calendar_filter_item:eq(-1)").toHaveText("partner 3");
646 });
647
648 test.tags("desktop");
649 test(`Select multiple attendees in the calendar filter panel autocomplete on desktop`, async () => {
650 CalendarPartner._views = {
651 list: `<list><field name="name"/></list>`,
652 };
653 CalendarPartner._records.push(
654 { id: 5, name: "foo partner 5" },
655 { id: 6, name: "foo partner 6" },
656 { id: 7, name: "foo partner 7" },
657 { id: 8, name: "foo partner 8" },
658 { id: 9, name: "foo partner 9" },
659 { id: 10, name: "foo partner 10" },
660 { id: 11, name: "foo partner 11" },
661 { id: 12, name: "foo partner 12" },
662 { id: 13, name: "foo partner 13" },
663 { id: 14, name: "foo partner 14" }
664 );
665
666 await mountView({
667 resModel: "event",
668 type: "calendar",
669 arch: `
670 <calendar date_start="start" date_stop="stop">
671 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
672 </calendar>
673 `,
674 });
675
676 const section = `.o_calendar_filter[data-name="attendee_ids"]`;
677 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(1);
678 await checkFilterItems(2);
679 expect(queryAllTexts`.o_calendar_filter_item`).toEqual(["partner 1", "partner 2"]);
680
681 expect(`.o_calendar_filter:eq(0) .o-autocomplete`).toHaveCount(1);
682 await contains(`${section} .o-autocomplete--input`).click();
683 await runAllTimers();
684 expect(`.dropdown-item`).toHaveCount(9);
685 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
686 "partner 3",
687 "partner 4",
688 "foo partner 5",
689 "foo partner 6",
690 "foo partner 7",
691 "foo partner 8",
692 "foo partner 9",
693 "foo partner 10",
694 "Search More...",
695 ]);
696
697 await contains(`.o-autocomplete--dropdown-item:last-child`).click();
698 expect(`.modal .o_data_row`).toHaveCount(12);
699 await contains(".o_data_row:nth-child(1) .o_list_record_selector").click();
700 await contains(".o_data_row:nth-child(2) .o_list_record_selector").click();
701 await contains(".o_dialog .o_select_button").click();
702 expect("o_dialog").toHaveCount(0);
703
704 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(1);
705 await checkFilterItems(4);
706 expect(queryAllTexts`.o_calendar_filter_item`).toEqual([
707 "partner 1",
708 "partner 2",
709 "partner 3",
710 "partner 4",
711 ]);
712 });
713
714 test.tags("desktop");
715 test(`add a filter with the search more dialog on desktop`, async () => {
716 CalendarPartner._views = {
717 list: `<list><field name="name"/></list>`,
718 };
719 CalendarPartner._records.push(
720 { id: 5, name: "foo partner 5" },
721 { id: 6, name: "foo partner 6" },
722 { id: 7, name: "foo partner 7" },
723 { id: 8, name: "foo partner 8" },
724 { id: 9, name: "foo partner 9" },
725 { id: 10, name: "foo partner 10" },
726 { id: 11, name: "foo partner 11" },
727 { id: 12, name: "foo partner 12" },
728 { id: 13, name: "foo partner 13" },
729 { id: 14, name: "foo partner 14" }
730 );
731
732 await mountView({
733 resModel: "event",
734 type: "calendar",
735 arch: `
736 <calendar date_start="start" date_stop="stop">
737 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
738 </calendar>
739 `,
740 });
741 const section = `.o_calendar_filter[data-name="attendee_ids"]`;
742 expect(`${section} .o_calendar_filter_item`).toHaveCount(2);
743 expect(queryAllTexts`.o_calendar_filter_item`).toEqual(["partner 1", "partner 2"]);
744
745 // Open the autocomplete dropdown
746 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(0);
747 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(0);
748 await contains(`${section} .o-autocomplete--input`).click();
749 await advanceTime(500);
750 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
751 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
752 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
753 "partner 3",
754 "partner 4",
755 "foo partner 5",
756 "foo partner 6",
757 "foo partner 7",
758 "foo partner 8",
759 "foo partner 9",
760 "foo partner 10",
761 "Search More...",
762 ]);
763
764 // Change the search term
765 await contains(`.o-autocomplete--input`).edit("foo", { confirm: false });
766 await advanceTime(500);
767 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
768 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
769 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
770 "foo partner 5",
771 "foo partner 6",
772 "foo partner 7",
773 "foo partner 8",
774 "foo partner 9",
775 "foo partner 10",
776 "foo partner 11",
777 "foo partner 12",
778 "Search More...",
779 ]);
780
781 // Open the search more dialog
782 expect(`.modal`).toHaveCount(0);
783 await contains(`${section} .o-autocomplete--dropdown-item:last-child`).click();
784 expect(`.modal`).toHaveCount(1);
785 expect(`.modal .o_data_row`).toHaveCount(10);
786 expect(queryAllTexts`.modal .o_data_row`).toEqual([
787 "foo partner 5",
788 "foo partner 6",
789 "foo partner 7",
790 "foo partner 8",
791 "foo partner 9",
792 "foo partner 10",
793 "foo partner 11",
794 "foo partner 12",
795 "foo partner 13",
796 "foo partner 14",
797 ]);
798 expect(`.modal .o_searchview_facet`).toHaveCount(1);
799 expect(`.modal .o_searchview_facet`).toHaveText("Quick search: foo");
800
801 // Choose a record
802 await contains(".o_data_row:nth-child(1) .o_list_record_selector").click();
803 await contains(".o_data_row:nth-child(2) .o_list_record_selector").click();
804 await contains(".o_dialog .o_select_button").click();
805 expect("o_dialog").toHaveCount(0);
806
807 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(1);
808 await checkFilterItems(4);
809 expect(queryAllTexts`.o_calendar_filter_item`).toEqual([
810 "foo partner 5",
811 "foo partner 6",
812 "partner 1",
813 "partner 2",
814 ]);
815
816 // Open the autocomplete dropdown
817 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(0);
818 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(0);
819 await contains(`${section} .o-autocomplete--input`).click();
820 await advanceTime(500);
821 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
822 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
823 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
824 "partner 3",
825 "partner 4",
826 "foo partner 7",
827 "foo partner 8",
828 "foo partner 9",
829 "foo partner 10",
830 "foo partner 11",
831 "foo partner 12",
832 "Search More...",
833 ]);
834
835 // Change the search term
836 await contains(`.o-autocomplete--input`).edit("foo", { confirm: false });
837 await advanceTime(500);
838 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
839 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
840 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
841 "foo partner 7",
842 "foo partner 8",
843 "foo partner 9",
844 "foo partner 10",
845 "foo partner 11",
846 "foo partner 12",
847 "foo partner 13",
848 "foo partner 14",
849 "Search More...",
850 ]);
851
852 // Open the search more dialog
853 expect(`.modal`).toHaveCount(0);
854 await contains(`${section} .o-autocomplete--dropdown-item:last-child`).click();
855 expect(`.modal`).toHaveCount(1);
856 expect(`.modal .o_data_row`).toHaveCount(8);
857 expect(queryAllTexts`.modal .o_data_row`).toEqual([
858 "foo partner 7",
859 "foo partner 8",
860 "foo partner 9",
861 "foo partner 10",
862 "foo partner 11",
863 "foo partner 12",
864 "foo partner 13",
865 "foo partner 14",
866 ]);
867 expect(`.modal .o_searchview_facet`).toHaveCount(1);
868 expect(`.modal .o_searchview_facet`).toHaveText("Quick search: foo");
869
870 // Close the search more dialog without choosing a record
871 await contains(`.modal .o_form_button_cancel`).click();
872 expect(`.modal`).toHaveCount(0);
873 expect(`${section} .o_calendar_filter_item`).toHaveCount(4);
874 expect(queryAllTexts`.o_calendar_filter_item`).toEqual([
875 "foo partner 5",
876 "foo partner 6",
877 "partner 1",
878 "partner 2",
879 ]);
880 expect(`.o-autocomplete--input`).toHaveValue("");
881 });
882
883 test.tags("desktop");
884 test(`add a filter with the search more dialog (field with a context)`, async () => {
885 CalendarPartner._views = {
886 list: `<list><field name="name"/></list>`,
887 };
888 CalendarPartner._records.push(
889 { id: 5, name: "foo partner 5" },
890 { id: 6, name: "foo partner 6" },
891 { id: 7, name: "foo partner 7" },
892 { id: 8, name: "foo partner 8" },
893 { id: 9, name: "foo partner 9" },
894 { id: 10, name: "foo partner 10" },
895 { id: 11, name: "foo partner 11" },
896 { id: 12, name: "foo partner 12" },
897 { id: 13, name: "foo partner 13" },
898 { id: 14, name: "foo partner 14" }
899 );
900
901 await mountView({
902 resModel: "event",
903 type: "calendar",
904 arch: `
905 <calendar date_start="start" date_stop="stop">
906 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" context="{'search_view_ref': 'my_view'}"/>
907 </calendar>
908 `,
909 });
910
911 onRpc("get_views", ({ kwargs }) => {
912 expect.step("get_views");
913 expect(kwargs.context.search_view_ref).toBe("my_view");
914 });
915 await contains(`.o_calendar_filter[data-name="attendee_ids"] .o-autocomplete--input`).click();
916 await advanceTime(500);
917 expect(
918 `.o_calendar_filter[data-name="attendee_ids"] .o-autocomplete--dropdown-item:last-child`
919 ).toHaveText("Search More...");
920 await contains(
921 `.o_calendar_filter[data-name="attendee_ids"] .o-autocomplete--dropdown-item:last-child`
922 ).click();
923 expect(`.modal`).toHaveCount(1);
924 expect.verifySteps(["get_views"]);
925 });
926
927 test.tags("mobile");
928 test(`add a filter with the search more dialog on mobile`, async () => {
929 CalendarPartner._views = {
930 list: `<list><field name="name"/></list>`,
931 kanban: `<kanban><templates><t t-name="card"><field class="o_data_row" name="name"/></t></templates></kanban>`,
932 };
933 CalendarPartner._records.push(
934 { id: 5, name: "foo partner 5" },
935 { id: 6, name: "foo partner 6" },
936 { id: 7, name: "foo partner 7" },
937 { id: 8, name: "foo partner 8" },
938 { id: 9, name: "foo partner 9" },
939 { id: 10, name: "foo partner 10" },
940 { id: 11, name: "foo partner 11" },
941 { id: 12, name: "foo partner 12" },
942 { id: 13, name: "foo partner 13" },
943 { id: 14, name: "foo partner 14" }
944 );
945
946 await mountView({
947 resModel: "event",
948 type: "calendar",
949 arch: `
950 <calendar date_start="start" date_stop="stop">
951 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
952 </calendar>
953 `,
954 });
955 await displayCalendarPanel();
956 const section = `.o_calendar_filter[data-name="attendee_ids"]`;
957 expect(`${section} .o_calendar_filter_item`).toHaveCount(2);
958 expect(queryAllTexts`.o_calendar_filter_item`).toEqual(["partner 1", "partner 2"]);
959
960 // Open the autocomplete dropdown
961 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(0);
962 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(0);
963 await contains(`${section} .o-autocomplete--input`).click();
964 await advanceTime(500);
965 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
966 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
967 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
968 "partner 3",
969 "partner 4",
970 "foo partner 5",
971 "foo partner 6",
972 "foo partner 7",
973 "foo partner 8",
974 "foo partner 9",
975 "foo partner 10",
976 "Search More...",
977 ]);
978
979 // Change the search term
980 await contains(`.o-autocomplete--input`).edit("foo", { confirm: false });
981 await advanceTime(500);
982 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
983 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
984 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
985 "foo partner 5",
986 "foo partner 6",
987 "foo partner 7",
988 "foo partner 8",
989 "foo partner 9",
990 "foo partner 10",
991 "foo partner 11",
992 "foo partner 12",
993 "Search More...",
994 ]);
995
996 // Open the search more dialog
997 expect(`.modal`).toHaveCount(0);
998 await contains(`${section} .o-autocomplete--dropdown-item:last-child`).click();
999 expect(`.modal`).toHaveCount(1);
1000 expect(`.modal .o_data_row`).toHaveCount(10);
1001 expect(queryAllTexts`.modal .o_data_row`).toEqual([
1002 "foo partner 5",
1003 "foo partner 6",
1004 "foo partner 7",
1005 "foo partner 8",
1006 "foo partner 9",
1007 "foo partner 10",
1008 "foo partner 11",
1009 "foo partner 12",
1010 "foo partner 13",
1011 "foo partner 14",
1012 ]);
1013 await contains(".o_data_row:eq(0)").click();
1014 await contains(`.o-autocomplete--input`).edit("foo", { confirm: false });
1015 await advanceTime(500);
1016 await contains(`${section} .o-autocomplete--dropdown-item:last-child`).click();
1017 await contains(".o_data_row:eq(0)").click();
1018 expect("o_dialog").toHaveCount(0);
1019
1020 expect(`.o_calendar_sidebar .o_calendar_filter`).toHaveCount(1);
1021 expect(`.o_calendar_filter_item`).toHaveCount(4);
1022 expect(queryAllTexts`.o_calendar_filter_item`).toEqual([
1023 "foo partner 5",
1024 "foo partner 6",
1025 "partner 1",
1026 "partner 2",
1027 ]);
1028
1029 // Open the autocomplete dropdown
1030 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(0);
1031 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(0);
1032 await contains(`${section} .o-autocomplete--input`).click();
1033 await advanceTime(500);
1034 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
1035 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
1036 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
1037 "partner 3",
1038 "partner 4",
1039 "foo partner 7",
1040 "foo partner 8",
1041 "foo partner 9",
1042 "foo partner 10",
1043 "foo partner 11",
1044 "foo partner 12",
1045 "Search More...",
1046 ]);
1047
1048 // Change the search term
1049 await contains(`.o-autocomplete--input`).edit("foo", { confirm: false });
1050 await advanceTime(500);
1051 expect(`${section} .o-autocomplete--dropdown-menu`).toHaveCount(1);
1052 expect(`${section} .o-autocomplete--dropdown-item`).toHaveCount(9);
1053 expect(queryAllTexts`.o-autocomplete--dropdown-item`).toEqual([
1054 "foo partner 7",
1055 "foo partner 8",
1056 "foo partner 9",
1057 "foo partner 10",
1058 "foo partner 11",
1059 "foo partner 12",
1060 "foo partner 13",
1061 "foo partner 14",
1062 "Search More...",
1063 ]);
1064
1065 // Open the search more dialog
1066 expect(`.modal`).toHaveCount(0);
1067 await contains(`${section} .o-autocomplete--dropdown-item:last-child`).click();
1068 expect(`.modal`).toHaveCount(1);
1069 expect(`.modal .o_data_row`).toHaveCount(8);
1070 expect(queryAllTexts`.modal .o_data_row`).toEqual([
1071 "foo partner 7",
1072 "foo partner 8",
1073 "foo partner 9",
1074 "foo partner 10",
1075 "foo partner 11",
1076 "foo partner 12",
1077 "foo partner 13",
1078 "foo partner 14",
1079 ]);
1080 await closeCwPopOver();
1081 expect(`.modal`).toHaveCount(0);
1082 expect(`${section} .o_calendar_filter_item`).toHaveCount(4);
1083 expect(queryAllTexts`.o_calendar_filter_item`).toEqual([
1084 "foo partner 5",
1085 "foo partner 6",
1086 "partner 1",
1087 "partner 2",
1088 ]);
1089 expect(`.o-autocomplete--input`).toHaveValue("");
1090 });
1091
1092 test(`delete attribute on calendar doesn't show delete button in popover`, async () => {
1093 await mountView({
1094 resModel: "event",
1095 type: "calendar",
1096 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" delete="0" mode="month"/>`,
1097 });
1098
1099 await clickEvent(4);
1100 const container = getMockEnv().isSmall ? ".modal" : ".o_cw_popover";
1101 expect(container).toHaveCount(1);
1102 expect(`${container} .o_cw_popover_delete`).toHaveCount(0);
1103 });
1104
1105 test.tags("desktop");
1106 test(`create and change events on desktop`, async () => {
1107 onRpc("web_save", ({ args }) => {
1108 if (args[0].length) {
1109 expect.step("web_save");
1110 expect(args[1]).toEqual({ name: "event 4 modified" });
1111 }
1112 });
1113 await mountView({
1114 resModel: "event",
1115 type: "calendar",
1116 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
1117 });
1118 expect(`.fc-dayGridMonth-view`).toHaveCount(1);
1119
1120 // click on an existing event to open the formViewDialog
1121 await clickEvent(4);
1122 expect(`.o_cw_popover`).toHaveCount(1);
1123 expect(`.o_cw_popover .o_cw_popover_edit`).toHaveCount(1);
1124 expect(`.o_cw_popover .o_cw_popover_delete`).toHaveCount(1);
1125 expect(`.o_cw_popover .o_cw_popover_close`).toHaveCount(1);
1126
1127 await contains(`.o_cw_popover .o_cw_popover_edit`).click();
1128 expect(`.modal-body`).toHaveCount(1);
1129
1130 await contains(`.modal-body input`).edit("event 4 modified");
1131 await contains(`.modal-footer .o_form_button_save`).click();
1132 expect(`.modal-body`).toHaveCount(0);
1133
1134 // create a new event, quick create only
1135 await clickDate("2016-12-13");
1136 expect(`.o-calendar-quick-create`).toHaveCount(1);
1137
1138 await contains(`.o-calendar-quick-create--input`).edit("new event in quick create", {
1139 confirm: false,
1140 });
1141 await contains(`.o-calendar-quick-create--create-btn`).click();
1142 expect(`.o_event[data-event-id="8"]`).toHaveText("new event in quick create");
1143 expect(
1144 `.fc-daygrid-event-harness:not(.fc-daygrid-event-harness-abs):contains("new event in quick create")`
1145 ).toHaveCount(1);
1146
1147 // create a new event, quick create only (validated by pressing enter key)
1148 await clickDate("2016-12-13");
1149 expect(`.o-calendar-quick-create`).toHaveCount(1);
1150
1151 await contains(`.o-calendar-quick-create--input`).edit(
1152 "new event in quick create validated by pressing enter key.",
1153 { confirm: "enter" }
1154 );
1155 expect(`.o_event[data-event-id="9"]`).toHaveText(
1156 "new event in quick create validated by pressing enter key."
1157 );
1158
1159 // create a new event and edit it
1160 await clickDate("2016-12-27");
1161 expect(`.o-calendar-quick-create`).toHaveCount(1);
1162
1163 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
1164 await contains(`.o-calendar-quick-create--edit-btn`).click();
1165 expect(`.modal`).toHaveCount(1);
1166 expect(`.modal .modal-title`).toHaveText("New Event");
1167 expect(`.modal [name="name"] input`).toHaveValue("coucou");
1168
1169 await contains(`.modal-footer .o_form_button_save`).click();
1170 expect(`.o_event[data-event-id="10"]`).toHaveText("coucou");
1171
1172 // create a new event with 2 days
1173 await selectDateRange("2016-12-20", "2016-12-21");
1174 await contains(`.o-calendar-quick-create--input`).edit("new event in quick create 2", {
1175 confirm: false,
1176 });
1177 await contains(`.o-calendar-quick-create--edit-btn`).click();
1178 expect(`.modal .o_form_view [name="name"] input`).toHaveValue("new event in quick create 2");
1179
1180 await contains(`.modal-footer .o_form_button_save`).click();
1181 expect(`.modal`).toHaveCount(0);
1182
1183 expect(`.o_event[data-event-id="11"]`).toHaveText("new event in quick create 2");
1184 expectEventToBeOver(`.o_event[data-event-id="11"]`, [["2016-12-20", "2016-12-21"]]);
1185
1186 await clickEvent(11);
1187 expect(`.o_cw_popover .list-group-item:eq(0)`).toHaveText("December 20-21, 2016 2 days");
1188 await closeCwPopOver();
1189
1190 // delete the a record
1191 await clickEvent(4);
1192 await contains(`.o_cw_popover_delete`).click();
1193 expect(`.modal-title`).toHaveText("Bye-bye, record!");
1194
1195 await contains(`.modal-footer button.btn-primary`).click();
1196 expect(`.o_event[data-event-id="4"]`).toHaveCount(0);
1197 expect(`.o_event`).toHaveCount(10);
1198
1199 // move to next month
1200 await navigate("next");
1201 expect(`.o_event`).toHaveCount(0);
1202
1203 await pickDate("2017-01-01");
1204 await changeScale("month");
1205 expect(`.o_event`).toHaveCount(0);
1206
1207 await navigate("prev");
1208 await pickDate("2016-12-27");
1209 await changeScale("month");
1210 await selectDateRange("2016-12-20", "2016-12-21");
1211 await contains(`.o-calendar-quick-create--input`).edit("test", { confirm: false });
1212 await contains(`.o-calendar-quick-create--create-btn`).click();
1213 expect.verifySteps(["web_save"]);
1214 });
1215
1216 test.tags("mobile");
1217 test(`create and change events on mobile`, async () => {
1218 onRpc("web_save", ({ args }) => {
1219 if (args[0].length) {
1220 expect.step("web_save");
1221 expect(args[1]).toEqual({ name: "event 4 modified" });
1222 }
1223 });
1224 await mountView({
1225 resModel: "event",
1226 type: "calendar",
1227 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
1228 });
1229 expect(`.fc-dayGridMonth-view`).toHaveCount(1);
1230
1231 // click on an existing event to open the formViewDialog
1232 await clickEvent(4);
1233 const container = ".modal";
1234 const closeButton = ".oi-arrow-left";
1235 expect(container).toHaveCount(1);
1236 expect(`${container} .o_cw_popover_edit`).toHaveCount(1);
1237 expect(`${container} .o_cw_popover_delete`).toHaveCount(1);
1238 expect(`${container} ${closeButton}`).toHaveCount(1);
1239
1240 await contains(`${container} .o_cw_popover_edit`).click();
1241 expect(`.modal-body`).toHaveCount(1);
1242
1243 await contains(`.modal-body input:eq(0)`).edit("event 4 modified");
1244 await contains(`.modal-footer .o_form_button_save`).click();
1245 expect(`.modal-body`).toHaveCount(0);
1246
1247 // create a new event, quick create only
1248 await clickDate("2016-12-13");
1249 expect(`.o-calendar-quick-create`).toHaveCount(1);
1250
1251 await contains(`.o-calendar-quick-create--input`).edit("new event in quick create", {
1252 confirm: false,
1253 });
1254 await contains(`.o-calendar-quick-create--create-btn`).click();
1255 expect(`.o_event[data-event-id="8"]`).toHaveText("new event in quick create");
1256 expect(
1257 `.fc-daygrid-event-harness:not(.fc-daygrid-event-harness-abs):contains("new event in quick create")`
1258 ).toHaveCount(1);
1259
1260 // create a new event, quick create only (validated by pressing enter key)
1261 await clickDate("2016-12-13");
1262 expect(`.o-calendar-quick-create`).toHaveCount(1);
1263
1264 await contains(`.o-calendar-quick-create--input`).edit(
1265 "new event in quick create validated by pressing enter key.",
1266 { confirm: "enter" }
1267 );
1268 expect(`.o_event[data-event-id="9"]`).toHaveText(
1269 "new event in quick create validated by pressing enter key."
1270 );
1271
1272 // create a new event and edit it
1273 await clickDate("2016-12-27");
1274 expect(`.o-calendar-quick-create`).toHaveCount(1);
1275
1276 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
1277 await contains(`.o-calendar-quick-create--edit-btn`).click();
1278 expect(`.modal`).toHaveCount(1);
1279 expect(`.modal .modal-title`).toHaveText("New Event");
1280 expect(`.modal [name="name"] input`).toHaveValue("coucou");
1281
1282 await contains(`.modal-footer .o_form_button_save`).click();
1283 expect(`.o_event[data-event-id="10"]`).toHaveText("coucou");
1284
1285 // create a new event with 2 days
1286 await selectDateRange("2016-12-20", "2016-12-21");
1287 await contains(`.o-calendar-quick-create--input`).edit("new event in quick create 2", {
1288 confirm: false,
1289 });
1290 await contains(`.o-calendar-quick-create--edit-btn`).click();
1291 expect(`.modal .o_form_view [name="name"] input`).toHaveValue("new event in quick create 2");
1292
1293 await contains(`.modal-footer .o_form_button_save`).click();
1294 expect(`.modal`).toHaveCount(0);
1295
1296 expect(`.o_event[data-event-id="11"]`).toHaveText("new event in quick create 2");
1297 expectEventToBeOver(`.o_event[data-event-id="11"]`, [["2016-12-20", "2016-12-21"]]);
1298
1299 await clickEvent(11);
1300
1301 expect(`${container} .list-group-item:eq(0)`).toHaveText("December 20-21, 2016 2 days");
1302
1303 await closeCwPopOver();
1304
1305 // delete the a record
1306 await clickEvent(4);
1307 await contains(`.o_cw_popover_delete`).click();
1308 expect(`.modal-title`).toHaveText("Bye-bye, record!");
1309
1310 await contains(`.modal-footer button.btn-primary`).click();
1311 expect(`.o_event[data-event-id="4"]`).toHaveCount(0);
1312 expect(`.o_event`).toHaveCount(10);
1313
1314 // move to next month
1315 await navigate("next");
1316
1317 expect(`.o_event`).toHaveCount(0);
1318
1319 await navigate("prev");
1320
1321 await selectDateRange("2016-12-20", "2016-12-21");
1322 await contains(`.o-calendar-quick-create--input`).edit("test", { confirm: false });
1323 await contains(`.o-calendar-quick-create--create-btn`).click();
1324
1325 expect.verifySteps(["web_save"]);
1326 });
1327
1328 test(`quickcreate with custom create_name_field`, async () => {
1329 class CustomEvent extends models.Model {
1330 _name = "custom.event";
1331
1332 x_name = fields.Char();
1333 x_start_date = fields.Date();
1334
1335 has_access() {
1336 return true;
1337 }
1338
1339 _records = [{ id: 1, x_name: "some event", x_start_date: "2016-12-06" }];
1340 }
1341 defineModels([CustomEvent]);
1342
1343 onRpc("create", ({ args }) => {
1344 expect.step("create");
1345 expect(args[0]).toEqual([
1346 {
1347 x_name: "custom event in quick create",
1348 x_start_date: "2016-12-13",
1349 },
1350 ]);
1351 });
1352
1353 await mountView({
1354 resModel: "custom.event",
1355 type: "calendar",
1356 arch: `<calendar date_start="x_start_date" create_name_field="x_name" mode="month"/>`,
1357 });
1358
1359 // create a new event
1360 await clickDate("2016-12-13");
1361 expect(`.o-calendar-quick-create`).toHaveCount(1);
1362
1363 await contains(`.o-calendar-quick-create--input`).edit("custom event in quick create", {
1364 confirm: false,
1365 });
1366 await contains(`.o-calendar-quick-create--create-btn`).click();
1367 expect(`.o_event[data-event-id="2"]`).toHaveCount(1);
1368 expect(`.o_event[data-event-id="2"]`).toHaveText("custom event in quick create");
1369 expect.verifySteps(["create"]);
1370 });
1371
1372 test(`quickcreate switching to actual create for required fields`, async () => {
1373 onRpc("create", () => {
1374 throw makeServerError();
1375 });
1376
1377 await mountView({
1378 resModel: "event",
1379 type: "calendar",
1380 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" event_open_popup="1"/>`,
1381 });
1382
1383 await clickDate("2016-12-13");
1384 expect(`.modal-title`).toHaveText("New Event");
1385
1386 await contains(`.o-calendar-quick-create--input`).edit("custom event in quick create", {
1387 confirm: false,
1388 });
1389 await contains(`.o-calendar-quick-create--create-btn`).click();
1390 expect(`.o-calendar-quick-create`).toHaveCount(0);
1391 expect(`.modal-title`).toHaveText("New Event");
1392 expect(`.modal .o_form_view .o_form_editable`).toHaveCount(1);
1393 });
1394
1395 test(`open multiple event form at the same time`, async () => {
1396 let callCounter = 0;
1397 mockService("dialog", {
1398 add() {
1399 callCounter++;
1400 return super.add(...arguments);
1401 },
1402 });
1403
1404 await mountView({
1405 resModel: "event",
1406 type: "calendar",
1407 arch: `
1408 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" event_open_popup="1" quick_create="0">
1409 <field name="name"/>
1410 </calendar>
1411 `,
1412 });
1413
1414 for (let i = 0; i < 5; i++) {
1415 await clickDate("2016-12-13");
1416 }
1417
1418 expect(callCounter).toBe(5, { message: "there should had been 5 attemps to open a modal" });
1419 expect(`.modal`).toHaveCount(1, { message: "there should be only one open modal" });
1420 });
1421
1422 test(`create event with timezone in week mode European locale`, async () => {
1423 mockTimeZone(2);
1424 Event._records = [];
1425
1426 onRpc("create", ({ args }) => {
1427 expect.step("create");
1428 expect(args[0]).toEqual([
1429 {
1430 is_all_day: false,
1431 name: "new event",
1432 start: "2016-12-13 06:00:00",
1433 stop: "2016-12-13 08:00:00",
1434 },
1435 ]);
1436 });
1437 await mountView({
1438 resModel: "event",
1439 type: "calendar",
1440 arch: `
1441 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1">
1442 <field name="name"/>
1443 <field name="start"/>
1444 <field name="is_all_day"/>
1445 </calendar>
1446 `,
1447 });
1448 await selectTimeRange("2016-12-13 08:00:00", "2016-12-13 10:00:00");
1449 expect(`.fc-event-main .fc-event-time`).toHaveText("08:00 - 10:00");
1450
1451 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
1452 await contains(`.o-calendar-quick-create--create-btn`).click();
1453 expect.verifySteps(["create"]);
1454 expect(`.fc-event-main .o_event_title`).toHaveText("new event");
1455
1456 await clickEvent(1);
1457 await contains(`.o_cw_popover_delete`).click();
1458 await contains(`.modal button.btn-primary`).click();
1459 expect(`.fc-event-main`).toHaveCount(0);
1460 });
1461
1462 test(`create multi day event in week mode`, async () => {
1463 mockTimeZone(2);
1464
1465 patchWithCleanup(CalendarCommonRenderer.prototype, {
1466 get options() {
1467 return { ...super.options, selectAllow: () => true };
1468 },
1469 });
1470 await mountView({
1471 resModel: "event",
1472 type: "calendar",
1473 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
1474 });
1475 await selectTimeRange("2016-12-13 11:00:00", "2016-12-14 16:00:00");
1476 expect(`.fc-event-main .fc-event-time`).toHaveText("11:00 - 16:00");
1477 });
1478
1479 test(`default week start (US)`, async () => {
1480 // if not given any option, default week start is on Sunday
1481 mockTimeZone(-7);
1482 onRpc("event", "search_read", ({ kwargs }) => {
1483 expect.step("event.search_read");
1484 expect(kwargs.domain).toEqual([
1485 ["start", "<=", "2016-12-18 06:59:59"],
1486 ["stop", ">=", "2016-12-11 07:00:00"],
1487 ]);
1488 });
1489 await mountView({
1490 resModel: "event",
1491 type: "calendar",
1492 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
1493 });
1494 expect.verifySteps(["event.search_read"]);
1495 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("SUN");
1496 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SAT");
1497 });
1498
1499 test(`European week start`, async () => {
1500 // the week start depends on the locale
1501 defineParams({ lang_parameters: { week_start: 1 } });
1502
1503 onRpc("event", "search_read", ({ kwargs }) => {
1504 expect.step("event.search_read");
1505 expect(kwargs.domain).toEqual([
1506 ["start", "<=", "2016-12-18 22:59:59"],
1507 ["stop", ">=", "2016-12-11 23:00:00"],
1508 ]);
1509 });
1510 await mountView({
1511 resModel: "event",
1512 type: "calendar",
1513 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
1514 });
1515 expect.verifySteps(["event.search_read"]);
1516 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("MON");
1517 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SUN");
1518 });
1519
1520 test.tags("desktop");
1521 test(`week numbering`, async () => {
1522 // Using ISO week calculation, get the ISO week number of
1523 // the Monday nearest to the start of the week.
1524 defineParams({ lang_parameters: { week_start: 7 } });
1525
1526 await mountView({
1527 resModel: "event",
1528 type: "calendar",
1529 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
1530 });
1531 expect(`.fc-timegrid-axis-cushion:eq(0)`).toHaveText("Week 50");
1532 });
1533
1534 test.tags("desktop");
1535 test(`render popover`, async () => {
1536 await mountView({
1537 resModel: "event",
1538 type: "calendar",
1539 arch: `
1540 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week">
1541 <field name="name" string="Custom Name"/>
1542 <field name="partner_id"/>
1543 </calendar>
1544 `,
1545 });
1546
1547 await clickEvent(2);
1548 expect(`.o_cw_popover`).toHaveCount(1);
1549 expect(`.o_cw_popover .popover-header`).toHaveText("event 2");
1550 expect(`.o_cw_popover .o_cw_popover_edit`).toHaveCount(1);
1551 expect(`.o_cw_popover .o_cw_popover_delete`).toHaveCount(1);
1552 expect(`.o_cw_popover .o_cw_popover_close`).toHaveCount(1);
1553 expect(`.o_cw_popover .list-group-item:eq(0)`).toHaveText("December 12, 2016");
1554 expect(`.o_cw_popover .list-group-item:eq(1)`).toHaveText("11:55 - 15:55 (4 hours)");
1555 expect(`.o_cw_popover .o_cw_popover_fields_secondary .list-group-item`).toHaveCount(2);
1556 expect(
1557 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item:eq(0) .o_field_char`
1558 ).toHaveCount(1);
1559 expect(
1560 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item:eq(0) .o_field_char`
1561 ).toHaveText("event 2");
1562 expect(
1563 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item:eq(0) span.fw-bold`
1564 ).toHaveText("Custom Name");
1565 expect(
1566 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item:eq(1) .o_form_uri`
1567 ).toHaveCount(1);
1568 expect(
1569 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item:eq(1) .o_form_uri`
1570 ).toHaveText("partner 1");
1571 expect(
1572 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item:eq(1) span.fw-bold`
1573 ).toHaveText("Partner");
1574
1575 await contains(`.o_cw_popover .o_cw_popover_close`).click();
1576 expect(`.o_cw_popover`).toHaveCount(0);
1577 });
1578
1579 test.tags("desktop");
1580 test(`render popover with modifiers`, async () => {
1581 Event._fields.priority = fields.Selection({
1582 selection: [
1583 ["0", "Normal"],
1584 ["1", "Important"],
1585 ],
1586 });
1587
1588 await mountView({
1589 resModel: "event",
1590 type: "calendar",
1591 arch: `
1592 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week">
1593 <field name="priority" widget="priority" readonly="1"/>
1594 <field name="is_hatched" invisible="1"/>
1595 <field name="partner_id" invisible="not is_hatched"/>
1596 <field name="start" invisible="is_hatched"/>
1597 </calendar>
1598 `,
1599 });
1600
1601 await clickEvent(4);
1602 expect(`.o_cw_popover`).toHaveCount(1);
1603 expect(`.o_cw_popover .o_priority span.o_priority_star`).toHaveCount(1);
1604 expect(`.o_cw_popover li.o_invisible_modifier`).toHaveCount(0);
1605 expect(`.o_cw_popover .o_field_datetime`).toHaveCount(1);
1606
1607 await contains(`.o_cw_popover .o_cw_popover_close`).click();
1608 expect(`.o_cw_popover`).toHaveCount(0);
1609 });
1610
1611 test.tags("desktop");
1612 test(`render popover: inside fullcalendar popover`, async () => {
1613 // add 10 records the same day
1614 Event._records = Array.from({ length: 10 }).map((_, i) => ({
1615 id: i + 1,
1616 name: `event ${i + 1}`,
1617 start: "2016-12-14 10:00:00",
1618 stop: "2016-12-14 15:00:00",
1619 user_id: serverState.userId,
1620 }));
1621
1622 mockService("action", {
1623 doAction(request) {
1624 expect.step("doAction");
1625 expect(request).toEqual({
1626 type: "ir.actions.act_window",
1627 res_model: "event",
1628 res_id: 1,
1629 views: [[false, "form"]],
1630 target: "current",
1631 context: {},
1632 });
1633 return super.doAction(request);
1634 },
1635 });
1636
1637 await mountView({
1638 resModel: "event",
1639 type: "calendar",
1640 arch: `
1641 <calendar date_start="start" date_stop="stop" mode="month">
1642 <field name="name" string="Custom Name"/>
1643 <field name="partner_id"/>
1644 </calendar>
1645 `,
1646 });
1647
1648 expect(`:not(.fc-daygrid-event-harness-abs) > .fc-event`).toHaveCount(4);
1649 expect(`.fc-more-link`).toHaveCount(1);
1650 expect(`.fc-more-link`).toHaveText("+6 more");
1651 expect(`.fc-popover`).toHaveCount(0);
1652
1653 await contains(`.fc-more-link`).click();
1654 expect(`.fc-popover`).toHaveCount(1);
1655 expect(`.fc-popover :not(.fc-daygrid-event-harness-abs) > .fc-event`).toHaveCount(10);
1656 expect(`.o_cw_popover`).toHaveCount(0);
1657
1658 await contains(`.fc-popover .fc-daygrid-event-harness:nth-child(1) .fc-event`).click();
1659 await advanceTime(500);
1660 expect(`.o_cw_popover`).toHaveCount(1);
1661
1662 await contains(`.o_cw_popover .o_cw_popover_edit`).click();
1663 expect.verifySteps(["doAction"]);
1664 expect(`.o_cw_popover`).toHaveCount(0);
1665 expect(`.fc-popover`).toHaveCount(1);
1666 });
1667
1668 test(`attributes hide_date and hide_time`, async () => {
1669 await mountView({
1670 resModel: "event",
1671 type: "calendar",
1672 arch: `<calendar date_start="start" date_stop="stop" hide_date="1" hide_time="1" mode="month"/>`,
1673 });
1674 await clickEvent(4);
1675 expect(`.o_cw_popover .list-group-item`).toHaveCount(0);
1676 });
1677
1678 test(`create event with timezone in week mode with formViewDialog`, async () => {
1679 mockTimeZone(2);
1680
1681 Event._records = [];
1682 Event._onChanges.is_all_day = (record) => {
1683 if (record.is_all_day) {
1684 record.start_date = (record.start && record.start.split(" ")[0]) || record.start_date;
1685 record.stop_date =
1686 (record.stop && record.stop.split(" ")[0]) || record.stop_date || record.start_date;
1687 } else {
1688 record.start = (record.start_date && record.start_date + " 00:00:00") || record.start;
1689 record.stop =
1690 (record.stop_date && record.stop_date + " 00:00:00") || record.stop || record.start;
1691 }
1692 };
1693
1694 onRpc("write", ({ args }) => expect.step(["write", args[1]]));
1695 onRpc("web_save", ({ kwargs }) => {
1696 expect.step("web_save");
1697 expect(kwargs.context).toEqual({
1698 default_name: "new event",
1699 default_start: "2016-12-13 06:00:00",
1700 default_stop: "2016-12-13 08:00:00",
1701 default_is_all_day: false,
1702 lang: "en",
1703 tz: "taht",
1704 uid: serverState.userId,
1705 allowed_company_ids: [1],
1706 });
1707 });
1708
1709 await mountView({
1710 resModel: "event",
1711 type: "calendar",
1712 arch: `
1713 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1">
1714 <field name="name"/>
1715 </calendar>
1716 `,
1717 });
1718
1719 await selectTimeRange("2016-12-13 08:00:00", "2016-12-13 10:00:00");
1720 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
1721 await contains(`.o-calendar-quick-create--edit-btn`).click();
1722 expect(`.o_field_widget[name='start']`).toHaveText("Dec 13, 8:00 AM");
1723
1724 // Set is_all_day to true in formViewDialog
1725 await contains(`.modal .o_field_boolean[name='is_all_day'] input`).click();
1726 expect(`.o_field_widget[name='start_date']`).toHaveText("Dec 13");
1727
1728 await contains(`.modal .o_field_boolean[name='is_all_day'] input`).click();
1729 expect(`.o_field_widget[name='start']`).toHaveText("Dec 13, 2:00 AM");
1730
1731 // use datepicker to enter a date: 12/13/2016 08:00:00
1732 await contains(`.o_field_widget[name='start'] button`).click();
1733 await selectHourOnPicker("8");
1734
1735 // use datepicker to enter a date: 12/13/2016 10:00:00
1736 await contains(`.o_field_widget[name='stop'] button`).click();
1737 await selectHourOnPicker("10");
1738
1739 await contains(`.modal-footer .o_form_button_save`).click();
1740 expect.verifySteps(["web_save"]);
1741 expect(`.o_event[data-event-id="1"] .o_event_title`).toHaveText("new event");
1742
1743 // Move this event to another day
1744 await moveEventToTime(1, "2016-12-12 08:00:00");
1745 expect.verifySteps([
1746 ["write", { is_all_day: false, start: "2016-12-12 06:00:00", stop: "2016-12-12 08:00:00" }],
1747 ]);
1748
1749 // Move to "All day"
1750 await moveEventToAllDaySlot(1, "2016-12-12");
1751 expect.verifySteps([["write", { is_all_day: true, start: "2016-12-12", stop: "2016-12-12" }]]);
1752 });
1753
1754 test(`create event with timezone in week mode American locale`, async () => {
1755 mockTimeZone(2);
1756 Event._records = [];
1757
1758 onRpc("create", ({ kwargs }) => {
1759 expect.step("create");
1760 expect(kwargs.context).toEqual({
1761 default_name: "new event",
1762 default_start: "2016-12-13 04:00:00",
1763 default_stop: "2016-12-13 06:00:00",
1764 default_is_all_day: false,
1765 lang: "en",
1766 tz: "taht",
1767 uid: serverState.userId,
1768 allowed_company_ids: [1],
1769 });
1770 });
1771
1772 await mountView({
1773 resModel: "event",
1774 type: "calendar",
1775 arch: `
1776 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
1777 <field name="name"/>
1778 <field name="start"/>
1779 <field name="is_all_day"/>
1780 </calendar>
1781 `,
1782 });
1783
1784 await selectTimeRange("2016-12-13 06:00:00", "2016-12-13 08:00:00");
1785 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
1786 await contains(`.o-calendar-quick-create--create-btn`).click();
1787 expect(`.o_event[data-event-id="1"] .o_event_title`).toHaveText("new event");
1788 expect.verifySteps(["create"]);
1789
1790 // delete record
1791 await clickEvent(1);
1792 await contains(`.o_cw_popover_delete`).click();
1793 await contains(`.modal button.btn-primary`).click();
1794 expect(`.fc-event-main`).toHaveCount(0);
1795 });
1796
1797 test(`fetch event when being in timezone`, async () => {
1798 mockTimeZone(11);
1799 onRpc("event", "search_read", ({ kwargs }) => {
1800 expect.step("event.search_read");
1801 expect(kwargs.domain).toEqual([
1802 ["start", "<=", "2016-12-17 12:59:59"],
1803 ["stop", ">=", "2016-12-10 13:00:00"],
1804 ]);
1805 });
1806
1807 await mountView({
1808 resModel: "event",
1809 type: "calendar",
1810 arch: `
1811 <calendar date_start="start" date_stop="stop" mode="week">
1812 <field name="name"/>
1813 <field name="start"/>
1814 <field name="is_all_day"/>
1815 </calendar>
1816 `,
1817 });
1818 expect.verifySteps(["event.search_read"]);
1819 expect(`.fc-col-header-cell .o_cw_day_number:eq(0)`).toHaveText("11");
1820 expect(`.fc-col-header-cell .o_cw_day_number:eq(-1)`).toHaveText("17");
1821 });
1822
1823 test(`check calendar week column time format`, async () => {
1824 defineParams({ lang_parameters: { time_format: "hh:mm:ss" } });
1825
1826 await mountView({
1827 resModel: "event",
1828 type: "calendar",
1829 arch: `<calendar date_start="start"/>`,
1830 });
1831 expect(`.fc-timegrid-slot[data-time="08:00:00"]:eq(0)`).toHaveText("8am");
1832 expect(`.fc-timegrid-slot[data-time="23:00:00"]:eq(0)`).toHaveText("11pm");
1833 });
1834
1835 test(`create all day event in week mode`, async () => {
1836 mockTimeZone(2);
1837 Event._records = [];
1838
1839 onRpc("create", ({ args }) => {
1840 expect.step("create");
1841 expect(args[0]).toEqual([
1842 {
1843 name: "new event",
1844 start: "2016-12-14",
1845 stop: "2016-12-15",
1846 is_all_day: true,
1847 },
1848 ]);
1849 });
1850 await mountView({
1851 resModel: "event",
1852 type: "calendar",
1853 arch: `
1854 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1">
1855 <field name="name"/>
1856 </calendar>
1857 `,
1858 });
1859
1860 await selectAllDayRange("2016-12-14", "2016-12-15");
1861 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
1862 await contains(`.o-calendar-quick-create--create-btn`).click();
1863 expect(`.o_event[data-event-id="1"]`).toHaveText("new event");
1864 expect.verifySteps(["create"]);
1865 expectEventToBeOver(`.o_event[data-event-id="1"]`, [["2016-12-14", "2016-12-15"]]);
1866 });
1867
1868 test(`create all day event in month mode: utc-11`, async () => {
1869 mockTimeZone(-11);
1870 Event._records = [];
1871
1872 onRpc("create", ({ args }) => {
1873 expect.step("create");
1874 expect(args[0]).toEqual([
1875 {
1876 name: "new event",
1877 start: "2016-12-14",
1878 stop: "2016-12-14",
1879 is_all_day: true,
1880 },
1881 ]);
1882 });
1883 await mountView({
1884 resModel: "event",
1885 type: "calendar",
1886 arch: `
1887 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" event_open_popup="1">
1888 <field name="name"/>
1889 </calendar>
1890 `,
1891 });
1892
1893 await clickDate("2016-12-14");
1894 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
1895 await contains(`.o-calendar-quick-create--create-btn`).click();
1896 expect.verifySteps(["create"]);
1897 expect(`.o_event[data-event-id="1"]`).toHaveText("new event");
1898 const eventRect = queryRect(`.o_event[data-event-id="1"]`);
1899 const cellRect = queryRect(`[data-date="2016-12-14"]`);
1900 expect(eventRect.left).toBeGreaterThan(cellRect.left);
1901 expect(eventRect.right).toBeLessThan(cellRect.right);
1902 expect(eventRect.top).toBeGreaterThan(cellRect.top);
1903 expect(eventRect.bottom).toBeLessThan(cellRect.bottom);
1904 });
1905
1906 test.tags("desktop");
1907 test(`create all day event in year mode: utc-11`, async () => {
1908 mockTimeZone(-11);
1909 Event._records = [];
1910
1911 onRpc("create", ({ args }) => {
1912 expect.step("create");
1913 expect(args[0]).toEqual([
1914 {
1915 name: "new event",
1916 start: "2016-12-14",
1917 stop: "2016-12-14",
1918 is_all_day: true,
1919 },
1920 ]);
1921 });
1922 await mountView({
1923 resModel: "event",
1924 type: "calendar",
1925 arch: `
1926 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="year" event_open_popup="1">
1927 <field name="name"/>
1928 </calendar>
1929 `,
1930 });
1931 await clickDate("2016-12-14");
1932 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
1933 await contains(`.o-calendar-quick-create--create-btn`).click();
1934 expect.verifySteps(["create"]);
1935 expect(`.o_event[data-event-id="1"]`).toHaveRect(`[data-date="2016-12-14"]`);
1936 });
1937
1938 test(`create event with default context (no quickCreate)`, async () => {
1939 mockTimeZone(2);
1940 Event._records = [];
1941
1942 mockService("action", {
1943 doAction(request) {
1944 expect.step("doAction");
1945 expect(request.context).toEqual({
1946 default_name: "New",
1947 default_start: "2016-12-14",
1948 default_stop: "2016-12-15",
1949 default_is_all_day: true,
1950 lang: "en",
1951 tz: "taht",
1952 uid: serverState.userId,
1953 allowed_company_ids: [1],
1954 });
1955 },
1956 });
1957
1958 await mountView({
1959 resModel: "event",
1960 type: "calendar",
1961 arch: `<calendar date_start="start" date_stop="stop" mode="week" all_day="is_all_day" quick_create="0"/>`,
1962 context: {
1963 default_name: "New",
1964 },
1965 });
1966 await selectAllDayRange("2016-12-14", "2016-12-15");
1967 expect.verifySteps(["doAction"]);
1968 });
1969
1970 test(`create event with default title in context (with quickCreate)`, async () => {
1971 Event._records = [];
1972
1973 await mountView({
1974 resModel: "event",
1975 type: "calendar",
1976 arch: `<calendar date_start="start" date_stop="stop" mode="week" all_day="is_all_day"/>`,
1977 context: {
1978 default_name: "Example Title",
1979 },
1980 });
1981 await selectAllDayRange("2016-12-14", "2016-12-15");
1982 expect(`.o-calendar-quick-create--input`).toHaveValue("Example Title");
1983 });
1984
1985 test(`create all day event in week mode (no quickCreate)`, async () => {
1986 mockTimeZone(2);
1987 Event._records = [];
1988
1989 mockService("action", {
1990 doAction(request) {
1991 expect.step("doAction");
1992 expect(request.context).toEqual({
1993 default_start: "2016-12-14",
1994 default_stop: "2016-12-15",
1995 default_is_all_day: true,
1996 lang: "en",
1997 tz: "taht",
1998 uid: serverState.userId,
1999 allowed_company_ids: [1],
2000 });
2001 },
2002 });
2003
2004 await mountView({
2005 resModel: "event",
2006 type: "calendar",
2007 arch: `
2008 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" quick_create="0"/>
2009 `,
2010 });
2011 await selectAllDayRange("2016-12-14", "2016-12-15");
2012 expect.verifySteps(["doAction"]);
2013 });
2014
2015 test(`create event in month mode`, async () => {
2016 mockTimeZone(2);
2017 Event._records = [];
2018
2019 onRpc("create", ({ args }) => {
2020 expect.step("create");
2021 expect(args[0]).toEqual([
2022 {
2023 name: "new event",
2024 start: "2016-12-14 05:00:00",
2025 stop: "2016-12-15 17:00:00",
2026 },
2027 ]);
2028 });
2029 await mountView({
2030 resModel: "event",
2031 type: "calendar",
2032 arch: `
2033 <calendar date_start="start" date_stop="stop" mode="month" event_open_popup="1">
2034 <field name="name"/>
2035 </calendar>
2036 `,
2037 });
2038
2039 await selectDateRange("2016-12-14", "2016-12-15");
2040 await contains(`.o-calendar-quick-create--input`).edit("new event", { confirm: false });
2041 await contains(`.o-calendar-quick-create--create-btn`).click();
2042 expect(`.o_event[data-event-id="1"]`).toHaveText("new event");
2043 expect.verifySteps(["create"]);
2044 expectEventToBeOver(`.o_event[data-event-id="1"]`, [["2016-12-14", "2016-12-15"]]);
2045 });
2046
2047 test.tags("desktop");
2048 test(`use mini calendar`, async () => {
2049 mockTimeZone(2);
2050
2051 await mountView({
2052 resModel: "event",
2053 type: "calendar",
2054 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1"/>`,
2055 });
2056 expect(`.fc-timeGridWeek-view`).toHaveCount(1);
2057 expect(`.o_event`).toHaveCount(5);
2058
2059 // Clicking on a day in another week should switch to the other week view
2060 await pickDate("2016-12-19");
2061 expect(`.fc-timeGridWeek-view`).toHaveCount(1);
2062 expect(`.o_event`).toHaveCount(2);
2063
2064 // Clicking on a day in the same week should switch to that particular day view
2065 await pickDate("2016-12-18");
2066 expect(`.fc-timeGridDay-view`).toHaveCount(1);
2067 expect(`.o_event`).toHaveCount(2);
2068
2069 // Clicking on the same day should toggle between day, month and week views
2070 await pickDate("2016-12-18");
2071 expect(`.fc-dayGridMonth-view`).toHaveCount(1);
2072 expect(`.o_event`).toHaveCount(7);
2073
2074 await pickDate("2016-12-18");
2075 expect(`.fc-timeGridWeek-view`).toHaveCount(1);
2076 expect(`.o_event`).toHaveCount(2);
2077
2078 await pickDate("2016-12-18");
2079 expect(`.fc-timeGridDay-view`).toHaveCount(1);
2080 expect(`.o_event`).toHaveCount(2);
2081 });
2082
2083 test.tags("desktop");
2084 test(`rendering, with many2many on desktop`, async () => {
2085 Event._fields.attendee_ids = fields.Many2many({
2086 relation: "calendar.partner",
2087 default: [[6, 0, [1]]],
2088 });
2089 Event._records[0].attendee_ids = [1, 2, 3, 4, 5];
2090 CalendarPartner._records.push({ id: 5, name: "partner 5", image: "EEE" });
2091
2092 await mountView({
2093 resModel: "event",
2094 type: "calendar",
2095 arch: `
2096 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
2097 <field name="attendee_ids" widget="many2many_tags_avatar" avatar_field="image" write_model="filter.partner" write_field="partner_id"/>
2098 </calendar>
2099 `,
2100 });
2101 expect(`.o_calendar_filter_item .o_cw_filter_avatar`).toHaveCount(2);
2102
2103 await toggleSectionFilter("attendee_ids");
2104 await clickEvent(4);
2105 expect(`.o_cw_popover`).toHaveCount(1);
2106 expect(`.o_cw_popover img`).toHaveCount(1);
2107
2108 await clickEvent(1);
2109 expect(`.o_cw_popover`).toHaveCount(1);
2110 expect(`.o_cw_popover img`).toHaveCount(5);
2111 });
2112
2113 test.tags("mobile");
2114 test(`rendering, with many2many on mobile`, async () => {
2115 Event._fields.attendee_ids = fields.Many2many({
2116 relation: "calendar.partner",
2117 default: [[6, 0, [1]]],
2118 });
2119 Event._records[0].attendee_ids = [1, 2, 3, 4, 5];
2120 CalendarPartner._records.push({ id: 5, name: "partner 5", image: "EEE" });
2121
2122 await mountView({
2123 resModel: "event",
2124 type: "calendar",
2125 arch: `
2126 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
2127 <field name="attendee_ids" widget="many2many_tags_avatar" avatar_field="image" write_model="filter.partner" write_field="partner_id"/>
2128 </calendar>
2129 `,
2130 });
2131 await displayCalendarPanel();
2132 expect(`.o_calendar_filter_item .o_cw_filter_avatar`).toHaveCount(2);
2133 await hideCalendarPanel();
2134 await toggleSectionFilter("attendee_ids");
2135 await clickEvent(4);
2136 expect(".modal").toHaveCount(1);
2137 expect(`.modal img`).toHaveCount(1);
2138 await closeCwPopOver();
2139 await clickEvent(1);
2140 expect(".modal").toHaveCount(1);
2141 expect(`.modal img`).toHaveCount(5);
2142 });
2143
2144 test.tags("desktop");
2145 test(`set filter with many2many field on desktop`, async () => {
2146 Event._fields.attendee_ids = fields.Many2many({
2147 relation: "calendar.partner",
2148 default: [[6, 0, [1]]],
2149 });
2150 Event._records[0].attendee_ids = [1, 2, 3, 4, 5];
2151 CalendarPartner._records.push({ id: 5, name: "partner 5", image: "EEE" });
2152 await mountView({
2153 resModel: "event",
2154 type: "calendar",
2155 arch: `
2156 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
2157 <field name="attendee_ids" filters="1"/>
2158 </calendar>
2159 `,
2160 });
2161 expect(`.o_calendar_filter_item`).toHaveCount(5);
2162 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2163 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(1);
2164
2165 await toggleSectionFilter("attendee_ids");
2166 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(0);
2167 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2168
2169 await toggleFilter("attendee_ids", "1");
2170 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2171 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2172 });
2173
2174 test.tags("mobile");
2175 test(`set filter with many2many field on mobile`, async () => {
2176 Event._fields.attendee_ids = fields.Many2many({
2177 relation: "calendar.partner",
2178 default: [[6, 0, [1]]],
2179 });
2180 Event._records[0].attendee_ids = [1, 2, 3, 4, 5];
2181 CalendarPartner._records.push({ id: 5, name: "partner 5", image: "EEE" });
2182 await mountView({
2183 resModel: "event",
2184 type: "calendar",
2185 arch: `
2186 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
2187 <field name="attendee_ids" filters="1"/>
2188 </calendar>
2189 `,
2190 });
2191 await contains(`.o_filter`).click();
2192 expect(`.o_calendar_filter_item`).toHaveCount(5);
2193 await contains(`.o_filter`).click();
2194 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2195 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(1);
2196
2197 await toggleSectionFilter("attendee_ids");
2198 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(0);
2199 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2200
2201 await toggleFilter("attendee_ids", "1");
2202 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2203 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2204 });
2205
2206 test.tags("desktop");
2207 test("many2many filter handles archived records without crashing on desktop", async () => {
2208 CalendarPartner._fields.active = fields.Boolean({ default: true });
2209 CalendarPartner._records.push({
2210 id: 99,
2211 name: "Joni",
2212 active: false,
2213 });
2214 Event._records[0].attendee_ids = [99];
2215
2216 await mountView({
2217 resModel: "event",
2218 type: "calendar",
2219 arch: `
2220 <calendar date_start="start">
2221 <field name="attendee_ids" filters="1"/>
2222 </calendar>
2223 `,
2224 });
2225 expect(`.o_calendar_filter_item`).toHaveCount(4);
2226 });
2227
2228 test.tags("mobile");
2229 test("many2many filter handles archived records without crashing on mobile", async () => {
2230 CalendarPartner._fields.active = fields.Boolean({ default: true });
2231 CalendarPartner._records.push({
2232 id: 99,
2233 name: "Joni",
2234 active: false,
2235 });
2236 Event._records[0].attendee_ids = [99];
2237
2238 await mountView({
2239 resModel: "event",
2240 type: "calendar",
2241 arch: `
2242 <calendar date_start="start">
2243 <field name="attendee_ids" filters="1"/>
2244 </calendar>
2245 `,
2246 });
2247 await contains(`.o_filter`).click();
2248 expect(`.o_calendar_filter_item`).toHaveCount(4);
2249 });
2250
2251 test.tags("desktop");
2252 test(`set filter with one2many field on desktop`, async () => {
2253 Event._fields.attendee_ids = fields.One2many({
2254 relation: "calendar.partner",
2255 default: [[6, 0, [1]]],
2256 });
2257 Event._records[0].attendee_ids = [1, 2, 3, 4, 5];
2258 CalendarPartner._records.push({ id: 5, name: "partner 5", image: "EEE" });
2259 await mountView({
2260 resModel: "event",
2261 type: "calendar",
2262 arch: `
2263 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
2264 <field name="attendee_ids" filters="1"/>
2265 </calendar>
2266 `,
2267 });
2268 expect(`.o_calendar_filter_item`).toHaveCount(5);
2269 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2270 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(1);
2271
2272 await toggleSectionFilter("attendee_ids");
2273 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(0);
2274 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2275
2276 await toggleFilter("attendee_ids", "1");
2277 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2278 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2279 });
2280
2281 test.tags("mobile");
2282 test(`set filter with one2many field on mobile`, async () => {
2283 Event._fields.attendee_ids = fields.One2many({
2284 relation: "calendar.partner",
2285 default: [[6, 0, [1]]],
2286 });
2287 Event._records[0].attendee_ids = [1, 2, 3, 4, 5];
2288 CalendarPartner._records.push({ id: 5, name: "partner 5", image: "EEE" });
2289 await mountView({
2290 resModel: "event",
2291 type: "calendar",
2292 arch: `
2293 <calendar date_start="start" date_stop="stop" all_day="is_all_day" event_open_popup="1">
2294 <field name="attendee_ids" filters="1"/>
2295 </calendar>
2296 `,
2297 });
2298 await contains(`.o_filter`).click();
2299 expect(`.o_calendar_filter_item`).toHaveCount(5);
2300 await contains(`.o_filter`).click();
2301 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2302 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(1);
2303
2304 await toggleSectionFilter("attendee_ids");
2305 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(0);
2306 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2307
2308 await toggleFilter("attendee_ids", "1");
2309 expect(`.o_event[data-event-id="1"] .fc-event-main`).toHaveCount(1);
2310 expect(`.o_event[data-event-id="5"] .fc-event-main`).toHaveCount(0);
2311 });
2312
2313 test(`open form view`, async () => {
2314 let expectedRequest;
2315 mockService("action", {
2316 doAction(request) {
2317 expect.step("doAction");
2318 expect(request).toEqual(expectedRequest);
2319 return super.doAction(request);
2320 },
2321 });
2322
2323 onRpc("get_formview_id", () => expect.step("get_formview_id")); // should not be called
2324 await mountView({
2325 resModel: "event",
2326 type: "calendar",
2327 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
2328 });
2329
2330 expectedRequest = {
2331 type: "ir.actions.act_window",
2332 res_id: 4,
2333 res_model: "event",
2334 views: [[false, "form"]],
2335 target: "current",
2336 context: {},
2337 };
2338 await clickEvent(4);
2339 await contains(`.o_cw_popover_edit`).click();
2340 expect.verifySteps(["doAction"]);
2341
2342 await clickDate("2016-12-27");
2343 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
2344 expectedRequest = {
2345 type: "ir.actions.act_window",
2346 res_model: "event",
2347 views: [[false, "form"]],
2348 target: "current",
2349 context: {
2350 default_name: "coucou",
2351 default_start: "2016-12-27",
2352 default_stop: "2016-12-27",
2353 default_is_all_day: true,
2354 lang: "en",
2355 tz: "taht",
2356 uid: serverState.userId,
2357 allowed_company_ids: [1],
2358 },
2359 };
2360 await contains(`.o-calendar-quick-create--edit-btn`).click();
2361 expect.verifySteps(["doAction"]);
2362 });
2363
2364 test(`create and edit event in month mode (all_day: false)`, async () => {
2365 mockTimeZone(-4);
2366
2367 mockService("action", {
2368 doAction(request) {
2369 expect.step("doAction");
2370 expect(request).toEqual({
2371 type: "ir.actions.act_window",
2372 res_model: "event",
2373 views: [[false, "form"]],
2374 target: "current",
2375 context: {
2376 default_name: "coucou",
2377 default_start: "2016-12-27 11:00:00", // 7:00 + 4h
2378 default_stop: "2016-12-27 23:00:00", // 19:00 + 4h
2379 default_allday: true,
2380 lang: "en",
2381 tz: "taht",
2382 uid: serverState.userId,
2383 allowed_company_ids: [1],
2384 },
2385 });
2386 },
2387 });
2388
2389 await mountView({
2390 resModel: "event",
2391 type: "calendar",
2392 arch: `<calendar date_start="start" date_stop="stop" mode="month"/>`,
2393 });
2394
2395 await clickDate("2016-12-27");
2396 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
2397 await contains(`.o-calendar-quick-create--edit-btn`).click();
2398 expect.verifySteps(["doAction"]);
2399 });
2400
2401 test(`show start time of single day event`, async () => {
2402 mockTimeZone(-4);
2403
2404 await mountView({
2405 resModel: "event",
2406 type: "calendar",
2407 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
2408 });
2409 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveText("06:55");
2410 expect(`.o_event[data-event-id="4"] .fc-event-main .fc-time`).toHaveCount(0);
2411 expect(`.o_event[data-event-id="5"] .fc-event-main .fc-time`).toHaveCount(0);
2412
2413 await changeScale("week");
2414 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(1);
2415 });
2416
2417 test(`start time should not shown for date type field`, async () => {
2418 mockTimeZone(-4);
2419
2420 await mountView({
2421 resModel: "event",
2422 type: "calendar",
2423 arch: `<calendar date_start="start_date" date_stop="stop_date" mode="month"/>`,
2424 });
2425 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(0);
2426
2427 await changeScale("week");
2428 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(0);
2429
2430 await changeScale("day");
2431 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(0);
2432 });
2433
2434 test(`start time should not shown if hide_time is true`, async () => {
2435 mockTimeZone(-4);
2436
2437 await mountView({
2438 resModel: "event",
2439 type: "calendar",
2440 arch: `<calendar date_start="start" date_stop="stop" mode="month" hide_time="1"/>`,
2441 });
2442 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(0);
2443
2444 await changeScale("week");
2445 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(0);
2446
2447 await changeScale("day");
2448 expect(`.o_event[data-event-id="2"] .fc-event-main .fc-time`).toHaveCount(0);
2449 });
2450
2451 test(`readonly date_start field`, async () => {
2452 Event._fields.start = fields.Datetime({ readonly: true });
2453
2454 let expectedRequest;
2455 mockService("action", {
2456 doAction(request) {
2457 expect.step("doAction");
2458 expect(request).toEqual(expectedRequest);
2459 },
2460 });
2461
2462 await mountView({
2463 resModel: "event",
2464 type: "calendar",
2465 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
2466 });
2467 expect(`.fc-resizer`).toHaveCount(0);
2468
2469 expectedRequest = {
2470 type: "ir.actions.act_window",
2471 res_id: 4,
2472 res_model: "event",
2473 views: [[false, "form"]],
2474 target: "current",
2475 context: {},
2476 };
2477 await clickEvent(4);
2478 await contains(`.o_cw_popover_edit`).click();
2479 expect.verifySteps(["doAction"]);
2480
2481 // create a new event and edit it
2482 await clickDate("2016-12-27");
2483 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
2484 expectedRequest = {
2485 type: "ir.actions.act_window",
2486 res_model: "event",
2487 views: [[false, "form"]],
2488 target: "current",
2489 context: {
2490 allowed_company_ids: [1],
2491 default_name: "coucou",
2492 default_start: "2016-12-27",
2493 default_stop: "2016-12-27",
2494 default_is_all_day: true,
2495 lang: "en",
2496 tz: "taht",
2497 uid: serverState.userId,
2498 },
2499 };
2500 await contains(`.o-calendar-quick-create--edit-btn`).click();
2501 expect.verifySteps(["doAction"]);
2502 });
2503
2504 test(`readonly calendar view`, async () => {
2505 let expectedRequest;
2506 mockService("action", {
2507 doAction(request) {
2508 expect.step("doAction");
2509 expect(request).toEqual(expectedRequest);
2510 },
2511 });
2512
2513 await mountView({
2514 resModel: "event",
2515 type: "calendar",
2516 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" edit="0"/>`,
2517 });
2518 expect(`.fc-resizer`).toHaveCount(0);
2519
2520 expectedRequest = {
2521 type: "ir.actions.act_window",
2522 res_id: 4,
2523 res_model: "event",
2524 views: [[false, "form"]],
2525 target: "current",
2526 context: {},
2527 };
2528 await clickEvent(4);
2529 await contains(`.o_cw_popover_edit`).click();
2530 expect.verifySteps(["doAction"]);
2531
2532 // create a new event and edit it
2533 await clickDate("2016-12-27");
2534 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
2535 expectedRequest = {
2536 type: "ir.actions.act_window",
2537 res_model: "event",
2538 views: [[false, "form"]],
2539 target: "current",
2540 context: {
2541 allowed_company_ids: [1],
2542 default_name: "coucou",
2543 default_start: "2016-12-27",
2544 default_stop: "2016-12-27",
2545 default_is_all_day: true,
2546 lang: "en",
2547 tz: "taht",
2548 uid: serverState.userId,
2549 },
2550 };
2551 await contains(`.o-calendar-quick-create--edit-btn`).click();
2552 expect.verifySteps(["doAction"]);
2553 });
2554
2555 test.tags("desktop");
2556 test(`check filters with filter_field specified on desktop`, async () => {
2557 await mountView({
2558 resModel: "event",
2559 type: "calendar",
2560 arch: `
2561 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week">
2562 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked"/>
2563 </calendar>
2564 `,
2565 });
2566 expect(
2567 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="2"] input:checked`
2568 ).toHaveCount(1);
2569 expect(MockServer.env["filter.partner"].read([2])[0].is_checked).toBe(true);
2570
2571 await toggleFilter("attendee_ids", 2);
2572 expect(
2573 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="2"] input:checked`
2574 ).toHaveCount(0);
2575 expect(MockServer.env["filter.partner"].read([2])[0].is_checked).toBe(false);
2576
2577 await changeScale("week"); // trick to reload the entire view
2578 expect(
2579 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="2"] input:checked`
2580 ).toHaveCount(0);
2581 expect(MockServer.env["filter.partner"].read([2])[0].is_checked).toBe(false);
2582 });
2583
2584 test.tags("mobile");
2585 test(`check filters with filter_field specified on mobile`, async () => {
2586 await mountView({
2587 resModel: "event",
2588 type: "calendar",
2589 arch: `
2590 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week">
2591 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked"/>
2592 </calendar>
2593 `,
2594 });
2595 await displayCalendarPanel();
2596 expect(
2597 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="2"] input:checked`
2598 ).toHaveCount(1);
2599 expect(MockServer.env["filter.partner"].read([2])[0].is_checked).toBe(true);
2600 await hideCalendarPanel();
2601 await toggleFilter("attendee_ids", 2);
2602 await displayCalendarPanel();
2603 expect(
2604 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="2"] input:checked`
2605 ).toHaveCount(0);
2606 expect(MockServer.env["filter.partner"].read([2])[0].is_checked).toBe(false);
2607 await hideCalendarPanel();
2608 await changeScale("week"); // trick to reload the entire view
2609 await displayCalendarPanel();
2610 expect(
2611 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="2"] input:checked`
2612 ).toHaveCount(0);
2613 expect(MockServer.env["filter.partner"].read([2])[0].is_checked).toBe(false);
2614 });
2615
2616 test(`dynamic filters with selection fields`, async () => {
2617 Event._fields.selection = fields.Selection({
2618 string: "Ambiance",
2619 selection: [
2620 ["desert", "Desert"],
2621 ["forest", "Forest"],
2622 ],
2623 });
2624
2625 Event._records[0].selection = "forest";
2626 Event._records[1].selection = "desert";
2627
2628 await mountView({
2629 resModel: "event",
2630 type: "calendar",
2631 arch: `
2632 <calendar date_start="start" date_stop="stop">
2633 <field name="selection" filters="1"/>
2634 </calendar>
2635 `,
2636 });
2637 await displayCalendarPanel();
2638 expect(`.o_calendar_filter[data-name="selection"] .o_cw_filter_label`).toHaveText("Ambiance");
2639 expect(
2640 queryAllTexts(`.o_calendar_filter[data-name="selection"] .o_calendar_filter_item`)
2641 ).toEqual(["Desert", "Forest", "Undefined"]);
2642 });
2643
2644 test(`Colors: cycling through available colors`, async () => {
2645 FilterPartner._records = Array.from({ length: 56 }, (_, i) => ({
2646 id: i + 1,
2647 user_id: serverState.userId,
2648 partner_id: i + 1,
2649 is_checked: true,
2650 }));
2651 CalendarPartner._records = Array.from({ length: 56 }, (_, i) => ({
2652 id: i + 1,
2653 name: `partner ${i + 1}`,
2654 }));
2655 Event._records = Array.from({ length: 56 }, (_, i) => ({
2656 id: i + 1,
2657 user_id: serverState.userId,
2658 partner_id: i + 1,
2659 name: `event ${i + 1}`,
2660 start: `2016-12-12 0${i % 10}:00:00`,
2661 stop: `2016-12-12 0${i % 10}:00:00`,
2662 attendee_ids: [i + 1],
2663 }));
2664 await mountView({
2665 resModel: "event",
2666 type: "calendar",
2667 arch: `
2668 <calendar date_start="start" date_stop="stop" mode="day" color="attendee_ids">
2669 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked" />
2670 </calendar>
2671 `,
2672 });
2673 expect(`.o_event`).toHaveCount(56);
2674 expect(`.o_event[data-event-id="1"]`).toHaveClass("o_calendar_color_1");
2675 expect(`.o_event[data-event-id="55"]`).toHaveClass("o_calendar_color_55");
2676 expect(`.o_event[data-event-id="56"]`).toHaveClass("o_calendar_color_1");
2677 await displayCalendarPanel();
2678 expect(
2679 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="1"]`
2680 ).toHaveClass("o_cw_filter_color_1");
2681 expect(
2682 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="55"]`
2683 ).toHaveClass("o_cw_filter_color_55");
2684 expect(
2685 `.o_calendar_filter[data-name="attendee_ids"] .o_calendar_filter_item[data-value="56"]`
2686 ).toHaveClass("o_cw_filter_color_1");
2687 });
2688
2689 test.tags("desktop");
2690 test(`Colors: use available colors when attr is not number on desktop`, async () => {
2691 await mountView({
2692 resModel: "event",
2693 type: "calendar",
2694 arch: `
2695 <calendar date_start="start" date_stop="stop" color="name">
2696 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked" />
2697 </calendar>
2698 `,
2699 });
2700 const colorClass = Array.from(queryFirst`.o_event[data-event-id="1"]`.classList).find(
2701 (className) => className.startsWith("o_calendar_color_")
2702 );
2703 expect(isNaN(Number(colorClass.split("_").at(-1)))).toBe(false);
2704
2705 await clickEvent(1);
2706 expect(`.o_cw_popover`).toHaveClass(colorClass);
2707 });
2708
2709 test.tags("mobile");
2710 test(`Colors: use available colors when attr is not number on mobile`, async () => {
2711 await mountView({
2712 resModel: "event",
2713 type: "calendar",
2714 arch: `
2715 <calendar date_start="start" date_stop="stop" color="name">
2716 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked" />
2717 </calendar>
2718 `,
2719 });
2720 const colorClass = Array.from(queryFirst`.o_event[data-event-id="1"]`.classList).find(
2721 (className) => className.startsWith("o_calendar_color_")
2722 );
2723 expect(isNaN(Number(colorClass.split("_").at(-1)))).toBe(false);
2724 });
2725
2726 test(`Add filters and specific color`, async () => {
2727 EventType._records.push({
2728 id: 4,
2729 name: "Event Type no color",
2730 color: 0,
2731 });
2732 Event._records.push(
2733 {
2734 id: 8,
2735 user_id: 4,
2736 partner_id: 1,
2737 name: "event 8",
2738 start: "2016-12-11 09:00:00",
2739 stop: "2016-12-11 10:00:00",
2740 is_all_day: false,
2741 attendee_ids: [1, 2, 3],
2742 type_id: 3,
2743 },
2744 {
2745 id: 9,
2746 user_id: 4,
2747 partner_id: 1,
2748 name: "event 9",
2749 start: "2016-12-11 19:00:00",
2750 stop: "2016-12-11 20:00:00",
2751 is_all_day: false,
2752 attendee_ids: [1, 2, 3],
2753 type_id: 1,
2754 },
2755 {
2756 id: 10,
2757 user_id: 4,
2758 partner_id: 1,
2759 name: "event 10",
2760 start: "2016-12-11 12:00:00",
2761 stop: "2016-12-11 13:00:00",
2762 is_all_day: false,
2763 attendee_ids: [1, 2, 3],
2764 type_id: 4,
2765 }
2766 );
2767
2768 onRpc(({ model, method, kwargs }) => {
2769 let step = `${method} (${model})`;
2770 if (kwargs.fields) {
2771 step += ` [${kwargs.fields.join(", ")}]`;
2772 }
2773 expect.step(step);
2774 });
2775 await mountView({
2776 resModel: "event",
2777 type: "calendar",
2778 arch: `
2779 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" color="color" event_open_popup="1">
2780 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
2781 <field name="type_id" filters="1" color="color"/>
2782 </calendar>
2783 `,
2784 });
2785 expect.verifySteps([
2786 "get_views (event)",
2787 "search_read (filter.partner) [partner_id]",
2788 "search_read (event) [display_name, start, stop, is_all_day, color, attendee_ids, type_id]",
2789 ]);
2790
2791 // By default no filter is selected. We check before continuing.
2792 await toggleFilter("attendee_ids", 1);
2793 expect.verifySteps([
2794 "search_read (filter.partner) [partner_id]",
2795 "search_read (event) [display_name, start, stop, is_all_day, color, attendee_ids, type_id]",
2796 ]);
2797
2798 await toggleFilter("attendee_ids", 2);
2799 expect.verifySteps([
2800 "search_read (filter.partner) [partner_id]",
2801 "search_read (event) [display_name, start, stop, is_all_day, color, attendee_ids, type_id]",
2802 ]);
2803
2804 expect(`.o_event[data-event-id="8"]`).toHaveClass("o_calendar_color_4");
2805 expect(`.o_event[data-event-id="9"]`).toHaveClass("o_calendar_color_1");
2806 expect(`.o_event[data-event-id="10"]`).toHaveClass("o_calendar_color_0");
2807
2808 await displayCalendarPanel();
2809 expect(`.o_calendar_filter`).toHaveCount(2);
2810 expect(`.o_calendar_filter[data-name="type_id"] .o_cw_filter_label`).toHaveText("Event Type");
2811 expect(`.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item`).toHaveCount(4);
2812 expect(
2813 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="3"]`
2814 ).toHaveClass("o_cw_filter_color_4");
2815 });
2816
2817 test(`Colors: dynamic filters without any color attr`, async () => {
2818 await mountView({
2819 resModel: "event",
2820 type: "calendar",
2821 arch: `
2822 <calendar date_start="start" date_stop="stop">
2823 <field name="user_id" filters="1" invisible="1"/>
2824 </calendar>
2825 `,
2826 });
2827 expect(`.o_event[data-event-id="1"]`).toHaveClass("o_calendar_color_0");
2828 expect(`.o_event[data-event-id="2"]`).toHaveClass("o_calendar_color_0");
2829 expect(`.o_event[data-event-id="3"]`).toHaveClass("o_calendar_color_0");
2830 expect(`.o_event[data-event-id="4"]`).toHaveClass("o_calendar_color_0");
2831 await displayCalendarPanel();
2832 expect(`.o_calendar_filter[data-name="user_id"]`).toHaveCount(1);
2833 expect(`.o_calendar_filter[data-name="user_id"] [class*='o_cw_filter_color_']`).toHaveCount(0);
2834 });
2835
2836 test(`Colors: dynamic filters without color attr (related)`, async () => {
2837 Event._records = [
2838 {
2839 id: 8,
2840 user_id: 4,
2841 partner_id: 1,
2842 name: "event 8",
2843 start: "2016-12-11 09:00:00",
2844 stop: "2016-12-11 10:00:00",
2845 is_all_day: false,
2846 attendee_ids: [1, 2, 3],
2847 type_id: 3,
2848 },
2849 {
2850 id: 9,
2851 user_id: 4,
2852 partner_id: 1,
2853 name: "event 9",
2854 start: "2016-12-11 19:00:00",
2855 stop: "2016-12-11 20:00:00",
2856 is_all_day: false,
2857 attendee_ids: [1, 2, 3],
2858 type_id: 1,
2859 },
2860 {
2861 id: 10,
2862 user_id: 4,
2863 partner_id: 1,
2864 name: "event 10",
2865 start: "2016-12-11 12:00:00",
2866 stop: "2016-12-11 13:00:00",
2867 is_all_day: false,
2868 attendee_ids: [1, 2, 3],
2869 type_id: 2,
2870 },
2871 ];
2872
2873 onRpc("event.type", "search_read", () => {
2874 throw makeServerError({ message: "should not fetch event.type filter colors" });
2875 });
2876 await mountView({
2877 resModel: "event",
2878 type: "calendar",
2879 arch: `
2880 <calendar date_start="start" date_stop="stop" color="color">
2881 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
2882 <field name="type_id" filters="1"/>
2883 </calendar>
2884 `,
2885 });
2886 await toggleSectionFilter("attendee_ids");
2887 expect(`.o_event[data-event-id="8"]`).toHaveClass("o_calendar_color_4");
2888 expect(`.o_event[data-event-id="9"]`).toHaveClass("o_calendar_color_1");
2889 expect(`.o_event[data-event-id="10"]`).toHaveClass("o_calendar_color_2");
2890 await displayCalendarPanel();
2891 expect(
2892 `.o_calendar_filter[data-name="attendee_ids"] [class*='o_cw_filter_color_']`
2893 ).toHaveCount(0);
2894 expect(`.o_calendar_filter[data-name="type_id"] [class*='o_cw_filter_color_']`).toHaveCount(3);
2895 });
2896
2897 test(`Colors: dynamic filters without color attr (direct)`, async () => {
2898 onRpc("event.type", "search_read", () => {
2899 throw makeServerError({ message: "should not fetch event.type filter colors" });
2900 });
2901 await mountView({
2902 resModel: "event",
2903 type: "calendar",
2904 arch: `
2905 <calendar date_start="start" date_stop="stop" color="user_id">
2906 <field name="partner_id" avatar_field="image"/>
2907 <field name="user_id" filters="1" invisible="1"/>
2908 </calendar>
2909 `,
2910 });
2911 expect(`.o_event[data-event-id="1"]`).toHaveClass("o_calendar_color_7"); // uid = serverState.user_id
2912 expect(`.o_event[data-event-id="2"]`).toHaveClass("o_calendar_color_7"); // uid = serverState.user_id
2913 expect(`.o_event[data-event-id="3"]`).toHaveClass("o_calendar_color_4");
2914 expect(`.o_event[data-event-id="4"]`).toHaveClass("o_calendar_color_7"); // uid = serverState.user_id
2915 await displayCalendarPanel();
2916 expect(`.o_calendar_filter[data-name="partner_id"] [class*='o_cw_filter_color_']`).toHaveCount(
2917 0
2918 );
2919 expect(`.o_calendar_filter[data-name="user_id"] [class*='o_cw_filter_color_']`).toHaveCount(2);
2920 });
2921
2922 test(`makeFilterUser: color for current user`, async () => {
2923 class ResPartner extends models.Model {
2924 _name = "res.partner";
2925
2926 name = fields.Char();
2927 image = fields.Char();
2928
2929 _records = [
2930 { id: 1, name: "partner 1", image: "AAA" },
2931 { id: 2, name: "partner 2", image: "BBB" },
2932 { id: 3, name: "partner 3", image: "CCC" },
2933 { id: 4, name: "partner 4", image: "DDD" },
2934 ];
2935 }
2936 defineModels([ResPartner]);
2937
2938 Event._fields.partner_id = fields.Many2one({ relation: "res.partner", default: 1 });
2939 Event._fields.attendee_ids = fields.One2many({
2940 relation: "res.partner",
2941 default: [[6, 0, [1]]],
2942 });
2943
2944 await mountView({
2945 resModel: "event",
2946 type: "calendar",
2947 arch: `
2948 <calendar date_start="start" date_stop="stop" color="attendee_ids">
2949 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
2950 </calendar>
2951 `,
2952 });
2953
2954 await displayCalendarPanel();
2955 const section = `.o_calendar_filter[data-name="attendee_ids"]`;
2956 expect(`${section} [class*='o_cw_filter_color_']`).toHaveCount(3);
2957 expect(`${section} .o_cw_filter_label`).toHaveText("Attendees");
2958 expect(`${section} .o_calendar_filter_item`).toHaveCount(3);
2959 expect(`${section} .o_calendar_filter_item[data-value="17"]`).toHaveText("Mitchell Admin");
2960 expect(`${section} .o_calendar_filter_item[data-value="17"]`).toHaveClass(
2961 "o_cw_filter_color_17"
2962 );
2963 expect(`${section} .o_calendar_filter_item[data-value="2"]`).toHaveClass("o_cw_filter_color_2");
2964 expect(`${section} .o_calendar_filter_item[data-value="1"]`).toHaveClass("o_cw_filter_color_1");
2965 });
2966
2967 test(`Colors: dynamic filters with same color as events`, async () => {
2968 Event._records = [
2969 {
2970 id: 8,
2971 user_id: 4,
2972 partner_id: 1,
2973 name: "event 8",
2974 start: "2016-12-11 09:00:00",
2975 stop: "2016-12-11 10:00:00",
2976 is_all_day: false,
2977 attendee_ids: [1, 2, 3],
2978 type_id: 3,
2979 },
2980 {
2981 id: 9,
2982 user_id: 4,
2983 partner_id: 1,
2984 name: "event 9",
2985 start: "2016-12-11 19:00:00",
2986 stop: "2016-12-11 20:00:00",
2987 is_all_day: false,
2988 attendee_ids: [1, 2, 3],
2989 type_id: 1,
2990 },
2991 {
2992 id: 10,
2993 user_id: 4,
2994 partner_id: 1,
2995 name: "event 10",
2996 start: "2016-12-11 12:00:00",
2997 stop: "2016-12-11 13:00:00",
2998 is_all_day: false,
2999 attendee_ids: [1, 2, 3],
3000 type_id: 2,
3001 },
3002 ];
3003
3004 onRpc("event.type", "search_read", () => {
3005 throw makeServerError({ message: "should not fetch event.type filter colors" });
3006 });
3007 await mountView({
3008 resModel: "event",
3009 type: "calendar",
3010 arch: `
3011 <calendar date_start="start" date_stop="stop" color="color">
3012 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3013 <field name="type_id" filters="1" color="color"/>
3014 </calendar>
3015 `,
3016 });
3017 await toggleSectionFilter("attendee_ids");
3018 expect(`.o_event[data-event-id="8"]`).toHaveClass("o_calendar_color_4");
3019 expect(`.o_event[data-event-id="9"]`).toHaveClass("o_calendar_color_1");
3020 expect(`.o_event[data-event-id="10"]`).toHaveClass("o_calendar_color_2");
3021 await displayCalendarPanel();
3022 expect(`.o_calendar_filter[data-name="type_id"] [class*='o_cw_filter_color_']`).toHaveCount(3);
3023 expect(
3024 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="1"]`
3025 ).toHaveClass("o_cw_filter_color_1");
3026 expect(
3027 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="2"]`
3028 ).toHaveClass("o_cw_filter_color_2");
3029 expect(
3030 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="3"]`
3031 ).toHaveClass("o_cw_filter_color_4");
3032 });
3033
3034 test(`Colors: dynamic filters with another color source`, async () => {
3035 Event._records = [
3036 {
3037 id: 8,
3038 user_id: 4,
3039 name: "event 8",
3040 start: "2016-12-11 09:00:00",
3041 stop: "2016-12-11 10:00:00",
3042 is_all_day: false,
3043 attendee_ids: [1, 2, 3],
3044 type_id: 3,
3045 },
3046 {
3047 id: 9,
3048 user_id: 4,
3049 name: "event 9",
3050 start: "2016-12-11 19:00:00",
3051 stop: "2016-12-11 20:00:00",
3052 is_all_day: false,
3053 attendee_ids: [1, 2, 3],
3054 type_id: 1,
3055 },
3056 {
3057 id: 10,
3058 user_id: 4,
3059 name: "event 10",
3060 start: "2016-12-11 12:00:00",
3061 stop: "2016-12-11 13:00:00",
3062 is_all_day: false,
3063 attendee_ids: [1, 2, 3],
3064 type_id: 2,
3065 },
3066 ];
3067
3068 onRpc("event.type", "search_read", () => {
3069 expect.step("fetching event.type filter colors");
3070 });
3071 await mountView({
3072 resModel: "event",
3073 type: "calendar",
3074 arch: `
3075 <calendar date_start="start" date_stop="stop" color="partner_id">
3076 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3077 <field name="type_id" filters="1" color="color"/>
3078 </calendar>
3079 `,
3080 });
3081 expect.verifySteps([]);
3082
3083 await toggleSectionFilter("attendee_ids");
3084 expect.verifySteps(["fetching event.type filter colors"]);
3085 expect(`.o_event[data-event-id="8"]`).toHaveClass("o_calendar_color_4");
3086 expect(`.o_event[data-event-id="9"]`).toHaveClass("o_calendar_color_4");
3087 expect(`.o_event[data-event-id="10"]`).toHaveClass("o_calendar_color_4");
3088 await displayCalendarPanel();
3089 expect(
3090 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="1"]`
3091 ).toHaveClass("o_cw_filter_color_1");
3092 expect(
3093 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="2"]`
3094 ).toHaveClass("o_cw_filter_color_2");
3095 expect(
3096 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="3"]`
3097 ).toHaveClass("o_cw_filter_color_4");
3098 });
3099
3100 test(`Colors: dynamic filters with no color source`, async () => {
3101 Event._records = [
3102 {
3103 id: 8,
3104 user_id: 4,
3105 name: "event 8",
3106 start: "2016-12-11 09:00:00",
3107 stop: "2016-12-11 10:00:00",
3108 is_all_day: false,
3109 attendee_ids: [1, 2, 3],
3110 type_id: 3,
3111 },
3112 {
3113 id: 9,
3114 user_id: 4,
3115 name: "event 9",
3116 start: "2016-12-11 19:00:00",
3117 stop: "2016-12-11 20:00:00",
3118 is_all_day: false,
3119 attendee_ids: [1, 2, 3],
3120 type_id: 1,
3121 },
3122 {
3123 id: 10,
3124 user_id: 4,
3125 name: "event 10",
3126 start: "2016-12-11 12:00:00",
3127 stop: "2016-12-11 13:00:00",
3128 is_all_day: false,
3129 attendee_ids: [1, 2, 3],
3130 type_id: 2,
3131 },
3132 ];
3133
3134 onRpc("event.type", "search_read", () => {
3135 expect.step("fetching event.type filter colors");
3136 });
3137 await mountView({
3138 resModel: "event",
3139 type: "calendar",
3140 arch: `
3141 <calendar date_start="start" date_stop="stop">
3142 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3143 <field name="type_id" filters="1" color="color"/>
3144 </calendar>
3145 `,
3146 });
3147 expect.verifySteps([]);
3148
3149 await toggleSectionFilter("attendee_ids");
3150 expect.verifySteps(["fetching event.type filter colors"]);
3151 await displayCalendarPanel();
3152 expect(
3153 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="1"]`
3154 ).toHaveClass("o_cw_filter_color_1");
3155 expect(
3156 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="2"]`
3157 ).toHaveClass("o_cw_filter_color_2");
3158 expect(
3159 `.o_calendar_filter[data-name="type_id"] .o_calendar_filter_item[data-value="3"]`
3160 ).toHaveClass("o_cw_filter_color_4");
3161 });
3162
3163 test(`create event with filters`, async () => {
3164 Event._fields.user_id = fields.Many2one({ relation: "calendar.users", default: 5 });
3165 Event._fields.partner_id = fields.Many2one({ relation: "calendar.partner", default: 3 });
3166 CalendarUsers._records.push({ id: 5, name: "user 5", partner_id: 3 });
3167
3168 await mountView({
3169 resModel: "event",
3170 type: "calendar",
3171 arch: `
3172 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1" attendee="attendee_ids" color="partner_id">
3173 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3174 <field name="partner_id" filters="1" invisible="1"/>
3175 </calendar>
3176 `,
3177 });
3178
3179 // By default only
3180 await toggleFilter("attendee_ids", 1);
3181 await checkFilterItems(4);
3182 expect(`.o_event`).toHaveCount(4);
3183
3184 // quick create a record
3185 await selectTimeRange("2016-12-15 06:00:00", "2016-12-15 08:00:00");
3186 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
3187 await contains(`.o-calendar-quick-create--create-btn`).click();
3188 await checkFilterItems(5);
3189 expect(`.o_event`).toHaveCount(5);
3190
3191 // change default value for quick create an hide record
3192 Event._fields.user_id.default = 4;
3193 Event._fields.partner_id.default = 4;
3194
3195 // Disable our filter to create a record without displaying it
3196 await toggleFilter("partner_id", 4);
3197
3198 // quick create and other record
3199 await selectTimeRange("2016-12-13 06:00:00", "2016-12-13 08:00:00");
3200 await contains(`.o-calendar-quick-create--input`).edit("coucou 2", { confirm: false });
3201 await contains(`.o-calendar-quick-create--create-btn`).click();
3202 await checkFilterItems(5);
3203 expect(`.o_event`).toHaveCount(4);
3204
3205 await toggleFilter("partner_id", 4);
3206 await toggleFilter("attendee_ids", 2);
3207 expect(`.o_event`).toHaveCount(7);
3208 });
3209
3210 test(`create event with filters (no quickCreate)`, async () => {
3211 Event._views = {
3212 form: `
3213 <form>
3214 <group>
3215 <field name="name"/>
3216 <field name="start"/>
3217 <field name="stop"/>
3218 <field name="user_id"/>
3219 <field name="partner_id" invisible="1"/>
3220 </group>
3221 </form>
3222 `,
3223 };
3224 Event._fields.user_id = fields.Many2one({ relation: "calendar.users", default: 5 });
3225 Event._fields.partner_id = fields.Many2one({ relation: "calendar.partner", default: 3 });
3226 CalendarUsers._records.push({ id: 5, name: "user 5", partner_id: 3 });
3227
3228 await mountView({
3229 resModel: "event",
3230 type: "calendar",
3231 arch: `
3232 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1" attendee="attendee_ids" color="partner_id">
3233 <filter name="user_id" avatar_field="image"/>
3234 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3235 <field name="partner_id" filters="1" invisible="1"/>
3236 </calendar>
3237 `,
3238 });
3239
3240 // dislay all attendee calendars
3241 await toggleSectionFilter("attendee_ids");
3242 await toggleFilter("partner_id", 4);
3243 await checkFilterItems(4);
3244 expect(`.o_event`).toHaveCount(3);
3245
3246 // quick create a record
3247 await selectTimeRange("2016-12-15 06:00:00", "2016-12-15 08:00:00");
3248 await contains(`.o-calendar-quick-create--input`).edit("coucou", { confirm: false });
3249 await contains(`.o-calendar-quick-create--edit-btn`).click();
3250 await contains(`.modal-footer .o_form_button_save`).click();
3251 await checkFilterItems(5);
3252 expect(`.o_event`).toHaveCount(4);
3253 });
3254
3255 test(`Toggle multiple values at once in a filter with filter_field`, async () => {
3256 onRpc("write", ({ args }) => {
3257 expect.step(`write ${args[0]}`);
3258 });
3259 await mountView({
3260 resModel: "event",
3261 type: "calendar",
3262 arch: `
3263 <calendar date_start="start">
3264 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked"/>
3265 </calendar>
3266 `,
3267 });
3268
3269 await toggleSectionFilter("attendee_ids");
3270 expect.verifySteps(["write 1,2"]); // single write rpc, on both records
3271 });
3272
3273 test.tags("desktop");
3274 test(`Update event with filters on desktop`, async () => {
3275 CalendarUsers._records.push({ id: 5, name: "user 5", partner_id: 3 });
3276 Event._views = {
3277 form: `
3278 <form>
3279 <group>
3280 <field name="name"/>
3281 <field name="start"/>
3282 <field name="stop"/>
3283 <field name="user_id"/>
3284 <field name="attendee_ids" widget="many2many_tags"/>
3285 <field name="partner_id" invisible="1"/>
3286 </group>
3287 </form>
3288 `,
3289 };
3290
3291 await mountView({
3292 resModel: "event",
3293 type: "calendar",
3294 arch: `
3295 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1" attendee="attendee_ids" color="partner_id">
3296 <filter name="user_id" avatar_field="image"/>
3297 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3298 <field name="partner_id" filters="1" invisible="1"/>
3299 </calendar>
3300 `,
3301 });
3302
3303 // select needed partner filters
3304 await toggleFilter("attendee_ids", 1);
3305 await toggleFilter("partner_id", 4);
3306 expect(`.o_calendar_filter_item`).toHaveCount(4);
3307 expect(`.o_event`).toHaveCount(3);
3308
3309 await clickEvent(2);
3310 expect(`.o_cw_popover`).toHaveCount(1);
3311
3312 await contains(`.o_cw_popover_edit`).click();
3313 expect(`.modal .modal-title`).toHaveText("Open: event 2");
3314
3315 await contains(`.modal .o_field_widget[name="user_id"] input`).click();
3316 await contains(`.ui-autocomplete.dropdown-menu .ui-menu-item:contains(user 5)`).click();
3317 await contains(`.modal .o_form_button_save`).click();
3318
3319 expect(`.o_calendar_filter_item`).toHaveCount(5);
3320 expect(`.o_event`).toHaveCount(3);
3321
3322 // test the behavior of the 'select all' input checkbox
3323 expect(`.o_calendar_filter_item input:checked`).toHaveCount(3);
3324 expect(`.o_calendar_filter_item input:not(:checked)`).toHaveCount(2);
3325
3326 // Click to select all users
3327 await toggleSectionFilter("partner_id");
3328
3329 // should contains 4 events
3330 expect(`.o_event`).toHaveCount(4);
3331
3332 // Should have 4 checked boxes
3333 expect(`.o_calendar_filter_item input:checked`).toHaveCount(4);
3334
3335 // unselect all user
3336 await toggleSectionFilter("partner_id");
3337 expect(`.o_event`).toHaveCount(0);
3338 expect(`.o_calendar_filter_item input:checked`).toHaveCount(1);
3339 });
3340
3341 test.tags("mobile");
3342 test(`Update event with filters on mobile`, async () => {
3343 CalendarUsers._records.push({ id: 5, name: "user 5", partner_id: 3 });
3344 CalendarUsers._views = {
3345 kanban: `<kanban><templates><t t-name="card"><field name="name"/></t></templates></kanban>`,
3346 };
3347 Event._views = {
3348 form: `
3349 <form>
3350 <group>
3351 <field name="name"/>
3352 <field name="start"/>
3353 <field name="stop"/>
3354 <field name="user_id"/>
3355 <field name="attendee_ids" widget="many2many_tags"/>
3356 <field name="partner_id" invisible="1"/>
3357 </group>
3358 </form>
3359 `,
3360 };
3361
3362 await mountView({
3363 resModel: "event",
3364 type: "calendar",
3365 arch: `
3366 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1" attendee="attendee_ids" color="partner_id">
3367 <filter name="user_id" avatar_field="image"/>
3368 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3369 <field name="partner_id" filters="1" invisible="1"/>
3370 </calendar>
3371 `,
3372 });
3373 // select needed partner filters
3374 await toggleFilter("attendee_ids", 1);
3375 await toggleFilter("partner_id", 4);
3376 await checkFilterItems(4);
3377 expect(`.o_event`).toHaveCount(3);
3378
3379 await clickEvent(2);
3380 await contains(`.o_cw_popover_edit`).click();
3381 expect(`.modal .modal-title`).toHaveText("Open: event 2");
3382
3383 await contains(`.modal .o_field_widget[name="user_id"] input`).click();
3384 await animationFrame();
3385 await contains(`.o_kanban_record:contains(user 5)`).click();
3386 await contains(`.modal .o_form_button_save`).click();
3387
3388 await checkFilterItems(5);
3389 expect(`.o_event`).toHaveCount(3);
3390 await displayCalendarPanel();
3391
3392 // test the behavior of the 'select all' input checkbox
3393 expect(`.o_calendar_filter_item input:checked`).toHaveCount(3);
3394 expect(`.o_calendar_filter_item input:not(:checked)`).toHaveCount(2);
3395 await hideCalendarPanel();
3396
3397 // Click to select all users
3398 await toggleSectionFilter("partner_id");
3399
3400 // should contains 4 events
3401 expect(`.o_event`).toHaveCount(4);
3402 await displayCalendarPanel();
3403 // Should have 4 checked boxes
3404 expect(`.o_calendar_filter_item input:checked`).toHaveCount(4);
3405 await hideCalendarPanel();
3406 // unselect all user
3407 await toggleSectionFilter("partner_id");
3408 expect(`.o_event`).toHaveCount(0);
3409 await displayCalendarPanel();
3410 expect(`.o_calendar_filter_item input:checked`).toHaveCount(1);
3411 });
3412
3413 test.tags("desktop");
3414 test(`change pager with filters`, async () => {
3415 CalendarUsers._records.push({ id: 5, name: "user 5", partner_id: 3 });
3416 Event._records.push(
3417 {
3418 id: 8,
3419 user_id: 5,
3420 partner_id: 3,
3421 name: "event 8",
3422 start: "2016-12-06 04:00:00",
3423 stop: "2016-12-06 08:00:00",
3424 is_all_day: false,
3425 attendee_ids: [1, 2, 3],
3426 },
3427 {
3428 id: 9,
3429 user_id: serverState.userId,
3430 partner_id: 1,
3431 name: "event 9",
3432 start: "2016-12-07 04:00:00",
3433 stop: "2016-12-07 08:00:00",
3434 is_all_day: false,
3435 attendee_ids: [1, 2, 3],
3436 },
3437 {
3438 id: 10,
3439 user_id: 4,
3440 partner_id: 4,
3441 name: "event 10",
3442 start: "2016-12-08 04:00:00",
3443 stop: "2016-12-08 08:00:00",
3444 is_all_day: false,
3445 attendee_ids: [1, 2, 3],
3446 }
3447 );
3448
3449 await mountView({
3450 resModel: "event",
3451 type: "calendar",
3452 arch: `
3453 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="week" event_open_popup="1" attendee="attendee_ids" color="partner_id">
3454 <filter name="user_id" avatar_field="image"/>
3455 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3456 <field name="partner_id" filters="1" invisible="1"/>
3457 </calendar>
3458 `,
3459 });
3460
3461 // select filter for partner 1, 2 and 4
3462 await toggleSectionFilter("attendee_ids");
3463 await toggleFilter("partner_id", 4);
3464 await pickDate("2016-12-05");
3465 await changeScale("week");
3466 await checkFilterItems(5);
3467 expect(`.o_event`).toHaveCount(2);
3468 expect(queryAllTexts`.fc-event .o_event_title`).toEqual(["event 8", "event 9"]);
3469 });
3470
3471 test.tags("desktop");
3472 test(`events starting at midnight on desktop`, async () => {
3473 await mountView({
3474 resModel: "event",
3475 type: "calendar",
3476 arch: `<calendar date_start="start" mode="week"/>`,
3477 });
3478
3479 // Click on Tuesday 12am
3480 await selectTimeRange("2016-12-13 00:00:00", "2016-12-13 00:30:00");
3481 expect(`.o-calendar-quick-create`).toHaveCount(1);
3482
3483 // Creating the event
3484 await contains(`.o-calendar-quick-create--input`).edit("new event in quick create", {
3485 confirm: false,
3486 });
3487 await contains(`.o-calendar-quick-create--create-btn`).click();
3488 expect(`.o_event[data-event-id="8"]`).toHaveText("00:00\nnew event in quick create");
3489 });
3490
3491 test.tags("mobile");
3492 test(`events starting at midnight on mobile`, async () => {
3493 await mountView({
3494 resModel: "event",
3495 type: "calendar",
3496 arch: `<calendar date_start="start" mode="week"/>`,
3497 });
3498
3499 // Click on Tuesday 12am
3500 await selectTimeRange("2016-12-13 00:00:00", "2016-12-13 00:30:00");
3501 expect(`.o-calendar-quick-create`).toHaveCount(1);
3502
3503 // Creating the event
3504 await contains(`.o-calendar-quick-create--input`).edit("new event in quick create", {
3505 confirm: false,
3506 });
3507 await contains(`.o-calendar-quick-create--create-btn`).click();
3508 expect(`.o_event[data-event-id="8"]`).toHaveText("new event in quick create");
3509 });
3510
3511 test(`single day event from midnight to midnight`, async () => {
3512 mockDate("2016-12-12T08:00:00", 0);
3513 Event._records = [
3514 {
3515 id: 1,
3516 name: "event 1",
3517 start: "2016-12-12 00:00:00",
3518 stop: "2016-12-13 00:00:00",
3519 },
3520 ];
3521 await mountView({
3522 resModel: "event",
3523 type: "calendar",
3524 arch: `<calendar date_start="start" date_stop="stop" mode="year"/>`,
3525 });
3526
3527 expect(`.o_event`).toHaveCount(1);
3528 let eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3529 let cellWidth = queryFirst(`.fc-daygrid-day-frame`).getBoundingClientRect().width;
3530 expect(eventWidth).toBe(cellWidth); // over a single day
3531 await changeScale("month");
3532 expect(`.o_event`).toHaveCount(1);
3533 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3534 cellWidth = queryFirst(`.fc-daygrid-day-events`).getBoundingClientRect().width;
3535 expect(eventWidth).not.toBeGreaterThan(cellWidth);
3536 await changeScale("week");
3537 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3538 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3539 cellWidth = queryFirst(`.fc-day`).getBoundingClientRect().width;
3540 expect(eventWidth).not.toBeGreaterThan(cellWidth);
3541 await changeScale("day");
3542 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3543 await navigate("next");
3544 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(0);
3545 });
3546
3547 test(`event over two days but lasting less than 24h`, async () => {
3548 mockDate("2016-12-12T08:00:00", 0);
3549 Event._records = [
3550 {
3551 id: 1,
3552 name: "event 1",
3553 start: "2016-12-12 19:00:00",
3554 stop: "2016-12-13 09:00:00",
3555 },
3556 ];
3557 await mountView({
3558 resModel: "event",
3559 type: "calendar",
3560 arch: `<calendar date_start="start" date_stop="stop" mode="year"/>`,
3561 });
3562
3563 expect(`.o_event`).toHaveCount(1);
3564 let eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3565 let cellWidth = queryFirst(`.fc-daygrid-day-frame`).getBoundingClientRect().width;
3566 expect(eventWidth).toBe(2 * cellWidth); // over 2 days
3567 await changeScale("month");
3568 expect(`.o_event`).toHaveCount(1);
3569 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3570 cellWidth = queryFirst(`.fc-daygrid-day-events`).getBoundingClientRect().width;
3571 expect(eventWidth).toBeGreaterThan(cellWidth);
3572 expect(eventWidth).not.toBeGreaterThan(2 * cellWidth);
3573 await changeScale("week");
3574 expect(`.fc-day-mon .o_event`).toHaveCount(1);
3575 expect(`.fc-day-tue .o_event`).toHaveCount(1);
3576 await changeScale("day");
3577 expect(`.fc-day-mon .o_event`).toHaveCount(1);
3578 await navigate("next");
3579 expect(`.fc-day-tue .o_event`).toHaveCount(1);
3580 });
3581
3582 test(`event over two days lasting longer than 24h`, async () => {
3583 mockDate("2016-12-12T08:00:00", 0);
3584 Event._records = [
3585 {
3586 id: 1,
3587 name: "event 1",
3588 start: "2016-12-12 09:00:00",
3589 stop: "2016-12-13 19:00:00",
3590 },
3591 ];
3592 await mountView({
3593 resModel: "event",
3594 type: "calendar",
3595 arch: `<calendar date_start="start" date_stop="stop" mode="year"/>`,
3596 });
3597
3598 expect(`.o_event`).toHaveCount(1);
3599 let eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3600 let cellWidth = queryFirst(`.fc-daygrid-day-frame`).getBoundingClientRect().width;
3601 expect(eventWidth).toBe(2 * cellWidth); // over 2 days
3602 await changeScale("month");
3603 expect(`.o_event`).toHaveCount(1);
3604 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3605 cellWidth = queryFirst(`.fc-daygrid-day-events`).getBoundingClientRect().width;
3606 expect(eventWidth).toBeGreaterThan(cellWidth);
3607 expect(eventWidth).not.toBeGreaterThan(2 * cellWidth);
3608 await changeScale("week");
3609 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3610 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3611 cellWidth = queryFirst(`.fc-day`).getBoundingClientRect().width;
3612 expect(eventWidth).toBeGreaterThan(cellWidth);
3613 expect(eventWidth).not.toBeGreaterThan(2 * cellWidth);
3614 await changeScale("day");
3615 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3616 await navigate("next");
3617 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3618 });
3619
3620 test(`all day event lasting 2 days`, async () => {
3621 mockDate("2016-12-12T08:00:00", 0);
3622 Event._records = [
3623 {
3624 id: 1,
3625 name: "event 1",
3626 start: "2016-12-12 00:00:00",
3627 stop: "2016-12-13 00:00:00",
3628 is_all_day: true,
3629 },
3630 ];
3631 await mountView({
3632 resModel: "event",
3633 type: "calendar",
3634 arch: `<calendar date_start="start_date" date_stop="stop_date" all_day="is_all_day" mode="year"/>`,
3635 });
3636
3637 expect(`.o_event`).toHaveCount(1);
3638 let eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3639 let cellWidth = queryFirst(`.fc-daygrid-day-frame`).getBoundingClientRect().width;
3640 expect(eventWidth).toBe(2 * cellWidth); // over 2 days
3641 await changeScale("month");
3642 expect(`.o_event`).toHaveCount(1);
3643 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3644 cellWidth = queryFirst(`.fc-daygrid-day-events`).getBoundingClientRect().width;
3645 expect(eventWidth).toBeGreaterThan(cellWidth);
3646 expect(eventWidth).not.toBeGreaterThan(2 * cellWidth);
3647 await changeScale("week");
3648 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3649 eventWidth = queryOne(`.o_event`).getBoundingClientRect().width;
3650 cellWidth = queryFirst(`.fc-day`).getBoundingClientRect().width;
3651 expect(eventWidth).toBeGreaterThan(cellWidth);
3652 expect(eventWidth).not.toBeGreaterThan(2 * cellWidth);
3653 await changeScale("day");
3654 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3655 await navigate("next");
3656 expect(`.fc-daygrid-day-events .o_event`).toHaveCount(1);
3657 });
3658
3659 test(`set event as all day when field is date`, async () => {
3660 mockTimeZone(-8);
3661 Event._fields.start_date = fields.Date();
3662 Event._records[0].start_date = "2016-12-14";
3663
3664 await mountView({
3665 resModel: "event",
3666 type: "calendar",
3667 arch: `
3668 <calendar date_start="start_date" all_day="is_all_day" mode="week" event_open_popup="1" attendee="attendee_ids" color="partner_id">
3669 <filter name="user_id" avatar_field="image"/>
3670 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
3671 </calendar>
3672 `,
3673 });
3674
3675 await toggleFilter("attendee_ids", 1);
3676 expect(`.fc-daygrid-body .fc-event`).toHaveCount(1);
3677
3678 await clickEvent(1);
3679 expect(`.list-group-item:eq(0)`).toHaveText("December 14, 2016");
3680 });
3681
3682 test(`set event as all day when field is date (without all_day mapping)`, async () => {
3683 Event._fields.start_date = fields.Date();
3684 Event._records[0].start_date = "2016-12-14";
3685 await mountView({
3686 resModel: "event",
3687 type: "calendar",
3688 arch: `<calendar date_start="start_date" mode="week"/>`,
3689 });
3690 expect(`.fc-daygrid-body .fc-event`).toHaveCount(1);
3691 });
3692
3693 test(`set event as all day when field is datetime (without all_day mapping)`, async () => {
3694 await mountView({
3695 resModel: "event",
3696 type: "calendar",
3697 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
3698 });
3699 expect(`.fc-daygrid-body .fc-event`).toHaveCount(1, {
3700 message: "should be one event in the all day row",
3701 });
3702 });
3703
3704 test(`quickcreate avoid double event creation`, async () => {
3705 const deferred = new Deferred();
3706
3707 onRpc("create", async () => {
3708 expect.step("create");
3709 await deferred;
3710 });
3711 await mountView({
3712 resModel: "event",
3713 type: "calendar",
3714 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" event_open_popup="1"/>`,
3715 });
3716
3717 // create a new event
3718 await clickDate("2016-12-13");
3719 await contains(`.modal-body input`).edit("new event in quick create", { confirm: false });
3720
3721 // Simulate ENTER pressed on Create button (after a TAB)
3722 await press("Enter");
3723 await click(`.o-calendar-quick-create--create-btn`);
3724 await animationFrame();
3725
3726 deferred.resolve();
3727 await animationFrame();
3728 expect.verifySteps(["create"]);
3729 });
3730
3731 test(`calendar is configured to have no groupBy menu`, async () => {
3732 await mountView({
3733 resModel: "event",
3734 type: "calendar",
3735 arch: `<calendar date_start="start"/>`,
3736 });
3737 expect(`.o_control_panel .o_group_by_menu`).toHaveCount(0);
3738 });
3739
3740 test.tags("desktop");
3741 test(`timezone does not affect current day`, async () => {
3742 mockTimeZone(40);
3743
3744 await mountView({
3745 resModel: "event",
3746 type: "calendar",
3747 arch: `<calendar date_start="start"/>`,
3748 });
3749 expect(`.o_datetime_picker .o_selected`).toHaveText("14");
3750
3751 await pickDate("2016-12-11");
3752 expect(`.o_datetime_picker .o_selected`).toHaveText("11");
3753 });
3754
3755 test.tags("desktop");
3756 test(`timezone does not affect drag and drop on desktop`, async () => {
3757 mockTimeZone(-40);
3758
3759 onRpc("write", ({ args }) => {
3760 expect.step("write");
3761 expect(args[0]).toEqual([6]);
3762 expect(args[1].start).toBe("2016-11-29 08:00:00");
3763 });
3764 await mountView({
3765 resModel: "event",
3766 type: "calendar",
3767 arch: `
3768 <calendar date_start="start" mode="month">
3769 <field name="name"/>
3770 <field name="start"/>
3771 </calendar>
3772 `,
3773 });
3774
3775 await clickEvent(1);
3776 expect(`.o_event[data-event-id="1"]`).toHaveText("08:00\nevent 1");
3777 expect(`.o_field_widget[name="start"]`).toHaveText("Dec 9, 8:00 AM");
3778
3779 await clickEvent(6);
3780 expect(`.o_event[data-event-id="6"]`).toHaveText("16:00\nevent 6");
3781 expect(`.o_field_widget[name="start"]`).toHaveText("Dec 16, 4:00 PM");
3782
3783 await closeCwPopOver();
3784 await moveEventToDate(6, "2016-11-27");
3785 await clickEvent(6);
3786 expect(`.o_event[data-event-id="6"]`).toHaveText("16:00\nevent 6");
3787 expect(`.o_field_widget[name="start"]`).toHaveText("Nov 27, 4:00 PM");
3788 expect.verifySteps(["write"]);
3789
3790 await clickEvent(1);
3791 expect(`.o_event[data-event-id="1"]`).toHaveText("08:00\nevent 1");
3792 expect(`.o_field_widget[name="start"]`).toHaveText("Dec 9, 8:00 AM");
3793 });
3794
3795 test.tags("mobile");
3796 test(`timezone does not affect drag and drop on mobile`, async () => {
3797 mockTimeZone(-40);
3798 patchWithCleanup(CalendarRenderer.prototype, {
3799 get actionSwiperProps() {
3800 const props = super.actionSwiperProps;
3801 props.onLeftSwipe = undefined;
3802 props.onRightSwipe = undefined;
3803 return props;
3804 },
3805 });
3806 onRpc("write", ({ args }) => {
3807 expect.step("write");
3808 expect(args[0]).toEqual([6]);
3809 expect(args[1].start).toBe("2016-11-29 08:00:00");
3810 });
3811 await mountView({
3812 resModel: "event",
3813 type: "calendar",
3814 arch: `
3815 <calendar date_start="start" mode="month">
3816 <field name="name"/>
3817 <field name="start"/>
3818 </calendar>
3819 `,
3820 });
3821
3822 await clickEvent(1);
3823 expect(`.o_event[data-event-id="1"]`).toHaveText("event 1");
3824 expect(`.o_field_widget[name="start"]`).toHaveText("Dec 9, 8:00 AM");
3825 await closeCwPopOver();
3826
3827 await clickEvent(6);
3828 expect(`.o_event[data-event-id="6"]`).toHaveText("event 6");
3829 expect(`.o_field_widget[name="start"]`).toHaveText("Dec 16, 4:00 PM");
3830 await closeCwPopOver();
3831
3832 await moveEventToDate(6, "2016-11-27");
3833 await clickEvent(6);
3834 expect(`.o_event[data-event-id="6"]`).toHaveText("event 6");
3835 expect(`.o_field_widget[name="start"]`).toHaveText("Nov 27, 4:00 PM");
3836 await closeCwPopOver();
3837 expect.verifySteps(["write"]);
3838
3839 await clickEvent(1);
3840 expect(`.o_event[data-event-id="1"]`).toHaveText("event 1");
3841 expect(`.o_field_widget[name="start"]`).toHaveText("Dec 9, 8:00 AM");
3842 });
3843
3844 test.tags("desktop");
3845 test(`timezone does not affect calendar with date field on desktop`, async () => {
3846 Event._fields.start_date = fields.Date();
3847 mockTimeZone(2);
3848
3849 onRpc("create", ({ args }) => {
3850 expect.step(`create ${args[0][0].start_date}`);
3851 });
3852 onRpc("write", ({ args }) => {
3853 expect.step(`write ${args[1].start_date}`);
3854 });
3855 await mountView({
3856 resModel: "event",
3857 type: "calendar",
3858 arch: `
3859 <calendar date_start="start_date" mode="month">
3860 <field name="name"/>
3861 <field name="start_date"/>
3862 </calendar>
3863 `,
3864 });
3865
3866 await clickDate("2016-12-20");
3867 await contains(`.o-calendar-quick-create--input`).edit("An event", { confirm: false });
3868 await contains(`.o-calendar-quick-create--create-btn`).click();
3869 expect.verifySteps(["create 2016-12-20"]);
3870
3871 await clickEvent(8);
3872 expect(`.o_cw_popover`).toHaveCount(1);
3873 expect(
3874 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item .o_field_date`
3875 ).toHaveText("Dec 20");
3876
3877 await closeCwPopOver();
3878 await moveEventToDate(8, "2016-11-27");
3879 expect.verifySteps(["write 2016-11-27"]);
3880
3881 await clickEvent(8);
3882 expect(`.o_cw_popover`).toHaveCount(1);
3883 expect(
3884 `.o_cw_popover .o_cw_popover_fields_secondary .list-group-item .o_field_date`
3885 ).toHaveText("Nov 27");
3886 });
3887
3888 test.tags("mobile");
3889 test(`timezone does not affect calendar with date field on mobile`, async () => {
3890 Event._fields.start_date = fields.Date();
3891 mockTimeZone(2);
3892 patchWithCleanup(CalendarRenderer.prototype, {
3893 get actionSwiperProps() {
3894 const props = super.actionSwiperProps;
3895 props.onLeftSwipe = undefined;
3896 props.onRightSwipe = undefined;
3897 return props;
3898 },
3899 });
3900 onRpc("create", ({ args }) => {
3901 expect.step(`create ${args[0][0].start_date}`);
3902 });
3903 onRpc("write", ({ args }) => {
3904 expect.step(`write ${args[1].start_date}`);
3905 });
3906 await mountView({
3907 resModel: "event",
3908 type: "calendar",
3909 arch: `
3910 <calendar date_start="start_date" mode="month">
3911 <field name="name"/>
3912 <field name="start_date"/>
3913 </calendar>
3914 `,
3915 });
3916
3917 await clickDate("2016-12-20");
3918 await contains(`.o-calendar-quick-create--input`).edit("An event", { confirm: false });
3919 await contains(`.o-calendar-quick-create--create-btn`).click();
3920 expect.verifySteps(["create 2016-12-20"]);
3921
3922 await clickEvent(8);
3923 expect(`.modal`).toHaveCount(1);
3924 expect(`.modal .o_cw_popover_fields_secondary .list-group-item .o_field_date`).toHaveText(
3925 "Dec 20"
3926 );
3927
3928 await closeCwPopOver();
3929 await moveEventToDate(8, "2016-11-27");
3930 expect.verifySteps(["write 2016-11-27"]);
3931
3932 await clickEvent(8);
3933 expect(`.modal`).toHaveCount(1);
3934 expect(`.modal .o_cw_popover_fields_secondary .list-group-item .o_field_date`).toHaveText(
3935 "Nov 27"
3936 );
3937 });
3938
3939 test(`drag and drop on month mode`, async () => {
3940 await mountView({
3941 resModel: "event",
3942 type: "calendar",
3943 arch: `
3944 <calendar date_start="start" date_stop="stop" mode="month" event_open_popup="1" quick_create="0">
3945 <field name="name"/>
3946 <field name="partner_id"/>
3947 </calendar>
3948 `,
3949 });
3950
3951 await clickDate("2016-12-20");
3952 await contains(`.modal-body .o_field_widget[name=name] input`).edit("An event");
3953 await contains(`.modal .o_form_button_save`).click();
3954 await moveEventToDate(1, "2016-12-19", { disableDrop: true });
3955 expect(`.o_event[data-event-id="1"]`).toHaveClass("dayGridMonth");
3956
3957 await moveEventToDate(8, "2016-12-19");
3958 await clickEvent(8);
3959 expect(`.list-group-item:eq(1)`).toHaveText("07:00 - 19:00 (12 hours)");
3960 });
3961
3962 test(`drag and drop on month mode with all_day mapping`, async () => {
3963 // Same test as before but in calendarEventToRecord (calendar_model.js) there is
3964 // different condition branching with all_day mapping or not
3965
3966 await mountView({
3967 resModel: "event",
3968 type: "calendar",
3969 arch: `
3970 <calendar date_start="start" date_stop="stop" mode="month" event_open_popup="1" quick_create="0" all_day="is_all_day">
3971 <field name="name"/>
3972 <field name="partner_id"/>
3973 </calendar>
3974 `,
3975 });
3976
3977 await clickDate("2016-12-20");
3978 await contains(`.o_field_widget[name="name"] input`).edit("An event");
3979 await contains(`.o_field_widget[name="is_all_day"] input`).click();
3980
3981 // use datepicker to enter a date: 12/20/2016 07:00:00
3982 await contains(`.o_field_widget[name="start"] button`).click();
3983 await selectHourOnPicker("7:00");
3984
3985 // use datepicker to enter a date: 12/20/2016 19:00:00
3986 await contains(`.o_field_widget[name="stop"] button`).click();
3987 await selectHourOnPicker("19:00");
3988 await contains(`.modal .o_form_button_save`).click();
3989 await moveEventToDate(8, "2016-12-19");
3990 await clickEvent(8);
3991 expect(`.list-group-item:eq(1)`).toHaveText("07:00 - 19:00 (12 hours)");
3992 });
3993
3994 test(`drag and drop on month mode with date_start and date_delay`, async () => {
3995 onRpc("write", ({ args }) => {
3996 expect.step("write");
3997 expect(args[1].delay).toBe(undefined);
3998 });
3999 await mountView({
4000 resModel: "event",
4001 type: "calendar",
4002 arch: `
4003 <calendar date_start="start" date_delay="delay" mode="month">
4004 <field name="name"/>
4005 <field name="start"/>
4006 <field name="delay"/>
4007 </calendar>
4008 `,
4009 });
4010
4011 await clickDate("2016-12-20");
4012 await contains(`.o-calendar-quick-create--input`).edit("An event", { confirm: false });
4013 await contains(`.o-calendar-quick-create--create-btn`).click();
4014 await moveEventToDate(8, "2016-11-27");
4015 expect.verifySteps(["write"]);
4016 });
4017
4018 test(`form_view_id attribute works (for creating events)`, async () => {
4019 mockService("action", {
4020 doAction(request) {
4021 expect.step("doAction");
4022 expect(request.views[0][0]).toBe(42);
4023 },
4024 });
4025
4026 onRpc("create", () =>
4027 // we simulate here the case where a create call with just
4028 // the field name fails. This is a normal flow, the server
4029 // reject the create rpc (quick create), then the web client
4030 // fall back to a form view. This happens typically when a
4031 // model has required fields
4032 Promise.reject("None shall pass!")
4033 );
4034
4035 await mountView({
4036 resModel: "event",
4037 type: "calendar",
4038 arch: `<calendar date_start="start" date_stop="stop" mode="month" form_view_id="42"/>`,
4039 });
4040 await clickDate("2016-12-13");
4041 await contains(`.modal-body input`).edit("It's just a fleshwound", { confirm: "blur" });
4042 await contains(`.o-calendar-quick-create--create-btn`).click();
4043 expect.verifySteps(["doAction"]);
4044 });
4045
4046 test(`form_view_id attribute works with popup (for creating events)`, async () => {
4047 mockService("action", {
4048 doAction(request) {
4049 expect.step("doAction");
4050 expect(request.views[0][0]).toBe(1);
4051 },
4052 });
4053
4054 await mountView({
4055 resModel: "event",
4056 type: "calendar",
4057 arch: `
4058 <calendar date_start="start" date_stop="stop" mode="month" open_event_popup="1" quick_create="0" form_view_id="1">
4059 <field name="name"/>
4060 </calendar>
4061 `,
4062 });
4063 await clickDate("2016-12-13");
4064 expect.verifySteps(["doAction"]);
4065 });
4066
4067 test(`calendar fallback to form view id in action if necessary`, async () => {
4068 Event._views["form,43"] = /* xml */ `<form />`;
4069
4070 mockService("action", {
4071 doAction(request) {
4072 expect.step("doAction");
4073 expect(request).toEqual({
4074 type: "ir.actions.act_window",
4075 res_model: "event",
4076 views: [[43, "form"]], // should use the view id from the config
4077 target: "current",
4078 context: {
4079 lang: "en",
4080 uid: serverState.userId,
4081 tz: "taht",
4082 default_name: "It's just a fleshwound",
4083 default_start: "2016-12-13 06:00:00",
4084 default_stop: "2016-12-13 18:00:00",
4085 default_allday: true,
4086 allowed_company_ids: [1],
4087 },
4088 });
4089 },
4090 });
4091
4092 onRpc("create", () =>
4093 // we simulate here the case where a create call with just
4094 // the field name fails. This is a normal flow, the server
4095 // reject the create rpc (quick create), then the web client
4096 // fall back to a form view. This happens typically when a
4097 // model has required fields
4098 Promise.reject("None shall pass!")
4099 );
4100 await mountView({
4101 resModel: "event",
4102 type: "calendar",
4103 arch: `<calendar date_start="start" date_stop="stop" mode="month"/>`,
4104 config: { views: [[43, "form"]] },
4105 });
4106
4107 await clickDate("2016-12-13");
4108 await contains(`.modal-body input`).edit("It's just a fleshwound", { confirm: "blur" });
4109 await contains(`.o-calendar-quick-create--create-btn`).click();
4110 expect.verifySteps(["doAction"]);
4111 });
4112
4113 test(`fullcalendar initializes with right locale`, async () => {
4114 // The machine that runs this test must have this locale available
4115 serverState.lang = "fr";
4116
4117 await mountView({
4118 resModel: "event",
4119 type: "calendar",
4120 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
4121 });
4122 expect(queryAllTexts`.fc-col-header-cell`).toEqual([
4123 "DIM.\n11",
4124 "LUN.\n12",
4125 "MAR.\n13",
4126 "MER.\n14",
4127 "JEU.\n15",
4128 "VEN.\n16",
4129 "SAM.\n17",
4130 ]);
4131 });
4132
4133 test(`initial_date given in the context`, async () => {
4134 Event._views = {
4135 "calendar,1": `<calendar date_start="start" date_stop="stop" mode="day"/>`,
4136 };
4137
4138 defineActions([
4139 {
4140 id: 1,
4141 name: "context initial date",
4142 res_model: "event",
4143 views: [[1, "calendar"]],
4144 context: { initial_date: "2016-01-30 08:00:00" }, // 30th of january
4145 },
4146 ]);
4147
4148 await mountWithCleanup(WebClient);
4149 await getService("action").doAction(1);
4150 expect(`.o_breadcrumb`).toHaveText("context initial date");
4151 expect(`.o_calendar_renderer .fc-col-header-cell .o_cw_day_name`).toHaveText("Saturday");
4152 expect(`.o_calendar_renderer .fc-col-header-cell .o_cw_day_number`).toHaveText("30");
4153 });
4154
4155 test.tags("desktop");
4156 test(`default week start (US) month mode on desktop`, async () => {
4157 // if not given any option, default week start is on Sunday
4158 mockDate("2019-09-12 08:00:00", -7);
4159
4160 onRpc("event", "search_read", ({ kwargs }) => {
4161 expect.step("event.search_read");
4162 expect(kwargs.domain).toEqual([
4163 ["start", "<=", "2019-10-13 06:59:59"],
4164 ["stop", ">=", "2019-09-01 07:00:00"],
4165 ]);
4166 });
4167 await mountView({
4168 resModel: "event",
4169 type: "calendar",
4170 arch: `<calendar date_start="start" date_stop="stop" mode="month"/>`,
4171 });
4172 expect.verifySteps(["event.search_read"]);
4173 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("SUN");
4174 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SAT");
4175 expect(`.fc-daygrid-day:eq(0) .fc-daygrid-week-number`).toHaveText("36");
4176 expect(`.fc-daygrid-day:eq(0) .fc-daygrid-day-number`).toHaveText("1");
4177 expect(`.fc-daygrid-day:eq(0)`).toHaveAttribute("data-date", "2019-09-01");
4178 expect(`.fc-daygrid-day:eq(-1) .fc-daygrid-day-number`).toHaveText("5");
4179 expect(`.fc-daygrid-day:eq(-1)`).toHaveAttribute("data-date", "2019-10-05");
4180 });
4181
4182 test.tags("mobile");
4183 test(`default week start (US) month mode on mobile`, async () => {
4184 // if not given any option, default week start is on Sunday
4185 mockDate("2019-09-12 08:00:00", -7);
4186
4187 onRpc("event", "search_read", ({ kwargs }) => {
4188 expect.step("event.search_read");
4189 expect(kwargs.domain).toEqual([
4190 ["start", "<=", "2019-10-13 06:59:59"],
4191 ["stop", ">=", "2019-09-01 07:00:00"],
4192 ]);
4193 });
4194 await mountView({
4195 resModel: "event",
4196 type: "calendar",
4197 arch: `<calendar date_start="start" date_stop="stop" mode="month"/>`,
4198 });
4199 expect.verifySteps(["event.search_read"]);
4200 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("SUN");
4201 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SAT");
4202 expect(`.o-fc-week:eq(0)`).toHaveText("36");
4203 expect(`.fc-daygrid-day:eq(0) .fc-daygrid-day-number`).toHaveText("1");
4204 expect(`.fc-daygrid-day:eq(0)`).toHaveAttribute("data-date", "2019-09-01");
4205 expect(`.fc-daygrid-day:eq(-1) .fc-daygrid-day-number`).toHaveText("5");
4206 expect(`.fc-daygrid-day:eq(-1)`).toHaveAttribute("data-date", "2019-10-05");
4207 });
4208
4209 test.tags("desktop");
4210 test(`European week start month mode on chat`, async () => {
4211 mockDate("2019-09-15 08:00:00");
4212 // the week start depends on the locale
4213 defineParams({ lang_parameters: { week_start: 1 } });
4214
4215 onRpc("event", "search_read", ({ kwargs }) => {
4216 expect.step("event.search_read");
4217 expect(kwargs.domain).toEqual([
4218 ["start", "<=", "2019-10-06 22:59:59"],
4219 ["stop", ">=", "2019-08-25 23:00:00"],
4220 ]);
4221 });
4222 await mountView({
4223 resModel: "event",
4224 type: "calendar",
4225 arch: `<calendar date_start="start" date_stop="stop" mode="month"/>`,
4226 });
4227 expect.verifySteps(["event.search_read"]);
4228 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("MON");
4229 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SUN");
4230 expect(`.fc-daygrid-day:eq(0) .fc-daygrid-week-number`).toHaveText("35");
4231 expect(`.fc-daygrid-day:eq(0) .fc-daygrid-day-number`).toHaveText("26");
4232 expect(`.fc-daygrid-day:eq(0)`).toHaveAttribute("data-date", "2019-08-26");
4233 expect(`.fc-daygrid-day:eq(-1) .fc-daygrid-day-number`).toHaveText("6");
4234 expect(`.fc-daygrid-day:eq(-1)`).toHaveAttribute("data-date", "2019-10-06");
4235 });
4236
4237 test.tags("mobile");
4238 test(`European week start month mode on mobile`, async () => {
4239 mockDate("2019-09-15 08:00:00");
4240 // the week start depends on the locale
4241 defineParams({ lang_parameters: { week_start: 1 } });
4242
4243 onRpc("event", "search_read", ({ kwargs }) => {
4244 expect.step("event.search_read");
4245 expect(kwargs.domain).toEqual([
4246 ["start", "<=", "2019-10-06 22:59:59"],
4247 ["stop", ">=", "2019-08-25 23:00:00"],
4248 ]);
4249 });
4250 await mountView({
4251 resModel: "event",
4252 type: "calendar",
4253 arch: `<calendar date_start="start" date_stop="stop" mode="month"/>`,
4254 });
4255 expect.verifySteps(["event.search_read"]);
4256 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("MON");
4257 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SUN");
4258 expect(`.o-fc-week:eq(0)`).toHaveText("35");
4259 expect(`.fc-daygrid-day:eq(0) .fc-daygrid-day-number`).toHaveText("26");
4260 expect(`.fc-daygrid-day:eq(0)`).toHaveAttribute("data-date", "2019-08-26");
4261 expect(`.fc-daygrid-day:eq(-1) .fc-daygrid-day-number`).toHaveText("6");
4262 expect(`.fc-daygrid-day:eq(-1)`).toHaveAttribute("data-date", "2019-10-06");
4263 });
4264
4265 test.tags("desktop");
4266 test(`Monday week start week mode on desktop`, async () => {
4267 mockDate("2019-09-15 08:00:00");
4268 // the week start depends on the locale
4269 defineParams({ lang_parameters: { week_start: 1 } });
4270
4271 onRpc("event", "search_read", ({ kwargs }) => {
4272 expect.step("event.search_read");
4273 expect(kwargs.domain).toEqual([
4274 ["start", "<=", "2019-09-15 22:59:59"],
4275 ["stop", ">=", "2019-09-08 23:00:00"],
4276 ]);
4277 });
4278 await mountView({
4279 resModel: "event",
4280 type: "calendar",
4281 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
4282 });
4283 expect.verifySteps(["event.search_read"]);
4284 expect(`.fc-timeGridWeek-view .fc-daygrid-body`).toHaveCount(1);
4285 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("MON");
4286 expect(`.fc-col-header-cell .o_cw_day_number:eq(0)`).toHaveText("9");
4287 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SUN");
4288 expect(`.fc-col-header-cell .o_cw_day_number:eq(-1)`).toHaveText("15");
4289 expect(`.fc-timegrid-axis-cushion:eq(0)`).toHaveText("Week 37");
4290 });
4291
4292 test.tags("mobile");
4293 test(`Monday week start week mode on mobile`, async () => {
4294 mockDate("2019-09-15 08:00:00");
4295 // the week start depends on the locale
4296 defineParams({ lang_parameters: { week_start: 1 } });
4297
4298 onRpc("event", "search_read", ({ kwargs }) => {
4299 expect.step("event.search_read");
4300 expect(kwargs.domain).toEqual([
4301 ["start", "<=", "2019-09-15 22:59:59"],
4302 ["stop", ">=", "2019-09-08 23:00:00"],
4303 ]);
4304 });
4305 await mountView({
4306 resModel: "event",
4307 type: "calendar",
4308 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
4309 });
4310 expect.verifySteps(["event.search_read"]);
4311 expect(`.fc-timeGridWeek-view .fc-daygrid-body`).toHaveCount(1);
4312 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("MON");
4313 expect(`.fc-col-header-cell .o_cw_day_number:eq(0)`).toHaveText("9");
4314 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("SUN");
4315 expect(`.fc-col-header-cell .o_cw_day_number:eq(-1)`).toHaveText("15");
4316 expect(`.fc-timegrid-axis-cushion:eq(0)`).toHaveText("37");
4317 expect(`.o_calendar_header .badge`).toHaveText("Week 37");
4318 });
4319
4320 test.tags("desktop");
4321 test(`Saturday week start week mode on desktop`, async () => {
4322 mockDate("2019-09-12 08:00:00");
4323 // the week start depends on the locale
4324 defineParams({ lang_parameters: { week_start: 6 } });
4325
4326 onRpc("event", "search_read", ({ kwargs }) => {
4327 expect.step("event.search_read");
4328 expect(kwargs.domain).toEqual([
4329 ["start", "<=", "2019-09-13 22:59:59"],
4330 ["stop", ">=", "2019-09-06 23:00:00"],
4331 ]);
4332 });
4333 await mountView({
4334 resModel: "event",
4335 type: "calendar",
4336 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
4337 });
4338 expect.verifySteps(["event.search_read"]);
4339 expect(`.fc-timeGridWeek-view .fc-daygrid-body`).toHaveCount(1);
4340 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("SAT");
4341 expect(`.fc-col-header-cell .o_cw_day_number:eq(0)`).toHaveText("7");
4342 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("FRI");
4343 expect(`.fc-col-header-cell .o_cw_day_number:eq(-1)`).toHaveText("13");
4344 expect(`.fc-timegrid-axis-cushion:eq(0)`).toHaveText("Week 37");
4345 });
4346
4347 test.tags("mobile");
4348 test(`Saturday week start week mode on mobile`, async () => {
4349 mockDate("2019-09-12 08:00:00");
4350 // the week start depends on the locale
4351 defineParams({ lang_parameters: { week_start: 6 } });
4352
4353 onRpc("event", "search_read", ({ kwargs }) => {
4354 expect.step("event.search_read");
4355 expect(kwargs.domain).toEqual([
4356 ["start", "<=", "2019-09-13 22:59:59"],
4357 ["stop", ">=", "2019-09-06 23:00:00"],
4358 ]);
4359 });
4360 await mountView({
4361 resModel: "event",
4362 type: "calendar",
4363 arch: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
4364 });
4365 expect.verifySteps(["event.search_read"]);
4366 expect(`.fc-timeGridWeek-view .fc-daygrid-body`).toHaveCount(1);
4367 expect(`.fc-col-header-cell .o_cw_day_name:eq(0)`).toHaveText("SAT");
4368 expect(`.fc-col-header-cell .o_cw_day_number:eq(0)`).toHaveText("7");
4369 expect(`.fc-col-header-cell .o_cw_day_name:eq(-1)`).toHaveText("FRI");
4370 expect(`.fc-col-header-cell .o_cw_day_number:eq(-1)`).toHaveText("13");
4371 expect(`.fc-timegrid-axis-cushion:eq(0)`).toHaveText("37");
4372 expect(`.o_calendar_header .badge`).toHaveText("Week 37");
4373 });
4374
4375 test(`Monday week start year mode`, async () => {
4376 mockDate("2019-09-15 08:00:00");
4377 // the week start depends on the locale
4378 defineParams({ lang_parameters: { week_start: 1 } });
4379
4380 patchWithCleanup(CalendarYearRenderer.prototype, {
4381 get options() {
4382 return { ...super.options, weekNumbers: true };
4383 },
4384 });
4385
4386 onRpc("event", "search_read", ({ kwargs }) => {
4387 expect.step("event.search_read");
4388 expect(kwargs.domain).toEqual([
4389 ["start", "<=", "2019-12-31 22:59:59"],
4390 ["stop", ">=", "2018-12-31 23:00:00"],
4391 ]);
4392 });
4393 await mountView({
4394 resModel: "event",
4395 type: "calendar",
4396 arch: `<calendar date_start="start" date_stop="stop" mode="year"/>`,
4397 });
4398 expect.verifySteps(["event.search_read"]);
4399
4400 const weekRow = queryFirst(`.fc-day-today`).closest("tr");
4401 expect(queryFirst(`.fc-daygrid-day-top`, { root: weekRow })).toHaveText("9", {
4402 message: "The first day of the week should be Monday the 9th",
4403 });
4404 expect(queryOne(`.fc-daygrid-day-top:last`, { root: weekRow })).toHaveText("15", {
4405 message: "The last day of the week should be Sunday the 15th",
4406 });
4407 expect(queryFirst(`.fc-daygrid-week-number`, { root: weekRow })).toHaveText("37");
4408 });
4409
4410 test(`Sunday week start year mode`, async () => {
4411 mockDate("2019-09-15 08:00:00");
4412 // the week start depends on the locale
4413 // the localization presents a python-like 1 to 7 weekStart value
4414 defineParams({ lang_parameters: { week_start: 7 } });
4415
4416 patchWithCleanup(CalendarYearRenderer.prototype, {
4417 get options() {
4418 return { ...super.options, weekNumbers: true };
4419 },
4420 });
4421
4422 onRpc("event", "search_read", ({ kwargs }) => {
4423 expect.step("event.search_read");
4424 expect(kwargs.domain).toEqual([
4425 ["start", "<=", "2019-12-31 22:59:59"],
4426 ["stop", ">=", "2018-12-31 23:00:00"],
4427 ]);
4428 });
4429 await mountView({
4430 resModel: "event",
4431 type: "calendar",
4432 arch: `<calendar date_start="start" date_stop="stop" mode="year"/>`,
4433 });
4434 expect.verifySteps(["event.search_read"]);
4435
4436 const weekRow = queryFirst(`.fc-day-today`).closest("tr");
4437 expect(queryFirst(`.fc-daygrid-day-top`, { root: weekRow })).toHaveText("15", {
4438 message: "The first day of the week should be Sunday the 15th",
4439 });
4440 expect(queryOne(`.fc-daygrid-day-top:last`, { root: weekRow })).toHaveText("21", {
4441 message: "The last day of the week should be Saturday the 21st",
4442 });
4443 expect(queryFirst(`.fc-daygrid-week-number`, { root: weekRow })).toHaveText("38");
4444 });
4445
4446 test(`edit record and attempt to create a record with "create" attribute set to false`, async () => {
4447 onRpc("web_save", ({ args }) => {
4448 expect.step("save");
4449 expect(args[1]).toEqual({ name: "event 4 modified" });
4450 });
4451
4452 await mountView({
4453 resModel: "event",
4454 type: "calendar",
4455 arch: `<calendar event_open_popup="1" create="0" date_start="start" date_stop="stop" mode="month"/>`,
4456 });
4457
4458 // editing existing events should still be possible
4459 // click on an existing event to open the formViewDialog
4460 await clickEvent(4);
4461 const popover = getMockEnv().isSmall ? ".modal" : ".o_cw_popover";
4462 const closeButton = getMockEnv().isSmall ? ".oi-arrow-left" : ".o_cw_popover_close";
4463 expect(popover).toHaveCount(1);
4464 expect(`${popover} .o_cw_popover_edit`).toHaveCount(1);
4465 expect(`${popover} .o_cw_popover_delete`).toHaveCount(1);
4466 expect(`${popover} ${closeButton}`).toHaveCount(1);
4467
4468 await contains(`${popover} .o_cw_popover_edit`).click();
4469 expect(`.modal-body`).toHaveCount(1);
4470
4471 await contains(`.modal-body input`).edit("event 4 modified");
4472 await contains(`.modal-footer .o_form_button_save`).click();
4473 expect(`.modal`).toHaveCount(0);
4474 expect.verifySteps(["save"]);
4475
4476 // creating an event should not be possible
4477 // attempt to create a new event with create set to false
4478 await clickDate("2016-12-13");
4479 expect(`.modal`).toHaveCount(0, {
4480 message:
4481 "shouldn't open a quick create dialog for creating a new event with create attribute set to false",
4482 });
4483 });
4484
4485 test(`attempt to create record with "create" and "quick_add" attributes set to false`, async () => {
4486 await mountView({
4487 resModel: "event",
4488 type: "calendar",
4489 arch: `<calendar create="0" event_open_popup="1" quick_create="0" date_start="start" date_stop="stop" mode="month"/>`,
4490 });
4491 await clickDate("2016-12-13");
4492 expect(`.modal`).toHaveCount(0, {
4493 message:
4494 "shouldn't open a form view for creating a new event with create attribute set to false",
4495 });
4496 });
4497
4498 test(`attempt to create multiples events and the same day and check the ordering on month view`, async () => {
4499 // This test aims to verify that the order of the event in month view is coherent with their start date.
4500 mockDate("2020-03-12 08:00:00");
4501
4502 Event._records = [
4503 {
4504 id: 1,
4505 name: "Second event",
4506 start: "2020-03-12 05:00:00",
4507 stop: "2020-03-12 07:00:00",
4508 is_all_day: false,
4509 },
4510 {
4511 id: 2,
4512 name: "First event",
4513 start: "2020-03-12 02:00:00",
4514 stop: "2020-03-12 03:00:00",
4515 is_all_day: false,
4516 },
4517 {
4518 id: 3,
4519 name: "Third event",
4520 start: "2020-03-12 08:00:00",
4521 stop: "2020-03-12 09:00:00",
4522 is_all_day: false,
4523 },
4524 ];
4525
4526 await mountView({
4527 resModel: "event",
4528 type: "calendar",
4529 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
4530 });
4531 expect(`.o_calendar_renderer .fc-view`).toHaveCount(1);
4532 expect(queryAllTexts`.o_event_title`).toEqual(["First event", "Second event", "Third event"]);
4533 });
4534
4535 test.tags("desktop");
4536 test(`Resizing Pill of Multiple Days(Allday)`, async () => {
4537 onRpc("web_save", ({ args }) => {
4538 expect.step("web_save");
4539 expect(args[1]).toEqual({
4540 is_all_day: true,
4541 name: "foobar",
4542 start: "2016-12-13 00:00:00",
4543 start_date: false,
4544 stop: "2016-12-14 00:00:00",
4545 stop_date: false,
4546 });
4547 });
4548
4549 onRpc("write", ({ args }) => {
4550 expect.step("write");
4551 expect(args[1]).toEqual({
4552 is_all_day: true,
4553 start: "2016-12-13",
4554 stop: "2016-12-16",
4555 });
4556 });
4557
4558 await mountView({
4559 resModel: "event",
4560 type: "calendar",
4561 arch: `<calendar event_open_popup="1" quick_create="0" date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
4562 });
4563
4564 await selectDateRange("2016-12-13", "2016-12-14");
4565 await contains(`.modal .o_field_widget[name="name"] input`).edit("foobar", { confirm: false });
4566 await contains(`.modal .o_form_button_save`).click();
4567 expect.verifySteps(["web_save"]);
4568
4569 await resizeEventToDate(8, "2016-12-16");
4570 const event = queryFirst`.o_event[data-event-id="8"]`;
4571 expect(event).toHaveText("foobar");
4572 expect(event.closest(".fc-daygrid-day")).not.toBeEmpty();
4573 expect.verifySteps(["write"]);
4574 });
4575
4576 test.tags("desktop");
4577 test(`create event and resize to next day (24h) on week mode`, async () => {
4578 onRpc("web_save", ({ args }) => {
4579 expect.step("web_save");
4580 expect(args[1]).toEqual({
4581 is_all_day: false,
4582 name: "foobar",
4583 start: "2016-12-13 07:00:00",
4584 start_date: false,
4585 stop: "2016-12-13 15:00:00",
4586 stop_date: false,
4587 });
4588 });
4589 onRpc("write", ({ args }) => {
4590 expect.step("write");
4591 expect(args[1]).toEqual({
4592 is_all_day: false,
4593 start: "2016-12-13 07:00:00",
4594 stop: "2016-12-14 07:00:00",
4595 });
4596 });
4597
4598 await mountView({
4599 resModel: "event",
4600 type: "calendar",
4601 arch: `<calendar event_open_popup="1" quick_create="0" date_start="start" date_stop="stop" all_day="is_all_day" mode="week"/>`,
4602 });
4603
4604 await selectTimeRange("2016-12-13 08:00:00", "2016-12-13 16:00:00");
4605 await contains(`.modal .o_field_widget[name="name"] input`).edit("foobar", { confirm: false });
4606 await contains(`.modal .o_form_button_save`).click();
4607 expect.verifySteps(["web_save"]);
4608
4609 await resizeEventToTime(8, "2016-12-14 08:00:00");
4610 const event = queryFirst`.o_event[data-event-id="8"]`;
4611 expect(event).toHaveText("foobar");
4612 expect(event.closest(".fc-daygrid-day")).not.toBeEmpty();
4613 expect.verifySteps(["write"]);
4614 });
4615
4616 test.tags("desktop");
4617 test(`correctly display year view`, async () => {
4618 await mountView({
4619 resModel: "event",
4620 type: "calendar",
4621 arch: `
4622 <calendar create="0" event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="year" attendee="attendee_ids" color="partner_id">
4623 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
4624 <field name="partner_id" filters="1" invisible="1"/>
4625 <field name="is_hatched" invisible="1"/>
4626 <field name="is_striked" invisible="1"/>
4627 </calendar>
4628 `,
4629 });
4630
4631 await toggleFilter("attendee_ids", 1);
4632 await toggleFilter("attendee_ids", 2);
4633
4634 expect(`.fc-month`).toHaveCount(12);
4635 expect(queryAllTexts`.fc-month .fc-header-toolbar`).toEqual([
4636 "January 2016",
4637 "February 2016",
4638 "March 2016",
4639 "April 2016",
4640 "May 2016",
4641 "June 2016",
4642 "July 2016",
4643 "August 2016",
4644 "September 2016",
4645 "October 2016",
4646 "November 2016",
4647 "December 2016",
4648 ]);
4649 expect(`.fc-bg-event`).toHaveCount(7); // There should be 6 events displayed but there is 1 split on 2 weeks
4650 expect(`.o_event_hatched`).toHaveCount(3);
4651 expect(`.o_event_striked`).toHaveCount(1);
4652
4653 await clickDate("2016-11-17");
4654 expect(`.o_popover`).toHaveCount(0);
4655
4656 await clickDate("2016-11-16");
4657 expect(`.o_popover`).toHaveCount(1);
4658 expect(`.o_popover`).toHaveText("November 14-16, 2016\nevent 7");
4659
4660 await closeCwPopOver();
4661 expect(`.o_popover`).toHaveCount(0);
4662
4663 await clickDate("2016-11-14");
4664 expect(`.o_popover`).toHaveCount(1);
4665 expect(`.o_popover`).toHaveText("November 14-16, 2016\nevent 7");
4666
4667 await closeCwPopOver();
4668 expect(`.o_popover`).toHaveCount(0);
4669
4670 await clickDate("2016-11-13");
4671 expect(`.o_popover`).toHaveCount(0);
4672
4673 await clickDate("2016-12-10");
4674 expect(`.o_popover`).toHaveCount(0);
4675
4676 await clickDate("2016-12-12");
4677 expect(`.o_popover`).toHaveCount(1);
4678 expect(`.o_popover`).toHaveText("December 12, 2016\n11:55\nevent 2\n16:55\nevent 3");
4679
4680 await closeCwPopOver();
4681 expect(`.o_popover`).toHaveCount(0);
4682
4683 await clickDate("2016-12-14");
4684 expect(`.o_popover`).toHaveCount(1);
4685 expect(`.o_popover`).toHaveText("December 14, 2016\nevent 4\nDecember 13-20, 2016\nevent 5");
4686
4687 await closeCwPopOver();
4688 expect(`.o_popover`).toHaveCount(0);
4689
4690 await clickDate("2016-12-21");
4691 expect(`.o_popover`).toHaveCount(0);
4692 });
4693
4694 test(`toggle filters in year view`, async () => {
4695 await mountView({
4696 resModel: "event",
4697 type: "calendar",
4698 arch: `
4699 <calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="year" attendee="attendee_ids" color="partner_id">
4700 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id"/>
4701 <field name="partner_id" filters="1" invisible="1"/>
4702 </calendar>
4703 `,
4704 });
4705
4706 // activate partner filter
4707 await toggleFilter("attendee_ids", 1);
4708 await toggleFilter("attendee_ids", 2);
4709 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(1);
4710 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(1);
4711 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(1);
4712 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(1);
4713 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(2);
4714 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4715 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(1);
4716
4717 await toggleFilter("attendee_ids", 2);
4718 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(1);
4719 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(1);
4720 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(1);
4721 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(1);
4722 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(0);
4723 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4724 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(0);
4725
4726 await toggleFilter("partner_id", 1);
4727 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(0);
4728 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(0);
4729 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(1);
4730 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(0);
4731 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(0);
4732 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4733 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(0);
4734
4735 await toggleFilter("partner_id", 4);
4736 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(0);
4737 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(0);
4738 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(0);
4739 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(0);
4740 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(0);
4741 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4742 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(0);
4743
4744 await toggleFilter("attendee_ids", 1);
4745 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(0);
4746 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(0);
4747 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(0);
4748 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(0);
4749 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(0);
4750 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4751 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(0);
4752
4753 await toggleFilter("attendee_ids", 2);
4754 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(1);
4755 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(1);
4756 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(0);
4757 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(0);
4758 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(2);
4759 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4760 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(1);
4761
4762 await toggleFilter("partner_id", 4);
4763 expect(`.fc-bg-event[data-event-id="1"]`).toHaveCount(1);
4764 expect(`.fc-bg-event[data-event-id="2"]`).toHaveCount(1);
4765 expect(`.fc-bg-event[data-event-id="3"]`).toHaveCount(0);
4766 expect(`.fc-bg-event[data-event-id="4"]`).toHaveCount(0);
4767 expect(`.fc-bg-event[data-event-id="5"]`).toHaveCount(0);
4768 expect(`.fc-bg-event[data-event-id="6"]`).toHaveCount(0);
4769 expect(`.fc-bg-event[data-event-id="7"]`).toHaveCount(1);
4770 });
4771
4772 test(`allowed scales`, async () => {
4773 await mountView({
4774 resModel: "event",
4775 type: "calendar",
4776 arch: `<calendar date_start="start" date_stop="stop" all_day="is_all_day" scales="day,week"/>`,
4777 });
4778
4779 await contains(`.o_view_scale_selector .scale_button_selection`).click();
4780 expect(`.o-dropdown--menu .o_scale_button_day`).toHaveCount(1);
4781 expect(`.o-dropdown--menu .o_scale_button_week`).toHaveCount(1);
4782 expect(`.o-dropdown--menu .o_scale_button_month`).toHaveCount(0);
4783 expect(`.o-dropdown--menu .o_scale_button_year`).toHaveCount(0);
4784 });
4785
4786 test.tags("desktop");
4787 test(`click outside the popup should close it`, async () => {
4788 await mountView({
4789 resModel: "event",
4790 type: "calendar",
4791 arch: `<calendar create="0" event_open_popup="1" quick_create="0" date_start="start" date_stop="stop" all_day="is_all_day" mode="month"/>`,
4792 });
4793 expect(`.o_cw_popover`).toHaveCount(0);
4794
4795 await clickEvent(1);
4796 expect(`.o_cw_popover`).toHaveCount(1);
4797
4798 await contains(`.o_cw_popover .o_cw_body`).click();
4799 expect(`.o_cw_popover`).toHaveCount(1);
4800
4801 await contains(`.o_calendar_view`).click();
4802 expect(`.o_cw_popover`).toHaveCount(0);
4803 });
4804
4805 test(`fields are added in the right order in popover`, async () => {
4806 const deferred = new Deferred();
4807 class DeferredWidget extends Component {
4808 static template = xml``;
4809 static props = ["*"];
4810 setup() {
4811 onWillStart(() => deferred);
4812 }
4813 }
4814 registry.category("fields").add("deferred_widget", { component: DeferredWidget });
4815
4816 await mountView({
4817 resModel: "event",
4818 type: "calendar",
4819 arch: `
4820 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month">
4821 <field name="user_id" widget="deferred_widget"/>
4822 <field name="name"/>
4823 </calendar>
4824 `,
4825 });
4826
4827 await clickEvent(4);
4828 const popover = getMockEnv().isSmall ? ".modal" : ".o_cw_popover";
4829 expect(popover).toHaveCount(0);
4830
4831 deferred.resolve();
4832 await animationFrame();
4833 expect(popover).toHaveCount(1);
4834 expect(`${popover} .o_cw_popover_fields_secondary`).toHaveText("User\nName\nevent 4");
4835 });
4836
4837 test(`select events and discard create`, async () => {
4838 await mountView({
4839 resModel: "event",
4840 type: "calendar",
4841 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="year"/>`,
4842 });
4843 expect(`.fc-dayGridMonth-view`).toHaveCount(12);
4844
4845 await selectDateRange("2016-11-13", "2016-11-19");
4846 expect(`.o-calendar-quick-create`).toHaveCount(1);
4847 expectEventToBeOver(`.fc-highlight`, [["2016-11-13", "2016-11-19"]]);
4848
4849 await contains(`.o-calendar-quick-create--cancel-btn`).click();
4850 expect(`.fc-highlight`).toHaveCount(0);
4851 });
4852
4853 test.tags("desktop");
4854 test(`create event in year view`, async () => {
4855 onRpc("create", ({ args }) => {
4856 expect.step(args[0][0]);
4857 });
4858
4859 await mountView({
4860 resModel: "event",
4861 type: "calendar",
4862 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="year"/>`,
4863 });
4864
4865 // Select the whole month of July
4866 await selectDateRange("2016-07-01", "2016-07-31");
4867 await contains(`.o-calendar-quick-create--input[name=title]`).edit("Whole July", {
4868 confirm: false,
4869 });
4870 await contains(`.o-calendar-quick-create--create-btn`).click();
4871 expect.verifySteps([
4872 { name: "Whole July", is_all_day: true, start: "2016-07-01", stop: "2016-07-31" },
4873 ]);
4874
4875 // get all rows for event 8
4876 expect(`.o_event[data-event-id='8']`).toHaveCount(6);
4877 expectEventToBeOver(`.o_event[data-event-id='8']`, [
4878 ["2016-07-01", "2016-07-02"],
4879 ["2016-07-03", "2016-07-09"],
4880 ["2016-07-10", "2016-07-16"],
4881 ["2016-07-17", "2016-07-23"],
4882 ["2016-07-24", "2016-07-30"],
4883 ["2016-07-31", "2016-07-31"],
4884 ]);
4885
4886 // Select the whole month of November
4887 await selectDateRange("2016-11-01", "2016-11-30");
4888 await contains(`.o-calendar-quick-create--input[name=title]`).edit("Whole November", {
4889 confirm: false,
4890 });
4891 await contains(`.o-calendar-quick-create--create-btn`).click();
4892 expect.verifySteps([
4893 { name: "Whole November", is_all_day: true, start: "2016-11-01", stop: "2016-11-30" },
4894 ]);
4895
4896 // get all rows for event 9
4897 expect(`.o_event[data-event-id='9']`).toHaveCount(5);
4898 expectEventToBeOver(`.o_event[data-event-id='9']`, [
4899 ["2016-11-01", "2016-11-05"],
4900 ["2016-11-06", "2016-11-12"],
4901 ["2016-11-13", "2016-11-19"],
4902 ["2016-11-20", "2016-11-26"],
4903 ["2016-11-27", "2016-11-30"],
4904 ]);
4905 });
4906
4907 test(`popover ignores readonly field modifier`, async () => {
4908 await mountView({
4909 resModel: "event",
4910 type: "calendar",
4911 arch: `
4912 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month">
4913 <field name="delay" invisible="True"/>
4914 <field name="name" readonly="delay == 42"/>
4915 </calendar>
4916 `,
4917 });
4918
4919 await clickEvent(4);
4920 // test would fail here if we don't ignore readonly modifier
4921 const popover = getMockEnv().isSmall ? ".modal" : ".o_cw_popover";
4922 expect(popover).toHaveCount(1);
4923 });
4924
4925 test.tags("desktop");
4926 test(`calendar with option show_date_picker set to false and no filter`, async () => {
4927 await mountView({
4928 resModel: "event",
4929 type: "calendar",
4930 arch: `
4931 <calendar date_start="start" date_stop="stop" show_date_picker="0">
4932 <field name="name"/>
4933 </calendar>
4934 `,
4935 });
4936 expect(`.o_datetime_picker`).toHaveCount(0);
4937 expect(`.o_calendar_sidebar`).toHaveCount(0);
4938 expect(`.o_sidebar_toggler`).toHaveCount(0);
4939 });
4940
4941 test.tags("desktop");
4942 test(`calendar with option show_date_picker set to false and filters`, async () => {
4943 await mountView({
4944 resModel: "event",
4945 type: "calendar",
4946 arch: `
4947 <calendar date_start="start" date_stop="stop" show_date_picker="0">
4948 <field name="name"/>
4949 <field name="partner_id" filters="1"/>
4950 </calendar>
4951 `,
4952 });
4953 expect(`.o_datetime_picker`).toHaveCount(0);
4954 expect(`.o_calendar_sidebar`).toHaveCount(1);
4955 expect(`.o_sidebar_toggler`).toHaveCount(1);
4956 });
4957
4958 test(`calendar with option month_overflow not set (default)`, async () => {
4959 Event._records = [
4960 {
4961 id: 1,
4962 name: "event november",
4963 start: "2016-11-30 10:00:00",
4964 stop: "2016-11-30 15:00:00",
4965 user_id: serverState.userId,
4966 partner_id: 1,
4967 },
4968 {
4969 id: 2,
4970 name: "event december",
4971 start: "2016-12-14 10:00:00",
4972 stop: "2016-12-14 15:00:00",
4973 user_id: serverState.userId,
4974 partner_id: 1,
4975 },
4976 ];
4977
4978 onRpc("search_read", ({ kwargs }) => {
4979 expect.step("search_read");
4980 expect(kwargs.domain).toEqual([
4981 ["start", "<=", "2017-01-07 22:59:59"],
4982 ["start", ">=", "2016-11-26 23:00:00"],
4983 ]);
4984 });
4985 await mountView({
4986 resModel: "event",
4987 type: "calendar",
4988 arch: `
4989 <calendar date_start="start" mode="month">
4990 <field name="name"/>
4991 </calendar>
4992 `,
4993 });
4994 expect(`.o_event`).toHaveCount(2);
4995 expect(".fc-day-disabled").toHaveCount(0);
4996 expect.verifySteps(["search_read"]);
4997 });
4998
4999 test(`calendar with option month_overflow set to false`, async () => {
5000 Event._records = [
5001 {
5002 id: 1,
5003 name: "event november",
5004 start: "2016-11-30 10:00:00",
5005 stop: "2016-11-30 15:00:00",
5006 user_id: serverState.userId,
5007 partner_id: 1,
5008 },
5009 {
5010 id: 2,
5011 name: "event december",
5012 start: "2016-12-14 10:00:00",
5013 stop: "2016-12-14 15:00:00",
5014 user_id: serverState.userId,
5015 partner_id: 1,
5016 },
5017 {
5018 id: 3,
5019 name: "event january",
5020 start: "2017-01-02 10:00:00",
5021 stop: "2016-01-02 15:00:00",
5022 user_id: serverState.userId,
5023 partner_id: 1,
5024 },
5025 ];
5026
5027 onRpc("search_read", ({ kwargs }) => {
5028 expect.step("search_read");
5029 expect(kwargs.domain).toEqual([
5030 ["start", "<=", "2016-12-31 22:59:59"],
5031 ["start", ">=", "2016-11-30 23:00:00"],
5032 ]);
5033 });
5034 await mountView({
5035 resModel: "event",
5036 type: "calendar",
5037 arch: `
5038 <calendar date_start="start" mode="month" month_overflow="0">
5039 <field name="name"/>
5040 </calendar>
5041 `,
5042 });
5043 expect(".o_event").toHaveCount(1);
5044 expect(".fc-day-disabled").toHaveCount(4);
5045 expect.verifySteps(["search_read"]);
5046 });
5047
5048 test.tags("desktop");
5049 test(`can not select invalid scale from datepicker`, async () => {
5050 await mountView({
5051 resModel: "event",
5052 type: "calendar",
5053 arch: `
5054 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" scales="month,year">
5055 <field name="delay" invisible="True"/>
5056 <field name="name" readonly="delay == 42"/>
5057 </calendar>
5058 `,
5059 });
5060
5061 await contains(`.o_datetime_picker .o_today`).click();
5062 // test would fail here if we went to week mode
5063 expect(`.fc-dayGridMonth-view`).toHaveCount(1);
5064 });
5065
5066 test(`calendar with custom quick create view`, async () => {
5067 mockService("dialog", {
5068 add(_, props) {
5069 expect.step(`add dialog ${props.viewId}`);
5070 return () => {};
5071 },
5072 });
5073
5074 await mountView({
5075 resModel: "event",
5076 type: "calendar",
5077 arch: `
5078 <calendar date_start="start" date_stop="stop" all_day="is_all_day" mode="month" quick_create="1" quick_create_view_id="2">
5079 <field name="name"/>
5080 </calendar>
5081 `,
5082 });
5083 await clickAllDaySlot("2016-12-01");
5084 expect.verifySteps(["add dialog 2"]);
5085 });
5086
5087 test(`check apply default record label`, async () => {
5088 class TestCalendarController extends CalendarController {
5089 get editRecordDefaultDisplayText() {
5090 return "Test Display";
5091 }
5092 }
5093
5094 registry.category("views").add("test_calendar_view", {
5095 ...calendarView,
5096 Controller: TestCalendarController,
5097 });
5098
5099 await mountView({
5100 resModel: "event",
5101 type: "calendar",
5102 arch: `<calendar js_class="test_calendar_view" date_start="start" date_stop="stop" all_day="is_all_day" mode="month" quick_create="0" event_open_popup="1"/>`,
5103 });
5104
5105 await clickDate("2016-12-13");
5106 expect(`.modal-title`).toHaveText("Test Display");
5107 });
5108
5109 test(`calendar render properties in popover`, async () => {
5110 Event._fields.properties = fields.Properties({
5111 definition_record: "type_id",
5112 definition_record_field: "definitions",
5113 });
5114 Event._records[0].type_id = 1;
5115 Event._records[0].properties = {
5116 property_1: "hello",
5117 property_2: "b",
5118 property_3: "hidden",
5119 };
5120
5121 EventType._fields.definitions = fields.PropertiesDefinition();
5122 EventType._records[0].definitions = [
5123 {
5124 name: "property_1",
5125 string: "My Char",
5126 type: "char",
5127 view_in_cards: true,
5128 },
5129 {
5130 name: "property_2",
5131 string: "My Selection",
5132 type: "selection",
5133 selection: [
5134 ["a", "A"],
5135 ["b", "B"],
5136 ["c", "C"],
5137 ],
5138 default: "c",
5139 view_in_cards: true,
5140 },
5141 {
5142 name: "property_3",
5143 string: "Hidden Char",
5144 type: "char",
5145 view_in_cards: false,
5146 },
5147 ];
5148
5149 await mountView({
5150 resModel: "event",
5151 type: "calendar",
5152 arch: `
5153 <calendar quick_create="0" event_open_popup="1" date_start="start">
5154 <field name="type_id"/>
5155 <field name="properties"/>
5156 </calendar>
5157 `,
5158 });
5159
5160 await clickEvent(1);
5161 const popover = getMockEnv().isSmall ? ".modal" : ".o_popover";
5162 // Labels:
5163 expect(queryAllTexts(`${popover} .o_calendar_property_field span.fw-bold`)).toEqual([
5164 "My Char",
5165 "My Selection",
5166 ]);
5167 // Values:
5168 expect(queryAllTexts(`${popover} .o_calendar_property_field div.text-truncate`)).toEqual([
5169 "hello",
5170 "B",
5171 ]);
5172 });
5173
5174 test(`calendar create record with default properties`, async () => {
5175 Event._fields.properties = fields.Properties({
5176 definition_record: "type_id",
5177 definition_record_field: "definitions",
5178 });
5179 Event._views = {
5180 form: `
5181 <form>
5182 <group>
5183 <field name="name"/>
5184 <field name="type_id"/>
5185 <field name="properties"/>
5186 </group>
5187 </form>
5188 `,
5189 };
5190
5191 EventType._fields.definitions = fields.PropertiesDefinition();
5192
5193 await mountView({
5194 resModel: "event",
5195 type: "calendar",
5196 arch: `
5197 <calendar quick_create="0" event_open_popup="1" date_start="start">
5198 <field name="type_id"/>
5199 <field name="properties"/>
5200 </calendar>
5201 `,
5202 context: {
5203 default_properties: [{ name: "event_prop", string: "Hello", type: "char" }],
5204 },
5205 });
5206 await selectTimeRange("2016-12-15 06:00:00", "2016-12-15 08:00:00");
5207 expect(`.modal`).toHaveCount(1);
5208 expect(`.modal [name='properties']`).toHaveText("Hello");
5209 });
5210
5211 test(`calendar show past events with background blur`, async () => {
5212 mockDate("2016-12-14 09:00:00");
5213
5214 await mountView({
5215 resModel: "event",
5216 type: "calendar",
5217 arch: `<calendar date_start="start" mode="week"/>`,
5218 });
5219 expect(`.o_event`).toHaveCount(5);
5220 expect(`.fc-event.o_past_event`).toHaveCount(4);
5221 });
5222
5223 test.tags("desktop");
5224 test(`calendar sidebar state is saved on session storage`, async () => {
5225 patchWithCleanup(sessionStorage, {
5226 setItem(key, value) {
5227 if (key === "calendar.showSideBar") {
5228 expect.step(`${key}-${value}`);
5229 }
5230 },
5231 getItem(key) {
5232 if (key === "calendar.showSideBar") {
5233 expect.step(`${key}-read`);
5234 return false;
5235 }
5236 },
5237 });
5238
5239 await mountView({
5240 resModel: "event",
5241 type: "calendar",
5242 arch: `<calendar date_start="start" mode="week"/>`,
5243 });
5244 expect(`.o_calendar_sidebar`).toHaveCount(0);
5245
5246 await contains(`.o_sidebar_toggler .oi-panel-right`).click();
5247 expect(`.o_calendar_sidebar`).toHaveCount(1);
5248 expect.verifySteps(["calendar.showSideBar-read", "calendar.showSideBar-true"]);
5249 });
5250
5251 test(`calendar should show date information on header`, async () => {
5252 mockDate("2015-12-26 09:00:00");
5253
5254 await mountView({
5255 resModel: "event",
5256 type: "calendar",
5257 arch: `<calendar date_start="start" mode="week"/>`,
5258 });
5259 expect(`.o_calendar_header h5`).toHaveText("December 2015\nWeek 52");
5260
5261 await changeScale("day");
5262 expect(`.o_calendar_header h5`).toHaveText("26 December 2015");
5263
5264 await changeScale("month");
5265 expect(`.o_calendar_header h5`).toHaveText("December 2015");
5266
5267 await changeScale("year");
5268 expect(`.o_calendar_header h5`).toHaveText("2015");
5269
5270 await changeScale("week");
5271 await navigate("next");
5272 expect(`.o_calendar_header h5`).toHaveText("December 2015 - January 2016\nWeek 53");
5273
5274 await navigate("prev");
5275 await navigate("prev");
5276 await navigate("prev");
5277 await navigate("prev");
5278 expect(`.o_calendar_header h5`).toHaveText("November - December 2015\nWeek 49");
5279 });
5280
5281 test(`calendar sidebar filters are ASC sorted (not valued @end)`, async () => {
5282 mockDate("2023-12-14 09:00:00");
5283
5284 Event._records = [];
5285 for (let i = 1; i <= 18; i++) {
5286 Event._records.push({
5287 user_id: i,
5288 name: `event ${i}`,
5289 start: "2023-12-11 00:00:00",
5290 stop: "2023-12-11 00:00:00",
5291 });
5292 }
5293 Event._records.push({
5294 user_id: false,
5295 name: `event X`,
5296 start: "2023-12-11 00:00:00",
5297 stop: "2023-12-11 00:00:00",
5298 });
5299
5300 CalendarUsers._records = [
5301 { id: 1, name: "Zoooro" },
5302 { id: 2, name: "Jean-Paul 1" },
5303 { id: 3, name: "Jean-Paul 2" },
5304 { id: 4, name: "Jeremy" },
5305 { id: 5, name: "Kévin" },
5306 { id: 6, name: "Romelü" },
5307 { id: 7, name: "Edên" },
5308 { id: 8, name: "Thibaùlt" },
5309 { id: 9, name: "1 - brol" },
5310 { id: 10, name: "10 - machin" },
5311 { id: 11, name: "11 - chose" },
5312 { id: 12, name: "101" },
5313 { id: 13, name: "100 - bidule" },
5314 { id: 14, name: "1000 - truc" },
5315 { id: 15, name: "00 - bazar" },
5316 { id: 16, name: "0 - chouette" },
5317 { id: 17, name: "@Hello" },
5318 { id: 18, name: "#Hello" },
5319 ];
5320
5321 await mountView({
5322 resModel: "event",
5323 type: "calendar",
5324 arch: `
5325 <calendar date_start="start" mode="month">
5326 <field name="user_id" filters="1"/>
5327 </calendar>
5328 `,
5329 });
5330 await displayCalendarPanel();
5331 expect(queryAllTexts`.o_calendar_filter_items .o_cw_filter_title`).toEqual([
5332 "00 - bazar",
5333 "0 - chouette",
5334 "1 - brol",
5335 "10 - machin",
5336 "11 - chose",
5337 "100 - bidule",
5338 "101",
5339 "1000 - truc",
5340 "Edên",
5341 "@Hello",
5342 "#Hello",
5343 "Jean-Paul 1",
5344 "Jean-Paul 2",
5345 "Jeremy",
5346 "Kévin",
5347 "Romelü",
5348 "Thibaùlt",
5349 "Zoooro",
5350 "Undefined",
5351 ]);
5352 });
5353
5354 test("sample data are not removed when switching back from calendar view", async () => {
5355 Event._records = [];
5356 Event._views = {
5357 calendar: `<calendar date_start="start" date_stop="stop" mode="day"/>`,
5358 list: `
5359 <list sample="1">
5360 <field name="start"/>
5361 <field name="stop"/>
5362 </list>
5363 `,
5364 };
5365
5366 defineActions([
5367 {
5368 id: 1,
5369 name: "Partners",
5370 res_model: "event",
5371 views: [
5372 [false, "list"],
5373 [false, "calendar"],
5374 ],
5375 },
5376 ]);
5377
5378 await mountWithCleanup(WebClient);
5379 await getService("action").doAction(1);
5380 expect(`.o_list_view`).toHaveCount(1);
5381 expect(`.o_view_sample_data`).toHaveCount(1);
5382
5383 await getService("action").switchView("calendar");
5384 expect(`.o_calendar_container`).toHaveCount(1);
5385
5386 await getService("action").switchView("list");
5387 expect(`.o_list_view`).toHaveCount(1);
5388 expect(`.o_view_sample_data`).toHaveCount(1);
5389 });
5390
5391 test(`Scale: scale default is fetched from localStorage`, async () => {
5392 patchWithCleanup(localStorage, {
5393 getItem(key) {
5394 if (key.startsWith("scaleOf-viewId")) {
5395 return "week";
5396 }
5397 },
5398 setItem(key, value) {
5399 if (key === "scaleOf-viewId-19") {
5400 expect.step(`scale_${value}`);
5401 }
5402 },
5403 });
5404
5405 await mountView({
5406 resModel: "event",
5407 type: "calendar",
5408 arch: `<calendar date_start="start" mode="month"/>`,
5409 viewId: 19,
5410 });
5411 expect.verifySteps(["scale_week"]);
5412 expect(`.scale_button_selection`).toHaveText("Week");
5413
5414 await changeScale("year");
5415 expect(`.scale_button_selection`).toHaveText("Year");
5416 expect.verifySteps(["scale_year"]);
5417 });
5418
5419 test.tags("desktop");
5420 test(`scroll to current hour when clicking on today`, async () => {
5421 mockDate("2016-12-12T01:00:00", 1);
5422 await mountView({
5423 resModel: "event",
5424 type: "calendar",
5425 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="week"/>`,
5426 });
5427 // Default scroll time should be 6am no matter the current hour
5428 expect(queryOne(".fc-scroller:last").scrollTop).toBeWithin(210, 230);
5429 await contains(".o_calendar_button_today").click();
5430 expect(queryOne(".fc-scroller:last").scrollTop).toBe(0);
5431 mockDate("2016-12-12T20:00:00", 1);
5432 await contains(".o_calendar_button_today").click();
5433 expect(queryOne(".fc-scroller:last").scrollTop).toBeWithin(360, 380);
5434 });
5435
5436 test("save selected date during view switching", async () => {
5437 defineActions([
5438 {
5439 id: 1,
5440 name: "Partners",
5441 res_model: "event",
5442 views: [
5443 [false, "list"],
5444 [false, "calendar"],
5445 ],
5446 },
5447 ]);
5448
5449 Event._views = {
5450 calendar: `<calendar date_start="start" date_stop="stop" mode="week"/>`,
5451 list: `
5452 <list sample="1">
5453 <field name="start"/>
5454 <field name="stop"/>
5455 </list>
5456 `,
5457 };
5458
5459 await mountWithCleanup(WebClient);
5460 await getService("action").doAction(1);
5461
5462 await getService("action").switchView("calendar");
5463 await navigate("next");
5464 const weekNumber = await queryFirst(`th .fc-timegrid-axis-cushion`).textContent;
5465 await getService("action").switchView("list");
5466 await getService("action").switchView("calendar");
5467 expect(`th .fc-timegrid-axis-cushion:eq(0)`).toHaveText(weekNumber);
5468 });
5469
5470 test(`check if active fields are fetched in addition to field names in record data(search_read rpc)`, async () => {
5471 class CustomWidget extends Component {
5472 static template = xml``;
5473 static props = ["*"];
5474 }
5475 registry.category("fields").add("custom_widget", {
5476 component: CustomWidget,
5477 fieldDependencies: [{ name: "delay", type: "float" }],
5478 });
5479
5480 onRpc("event", "search_read", ({ kwargs }) => {
5481 expect.step("event.search_read");
5482 expect(kwargs.fields).toInclude("delay");
5483 });
5484
5485 await mountView({
5486 resModel: "event",
5487 type: "calendar",
5488 arch: `
5489 <calendar date_start="start">
5490 <field name="user_id" widget="custom_widget"/>
5491 </calendar>
5492 `,
5493 });
5494
5495 expect.verifySteps(["event.search_read"]);
5496 });
5497
5498 test("update time while drag and drop on month mode", async () => {
5499 patchWithCleanup(CalendarRenderer.prototype, {
5500 get actionSwiperProps() {
5501 const props = super.actionSwiperProps;
5502 props.onLeftSwipe = undefined;
5503 props.onRightSwipe = undefined;
5504 return props;
5505 },
5506 });
5507 await mountView({
5508 resModel: "event",
5509 type: "calendar",
5510 arch: `
5511 <calendar date_start="start" date_stop="stop" mode="month" event_open_popup="1" quick_create="0">
5512 <field name="name"/>
5513 <field name="partner_id"/>
5514 </calendar>
5515 `,
5516 });
5517
5518 await clickDate("2016-12-20");
5519 await contains(".modal-body .o_field_widget[name=name] input").edit("An event");
5520 await contains(".modal-body .o_field_widget[name=start] button").click();
5521 await contains(".modal-body .o_field_widget[name=start] input").edit("2016-12-20 08:00:00");
5522 await contains(".modal-body .o_field_widget[name=stop] button").click();
5523 await contains(".modal-body .o_field_widget[name=stop] input").edit("2016-12-23 10:00:00");
5524 await contains(".modal .o_form_button_save").click();
5525 await moveEventToDate(8, "2016-12-27");
5526 await clickEvent(8);
5527 await contains(".o_cw_popover_edit").click();
5528
5529 expect(".o_field_widget[name='start']").toHaveText("Dec 26, 8:00 AM");
5530 expect(".o_field_widget[name='stop']").toHaveText("Dec 29, 10:00 AM");
5531 });
5532
5533 test("html field on calendar shouldn't have a tooltip", async () => {
5534 Event._fields.description = fields.Html();
5535 Event._records[0].description = "<p>test html field</p>";
5536 await mountView({
5537 type: "calendar",
5538 resModel: "event",
5539 arch: `
5540 <calendar date_start="start">
5541 <field name="description"/>
5542 </calendar>
5543 `,
5544 });
5545
5546 await clickEvent(MockServer.env["event"][0].id);
5547 const descriptionField = queryFirst('.o_cw_popover_field .o_field_widget[name="description"]');
5548 const parentLi = descriptionField.closest("li");
5549 expect(parentLi).toHaveAttribute("data-tooltip", "");
5550 });
5551
5552 test.tags("mobile");
5553 test("simple calendar rendering in mobile", async () => {
5554 await mountView({
5555 resModel: "event",
5556 type: "calendar",
5557 arch: `<calendar date_start="start" date_stop="stop"><field name="name"/></calendar>`,
5558 });
5559
5560 expect(".o_calendar_button_prev").toHaveCount(0, { message: "prev button should be hidden" });
5561 expect(".o_calendar_button_next").toHaveCount(0, { message: "next button should be hidden" });
5562 expect(".o_calendar_container .o_calendar_header button.o_calendar_button_today").toBeVisible({
5563 message: "today button should be visible",
5564 });
5565 // Test all views
5566 // displays month mode by default
5567 expect(".o_calendar_container .o_calendar_header .dropdown-toggle").toHaveText("Week", {
5568 message: "should display the current week",
5569 });
5570 // switch to day mode
5571 await contains(".o_calendar_container .o_calendar_header .dropdown-toggle").click();
5572 await contains(".o-dropdown--menu .o_scale_button_day").click();
5573 await animationFrame();
5574 expect(".o_calendar_container .o_calendar_header .dropdown-toggle").toHaveText("Day", {
5575 message: "should display the current day",
5576 });
5577 // switch to month mode
5578 await contains(".o_calendar_container .o_calendar_header .dropdown-toggle").click();
5579 await contains(".o-dropdown--menu .o_scale_button_month").click();
5580 // await nextTick();
5581 expect(".o_calendar_container .o_calendar_header .dropdown-toggle").toHaveText("Month", {
5582 message: "should display the current month",
5583 });
5584
5585 // switch to year mode
5586 await contains(".o_calendar_container .o_calendar_header .dropdown-toggle").click();
5587 await contains(".o-dropdown--menu .o_scale_button_year").click();
5588 // await nextTick();
5589 expect(".o_calendar_container .o_calendar_header .dropdown-toggle").toHaveText("Year", {
5590 message: "should display the current year",
5591 });
5592 });
5593
5594 test.tags("mobile");
5595 test("calendar: popover is rendered as dialog in mobile", async () => {
5596 // Legacy name of this test: "calendar: popover rendering in mobile"
5597 await mountView({
5598 type: "calendar",
5599 resModel: "event",
5600 arch: `<calendar date_start="start" date_stop="stop"><field name="name"/></calendar>`,
5601 });
5602
5603 await clickEvent(1);
5604 expect(".o_cw_popover").toHaveCount(0);
5605 expect(".modal").toHaveCount(1);
5606 expect(".modal").toHaveClass("o_modal_full");
5607
5608 expect(".modal-footer .btn").toHaveCount(2);
5609 expect(".modal-footer .btn.btn-primary.o_cw_popover_edit").toHaveCount(1);
5610 expect(".modal-footer .btn.btn-secondary.o_cw_popover_delete").toHaveCount(1);
5611 });
5612
5613 test.tags("mobile");
5614 test("calendar: today button", async () => {
5615 await mountView({
5616 type: "calendar",
5617 resModel: "event",
5618 arch: `<calendar mode="day" date_start="start" date_stop="stop"></calendar>`,
5619 });
5620 expandCalendarView();
5621 expect(queryFirst(".fc-col-header-cell[data-date]").dataset.date).toBe("2016-12-12");
5622
5623 await navigate("prev");
5624
5625 expect(queryFirst(".fc-col-header-cell[data-date]").dataset.date).toBe("2016-12-11");
5626
5627 await contains(".o_calendar_button_today").click();
5628 expect(queryFirst(".fc-col-header-cell[data-date]").dataset.date).toBe("2016-12-12");
5629 });
5630
5631 test.tags("mobile");
5632 test("calendar: show and change other calendar", async () => {
5633 await mountView({
5634 type: "calendar",
5635 resModel: "event",
5636 arch: `
5637 <calendar date_start="start" date_stop="stop" color="partner_id">
5638 <filter name="user_id" avatar_field="image"/>
5639 <field name="partner_id" filters="1" invisible="1"/>
5640 </calendar>`,
5641 });
5642
5643 expect(".o_calendar_renderer").toHaveCount(1);
5644 expect(".o_other_calendar_panel").toHaveCount(1);
5645 await displayCalendarPanel();
5646 expect(".o_calendar_filter_items_checkall").toHaveCount(1, {
5647 message: "should contain one filter to check all",
5648 });
5649 expect(".o_calendar_filter_item").toHaveCount(2, {
5650 message: "should contain 2 child nodes -> 2 resources",
5651 });
5652
5653 expect(".o_calendar_sidebar").toHaveCount(1);
5654 expect(".o_calendar_renderer").toHaveCount(0);
5655 expect(".o_calendar_filter").toHaveCount(1);
5656 expect(".o_calendar_filter[data-name=partner_id]").toHaveCount(1);
5657
5658 // Toggle the whole section filters by unchecking the all items checkbox
5659 await hideCalendarPanel();
5660 await toggleSectionFilter("partner_id");
5661 await displayCalendarPanel();
5662 expect(".o_other_calendar_panel .o_filter > *").toHaveCount(0, {
5663 message: "should contain 0 child nodes -> no filters selected",
5664 });
5665
5666 // Toggle again the other calendar panel should hide the sidebar and show the calendar view
5667 await contains(".o_other_calendar_panel").click();
5668 expect(".o_calendar_sidebar").toHaveCount(0);
5669 expect(".o_calendar_renderer").toHaveCount(1);
5670 });
5671
5672 test.tags("mobile");
5673 test('calendar: tap on "Free Zone" opens quick create', async () => {
5674 patchWithCleanup(CalendarCommonRenderer.prototype, {
5675 onDateClick(...args) {
5676 expect.step("dateClick");
5677 return super.onDateClick(...args);
5678 },
5679 onSelect(...args) {
5680 expect.step("select");
5681 return super.onSelect(...args);
5682 },
5683 });
5684
5685 await mountView({
5686 type: "calendar",
5687 resModel: "event",
5688 arch: `<calendar mode="day" date_start="start" date_stop="stop"/>`,
5689 });
5690 expandCalendarView();
5691
5692 // Simulate a "TAP" (touch)
5693 await click(".fc-timegrid-slot-lane.fc-timegrid-slot-minor[data-time='08:30:00']");
5694 await animationFrame();
5695
5696 // should open a Quick create modal view in mobile on short tap
5697 expect(".modal").toHaveCount(1);
5698 expect.verifySteps(["dateClick"]);
5699 });
5700
5701 test.tags("mobile");
5702 test('calendar: select range on "Free Zone" opens quick create', async () => {
5703 patchWithCleanup(CalendarCommonRenderer.prototype, {
5704 onDateClick(info) {
5705 expect.step("dateClick");
5706 return super.onDateClick(info);
5707 },
5708 onSelect(info) {
5709 expect.step("select");
5710 expect(info.startStr).toBe("2016-12-12T08:00:00+01:00");
5711 expect(info.endStr).toBe("2016-12-12T09:00:00+01:00");
5712 return super.onSelect(info);
5713 },
5714 });
5715
5716 await mountView({
5717 type: "calendar",
5718 resModel: "event",
5719 arch: `<calendar mode="day" date_start="start" date_stop="stop"/>`,
5720 });
5721 expandCalendarView();
5722
5723 await selectRange(
5724 ".fc-timegrid-slot-lane[data-time='08:00:00']",
5725 ".fc-timegrid-slot-lane[data-time='08:30:00']",
5726 { start: "top", end: "bottom" }
5727 );
5728
5729 // should open a Quick create modal view in mobile on short tap
5730 expect(".modal").toHaveCount(1);
5731 expect.verifySteps(["select"]);
5732 });
5733
5734 test("calendar (year): select date range opens quick create", async () => {
5735 patchWithCleanup(CalendarYearRenderer.prototype, {
5736 onDateClick(info) {
5737 expect.step("dateClick");
5738 return super.onDateClick(info);
5739 },
5740 onSelect(info) {
5741 expect.step("select");
5742 expect(info.startStr).toBe("2016-02-02");
5743 expect(info.endStr).toBe("2016-02-06"); // end date is exclusive
5744 return super.onSelect(info);
5745 },
5746 });
5747
5748 await mountView({
5749 type: "calendar",
5750 resModel: "event",
5751 arch: `<calendar mode="year" date_start="start" date_stop="stop"/>`,
5752 });
5753 expandCalendarView();
5754
5755 // Tap on a date
5756 await selectRange(
5757 ".fc-daygrid-day[data-date='2016-02-02']",
5758 ".fc-daygrid-day[data-date='2016-02-05']"
5759 );
5760
5761 // should open a Quick create modal view in mobile on short tap
5762 expect(".modal").toHaveCount(1);
5763 expect.verifySteps(["select"]);
5764 });
5765
5766 test.tags("mobile");
5767 test("calendar (year): tap on date switch to day scale", async () => {
5768 await mountView({
5769 type: "calendar",
5770 resModel: "event",
5771 arch: `<calendar mode="year" date_start="start" date_stop="stop"/>`,
5772 });
5773 expandCalendarView();
5774
5775 // Should display year view
5776 expect(".fc-dayGridYear-view").toHaveCount(1);
5777 expect(".fc-month-container").toHaveCount(12);
5778
5779 // Tap on a date
5780 await click(".fc-daygrid-day[data-date='2016-02-05']");
5781 await animationFrame(); // switch renderer
5782 await animationFrame(); // await breadcrumb update
5783 expect(".o_calendar_container .o_calendar_header h5").toHaveText("5 February 2016");
5784
5785 // Should display day view
5786 expect(".fc-dayGridYear-view").toHaveCount(0);
5787 expect(".fc-timeGridDay-view").toHaveCount(1);
5788 expect(queryFirst(".fc-col-header-cell[data-date]").dataset.date).toBe("2016-02-05");
5789
5790 // Change scale to month
5791 await changeScale("month");
5792 expect(".o_calendar_container .o_calendar_header h5").toHaveCount(1);
5793 expect(".o_calendar_container .o_calendar_header h5").toHaveText("February 2016");
5794 expect(".fc-timeGridDay-view").toHaveCount(0);
5795 expect(".fc-dayGridMonth-view").toHaveCount(1);
5796
5797 // Tap on a date
5798 await click(".fc-daygrid-day[data-date='2016-02-10']");
5799 await animationFrame(); // await reload & render
5800 await animationFrame(); // await breadcrumb update
5801 expect(".o_calendar_container .o_calendar_header h5").toHaveText("February 2016");
5802
5803 // should open a Quick create modal view in mobile on short tap on date in monthly view
5804 expect(".modal").toHaveCount(1);
5805 });
5806
5807 test("calendar: check context is correclty sent to fetch data", async () => {
5808 expect.assertions(1);
5809 onRpc("event", "search_read", ({ kwargs }) => {
5810 const { active_test } = kwargs.context;
5811 expect(active_test).toBe(true);
5812 });
5813 await mountView({
5814 resModel: "event",
5815 type: "calendar",
5816 arch: `
5817 <calendar date_start="start" date_stop="stop">
5818 <field name="name"/>
5819 </calendar>`,
5820 context: { active_test: true },
5821 });
5822 });
5823
5824 test(`disable editing without write access rights`, async () => {
5825 await mountView({
5826 resModel: "event",
5827 type: "calendar",
5828 arch: `
5829 <calendar date_start="start" date_stop="stop" edit="0">
5830 <field name="name"/>
5831 </calendar>
5832 `,
5833 });
5834 expect(`.fc-event-draggable`).toHaveCount(0, {
5835 message: "Record should not be draggable/editable",
5836 });
5837 });
5838
5839 test(`calendar view with show_unusual_days`, async () => {
5840 let unusualDays = {
5841 "2016-12-14": true,
5842 };
5843 onRpc("get_unusual_days", ({ args }) => {
5844 expect.step(`get_unusual_days from ${args[0]} to ${args[1]}`);
5845 return unusualDays;
5846 });
5847 await mountView({
5848 resModel: "event",
5849 type: "calendar",
5850 arch: `
5851 <calendar date_start="start" date_stop="stop" show_unusual_days="1">
5852 <field name="name"/>
5853 </calendar>
5854 `,
5855 });
5856 expect(".fc-daygrid-day.o_calendar_disabled").toHaveCount(1);
5857 expect(".fc-daygrid-day.o_calendar_disabled").toHaveAttribute("data-date", "2016-12-14");
5858
5859 unusualDays = {
5860 "2016-12-14": true,
5861 "2016-12-21": true,
5862 };
5863 await changeScale("month");
5864 expect(".fc-daygrid-day.o_calendar_disabled").toHaveCount(2);
5865 expect(".fc-daygrid-day.o_calendar_disabled:eq(0)").toHaveAttribute("data-date", "2016-12-14");
5866 expect(".fc-daygrid-day.o_calendar_disabled:eq(1)").toHaveAttribute("data-date", "2016-12-21");
5867
5868 await changeScale("week");
5869 expect(".fc-daygrid-day.o_calendar_disabled").toHaveCount(1);
5870 expect(".fc-daygrid-day.o_calendar_disabled").toHaveAttribute("data-date", "2016-12-14");
5871
5872 unusualDays = {};
5873 await navigate("next");
5874 expect(".fc-daygrid-day.o_calendar_disabled").toHaveCount(0);
5875
5876 await navigate("prev");
5877 expect(".fc-daygrid-day.o_calendar_disabled").toHaveCount(1);
5878 expect(".fc-daygrid-day.o_calendar_disabled").toHaveAttribute("data-date", "2016-12-14");
5879
5880 expect.verifySteps([
5881 "get_unusual_days from 2016-12-10 23:00:00 to 2016-12-17 22:59:59",
5882 "get_unusual_days from 2016-11-26 23:00:00 to 2017-01-07 22:59:59",
5883 "get_unusual_days from 2016-12-17 23:00:00 to 2016-12-24 22:59:59",
5884 ]);
5885 });
5886
5887 test.tags("desktop");
5888 test(`calendar renderer is rendered once after search refresh`, async () => {
5889 patchWithCleanup(CalendarRenderer.prototype, {
5890 setup() {
5891 super.setup();
5892 onRendered(() => expect.step("rendered"));
5893 },
5894 });
5895 await mountView({
5896 resModel: "event",
5897 type: "calendar",
5898 arch: `
5899 <calendar date_start="start" date_stop="stop">
5900 <filter name="user_id"/>
5901 </calendar>
5902 `,
5903 });
5904 expect.verifySteps(["rendered"]);
5905 await validateSearch();
5906 expect.verifySteps(["rendered"]);
5907 });
5908
5909 test.tags("desktop");
5910 test(`calendar with filters and count aggregate`, async () => {
5911 await mountView({
5912 resModel: "event",
5913 type: "calendar",
5914 arch: `
5915 <calendar date_start="start" date_stop="stop" aggregate="id:count">
5916 <field name="attendee_ids" write_model="filter.partner" write_field="partner_id" filter_field="is_checked"/>
5917 </calendar>
5918 `,
5919 });
5920
5921 expect(queryAllTexts(".o_calendar_filter_item span")).toEqual(["partner 1", "2", "partner 2"]);
5922 });
5923
5924 test.tags("desktop");
5925 test(`calendar with dynamic filters and sum aggregate`, async () => {
5926 Event._fields.revenue = fields.Float();
5927 Event._records[0].revenue = 1200;
5928 Event._records[1].revenue = 350;
5929 Event._records[2].revenue = 800;
5930 Event._records[3].revenue = 3000;
5931 Event._records[4].revenue = 1900;
5932 await mountView({
5933 resModel: "event",
5934 type: "calendar",
5935 arch: `
5936 <calendar date_start="start" date_stop="stop" aggregate="revenue:sum">
5937 <field name="partner_id" filters="1"/>
5938 </calendar>
5939 `,
5940 });
5941
5942 expect(queryAllTexts(".o_calendar_filter_item span")).toEqual([
5943 "partner 1",
5944 "4,550",
5945 "partner 4",
5946 "2,700",
5947 ]);
5948 });
5949
5950 test.tags("desktop");
5951 test(`Hour format mirror event`, async () => {
5952 onRpc("create", ({ args }) => {
5953 expect.step("create");
5954 });
5955 await mountView({
5956 resModel: "event",
5957 type: "calendar",
5958 arch: `<calendar event_open_popup="1" date_start="start" date_stop="stop" all_day="is_all_day" mode="year"/>`,
5959 });
5960
5961 await changeScale("week");
5962
5963 await selectTimeRange("2016-12-13 11:00:00", "2016-12-13 16:30:00");
5964 // Verify highlighted event
5965 expect(`.fc-event-mirror`).toHaveText("11:00 - 16:30");
5966 await contains(`.o-calendar-quick-create--input`).edit("mirror_event", { confirm: false });
5967 await contains(`.o-calendar-quick-create--create-btn`).click();
5968
5969 expect.verifySteps(["create"]);
5970
5971 expect(`.o_event[data-event-id="8"] .fc-event-main .o_event_title`).toHaveText("mirror_event");
5972 expect(`.o_event[data-event-id="8"] .fc-event-main .fc-time`).toHaveText("11:00");
5973 });