moodlehq · dpalou · Aug 29, 2019 · Aug 29, 2019
diff --git a/src/addon/calendar/components/calendar/calendar.ts b/src/addon/calendar/components/calendar/calendar.ts
@@ -285,14 +285,16 @@ export class AddonCalendarCalendarComponent implements OnInit, OnChanges, OnDest
     /**
      * Refresh events.
      *
-     * @param {boolean} [sync] Whether it should try to synchronize offline events.
-     * @param {boolean} [showErrors] Whether to show sync errors to the user.
+     * @param {boolean} [afterChange] Whether the refresh is done after an event has changed or has been synced.
      * @return {Promise<any>} Promise resolved when done.
      */
-    refreshData(sync?: boolean, showErrors?: boolean): Promise<any> {
+    refreshData(afterChange?: boolean): Promise<any> {
         const promises = [];
 
-        promises.push(this.calendarProvider.invalidateMonthlyEvents(this.year, this.month));
+        // Don't invalidate monthly events after a change, it has already been handled.
+        if (!afterChange) {
+            promises.push(this.calendarProvider.invalidateMonthlyEvents(this.year, this.month));
+        }
         promises.push(this.coursesProvider.invalidateCategories(0, true));
         promises.push(this.calendarProvider.invalidateTimeFormat());
 

diff --git a/src/addon/calendar/components/upcoming-events/upcoming-events.ts b/src/addon/calendar/components/upcoming-events/upcoming-events.ts
@@ -225,14 +225,16 @@ export class AddonCalendarUpcomingEventsComponent implements OnInit, OnChanges,
     /**
      * Refresh events.
      *
-     * @param {boolean} [sync] Whether it should try to synchronize offline events.
-     * @param {boolean} [showErrors] Whether to show sync errors to the user.
+     * @param {boolean} [afterChange] Whether the refresh is done after an event has changed or has been synced.
      * @return {Promise<any>} Promise resolved when done.
      */
-    refreshData(sync?: boolean, showErrors?: boolean): Promise<any> {
+    refreshData(afterChange?: boolean): Promise<any> {
         const promises = [];
 
-        promises.push(this.calendarProvider.invalidateAllUpcomingEvents());
+        // Don't invalidate upcoming events after a change, it has already been handled.
+        if (!afterChange) {
+            promises.push(this.calendarProvider.invalidateAllUpcomingEvents());
+        }
         promises.push(this.coursesProvider.invalidateCategories(0, true));
         promises.push(this.calendarProvider.invalidateLookAhead());
         promises.push(this.calendarProvider.invalidateTimeFormat());

diff --git a/src/addon/calendar/pages/day/day.ts b/src/addon/calendar/pages/day/day.ts
@@ -113,35 +113,35 @@ export class AddonCalendarDayPage implements OnInit, OnDestroy {
         this.newEventObserver = eventsProvider.on(AddonCalendarProvider.NEW_EVENT_EVENT, (data) => {
             if (data && data.event) {
                 this.loaded = false;
-                this.refreshData(true, false);
+                this.refreshData(true, false, true);
             }
         }, this.currentSiteId);
 
         // Listen for new event discarded event. When it does, reload the data.
         this.discardedObserver = eventsProvider.on(AddonCalendarProvider.NEW_EVENT_DISCARDED_EVENT, () => {
             this.loaded = false;
-            this.refreshData(true, false);
+            this.refreshData(true, false, true);
         }, this.currentSiteId);
 
         // Listen for events edited. When an event is edited, reload the data.
         this.editEventObserver = eventsProvider.on(AddonCalendarProvider.EDIT_EVENT_EVENT, (data) => {
             if (data && data.event) {
                 this.loaded = false;
-                this.refreshData(true, false);
+                this.refreshData(true, false, true);
             }
         }, this.currentSiteId);
 
         // Refresh data if calendar events are synchronized automatically.
         this.syncObserver = eventsProvider.on(AddonCalendarSyncProvider.AUTO_SYNCED, (data) => {
             this.loaded = false;
-            this.refreshData();
+            this.refreshData(false, false, true);
         }, this.currentSiteId);
 
         // Refresh data if calendar events are synchronized manually but not by this page.
         this.manualSyncObserver = eventsProvider.on(AddonCalendarSyncProvider.MANUAL_SYNCED, (data) => {
             if (data && (data.source != 'day' || data.year != this.year || data.month != this.month || data.day != this.day)) {
                 this.loaded = false;
-                this.refreshData();
+                this.refreshData(false, false, true);
             }
         }, this.currentSiteId);
 
@@ -153,7 +153,7 @@ export class AddonCalendarDayPage implements OnInit, OnDestroy {
                 this.deletedEvents.push(data.eventId);
             } else {
                 this.loaded = false;
-                this.refreshData();
+                this.refreshData(false, false, true);
             }
         }, this.currentSiteId);
 
@@ -425,15 +425,19 @@ export class AddonCalendarDayPage implements OnInit, OnDestroy {
      *
      * @param {boolean} [sync] Whether it should try to synchronize offline events.
      * @param {boolean} [showErrors] Whether to show sync errors to the user.
+     * @param {boolean} [afterChange] Whether the refresh is done after an event has changed or has been synced.
      * @return {Promise<any>} Promise resolved when done.
      */
-    refreshData(sync?: boolean, showErrors?: boolean): Promise<any> {
+    refreshData(sync?: boolean, showErrors?: boolean, afterChange?: boolean): Promise<any> {
         this.syncIcon = 'spinner';
 
         const promises = [];
 
+        // Don't invalidate day events after a change, it has already been handled.
+        if (!afterChange) {
+            promises.push(this.calendarProvider.invalidateDayEvents(this.year, this.month, this.day));
+        }
         promises.push(this.calendarProvider.invalidateAllowedEventTypes());
-        promises.push(this.calendarProvider.invalidateDayEvents(this.year, this.month, this.day));
         promises.push(this.coursesProvider.invalidateCategories(0, true));
         promises.push(this.calendarProvider.invalidateTimeFormat());
 

diff --git a/src/addon/calendar/pages/edit-event/edit-event.ts b/src/addon/calendar/pages/edit-event/edit-event.ts
@@ -499,7 +499,7 @@ export class AddonCalendarEditEventPage implements OnInit, OnDestroy {
                 const numberOfRepetitions = formData.repeat ? formData.repeats :
                     (data.repeateditall && this.event.othereventscount ? this.event.othereventscount + 1 : 1);
 
-                this.calendarHelper.invalidateRepeatedEventsOnCalendarForEvent(result.event, numberOfRepetitions).catch(() => {
+                return this.calendarHelper.refreshAfterChangeEvent(result.event, numberOfRepetitions).catch(() => {
                     // Ignore errors.
                 });
             }

diff --git a/src/addon/calendar/pages/event/event.ts b/src/addon/calendar/pages/event/event.ts
@@ -449,8 +449,8 @@ export class AddonCalendarEventPage implements OnDestroy {
 
                 if (sent) {
                     // Event deleted, invalidate right days & months.
-                    promise = this.calendarHelper.invalidateRepeatedEventsOnCalendarForEvent(this.event,
-                            deleteAll ? this.event.eventcount : 1).catch(() => {
+                    promise = this.calendarHelper.refreshAfterChangeEvent(this.event, deleteAll ? this.event.eventcount : 1)
+                            .catch(() => {
                         // Ignore errors.
                     });
                 } else {

diff --git a/src/addon/calendar/pages/index/index.ts b/src/addon/calendar/pages/index/index.ts
@@ -95,42 +95,42 @@ export class AddonCalendarIndexPage implements OnInit, OnDestroy {
         this.newEventObserver = eventsProvider.on(AddonCalendarProvider.NEW_EVENT_EVENT, (data) => {
             if (data && data.event) {
                 this.loaded = false;
-                this.refreshData(true, false);
+                this.refreshData(true, false, true);
             }
         }, this.currentSiteId);
 
         // Listen for new event discarded event. When it does, reload the data.
         this.discardedObserver = eventsProvider.on(AddonCalendarProvider.NEW_EVENT_DISCARDED_EVENT, () => {
             this.loaded = false;
-            this.refreshData(true, false);
+            this.refreshData(true, false, true);
         }, this.currentSiteId);
 
         // Listen for events edited. When an event is edited, reload the data.
         this.editEventObserver = eventsProvider.on(AddonCalendarProvider.EDIT_EVENT_EVENT, (data) => {
             if (data && data.event) {
                 this.loaded = false;
-                this.refreshData(true, false);
+                this.refreshData(true, false, true);
             }
         }, this.currentSiteId);
 
         // Refresh data if calendar events are synchronized automatically.
         this.syncObserver = eventsProvider.on(AddonCalendarSyncProvider.AUTO_SYNCED, (data) => {
             this.loaded = false;
-            this.refreshData();
+            this.refreshData(false, false, true);
         }, this.currentSiteId);
 
         // Refresh data if calendar events are synchronized manually but not by this page.
         this.manualSyncObserver = eventsProvider.on(AddonCalendarSyncProvider.MANUAL_SYNCED, (data) => {
             if (data && data.source != 'index') {
                 this.loaded = false;
-                this.refreshData();
+                this.refreshData(false, false, true);
             }
         }, this.currentSiteId);
 
         // Update the events when an event is deleted.
         this.deleteEventObserver = eventsProvider.on(AddonCalendarProvider.DELETED_EVENT_EVENT, (data) => {
             this.loaded = false;
-            this.refreshData();
+            this.refreshData(false, false, true);
         }, this.currentSiteId);
 
         // Update the "hasOffline" property if an event deleted in offline is restored.
@@ -251,9 +251,10 @@ export class AddonCalendarIndexPage implements OnInit, OnDestroy {
      *
      * @param {boolean} [sync] Whether it should try to synchronize offline events.
      * @param {boolean} [showErrors] Whether to show sync errors to the user.
+     * @param {boolean} [afterChange] Whether the refresh is done after an event has changed or has been synced.
      * @return {Promise<any>} Promise resolved when done.
      */
-    refreshData(sync?: boolean, showErrors?: boolean): Promise<any> {
+    refreshData(sync?: boolean, showErrors?: boolean, afterChange?: boolean): Promise<any> {
         this.syncIcon = 'spinner';
 
         const promises = [];
@@ -262,9 +263,9 @@ export class AddonCalendarIndexPage implements OnInit, OnDestroy {
 
         // Refresh the sub-component.
         if (this.showCalendar && this.calendarComponent) {
-            promises.push(this.calendarComponent.refreshData());
+            promises.push(this.calendarComponent.refreshData(afterChange));
         } else if (!this.showCalendar && this.upcomingEventsComponent) {
-            promises.push(this.upcomingEventsComponent.refreshData());
+            promises.push(this.upcomingEventsComponent.refreshData(afterChange));
         }
 
         return Promise.all(promises).finally(() => {

diff --git a/src/addon/calendar/providers/calendar-sync.ts b/src/addon/calendar/providers/calendar-sync.ts
@@ -159,7 +159,7 @@ export class AddonCalendarSyncProvider extends CoreSyncBaseProvider {
                 // Data has been sent to server. Now invalidate the WS calls.
                 const promises = [
                     this.calendarProvider.invalidateEventsList(siteId),
-                    this.calendarHelper.invalidateRepeatedEventsOnCalendar(result.toinvalidate, siteId)
+                    this.calendarHelper.refreshAfterChangeEvents(result.toinvalidate, siteId)
                 ];
 
                 return Promise.all(promises).catch(() => {

diff --git a/src/addon/calendar/providers/calendar.ts b/src/addon/calendar/providers/calendar.ts
@@ -15,7 +15,7 @@
 import { Injectable } from '@angular/core';
 import { CoreLoggerProvider } from '@providers/logger';
 import { CoreSitesProvider, CoreSiteSchema } from '@providers/sites';
-import { CoreSite } from '@classes/site';
+import { CoreSite, CoreSiteWSPreSets } from '@classes/site';
 import { CoreCoursesProvider } from '@core/courses/providers/courses';
 import { CoreAppProvider } from '@providers/app';
 import { CoreTextUtilsProvider } from '@providers/utils/text';
@@ -971,10 +971,12 @@ export class AddonCalendarProvider {
      * @param {number} day Day to get.
      * @param {number} [courseId] Course to get.
      * @param {number} [categoryId] Category to get.
+     * @param  {boolean} [ignoreCache] True if it should ignore cached data (it will always fail in offline or server down).
      * @param {string} [siteId] Site ID. If not defined, current site.
      * @return {Promise<any>} Promise resolved with the response.
      */
-    getDayEvents(year: number, month: number, day: number, courseId?: number, categoryId?: number, siteId?: string): Promise<any> {
+    getDayEvents(year: number, month: number, day: number, courseId?: number, categoryId?: number, ignoreCache?: boolean,
+            siteId?: string): Promise<any> {
 
         return this.sitesProvider.getSite(siteId).then((site) => {
 
@@ -991,11 +993,16 @@ export class AddonCalendarProvider {
                 data.categoryid = categoryId;
             }
 
-            const preSets = {
+            const preSets: CoreSiteWSPreSets = {
                 cacheKey: this.getDayEventsCacheKey(year, month, day, courseId, categoryId),
                 updateFrequency: CoreSite.FREQUENCY_SOMETIMES
             };
 
+            if (ignoreCache) {
+                preSets.getFromCache = false;
+                preSets.emergencyCache = false;
+            }
+
             return site.read('core_calendar_get_calendar_day_view', data, preSets).then((response) => {
                 this.storeEventsInLocalDB(response.events, siteId);
 
@@ -1159,18 +1166,19 @@ export class AddonCalendarProvider {
             return site.getDb().getRecords(AddonCalendarProvider.EVENTS_TABLE, {repeatid: repeatId});
         });
     }
-
     /**
      * Get monthly calendar events.
      *
      * @param {number} year Year to get.
      * @param {number} month Month to get.
      * @param {number} [courseId] Course to get.
      * @param {number} [categoryId] Category to get.
+     * @param  {boolean} [ignoreCache] True if it should ignore cached data (it will always fail in offline or server down).
      * @param {string} [siteId] Site ID. If not defined, current site.
      * @return {Promise<any>} Promise resolved with the response.
      */
-    getMonthlyEvents(year: number, month: number, courseId?: number, categoryId?: number, siteId?: string): Promise<any> {
+    getMonthlyEvents(year: number, month: number, courseId?: number, categoryId?: number, ignoreCache?: boolean, siteId?: string)
+            : Promise<any> {
 
         return this.sitesProvider.getSite(siteId).then((site) => {
 
@@ -1180,7 +1188,7 @@ export class AddonCalendarProvider {
             };
 
             // This parameter requires Moodle 3.5.
-            if ( site.isVersionGreaterEqualThan('3.5')) {
+            if (site.isVersionGreaterEqualThan('3.5')) {
                 // Set mini to 1 to prevent returning the course selector HTML.
                 data.mini = 1;
             }
@@ -1192,11 +1200,16 @@ export class AddonCalendarProvider {
                 data.categoryid = categoryId;
             }
 
-            const preSets = {
+            const preSets: CoreSiteWSPreSets = {
                 cacheKey: this.getMonthlyEventsCacheKey(year, month, courseId, categoryId),
                 updateFrequency: CoreSite.FREQUENCY_SOMETIMES
             };
 
+            if (ignoreCache) {
+                preSets.getFromCache = false;
+                preSets.emergencyCache = false;
+            }
+
             return site.read('core_calendar_get_calendar_monthly_view', data, preSets).then((response) => {
                 response.weeks.forEach((week) => {
                     week.days.forEach((day) => {
@@ -1253,10 +1266,11 @@ export class AddonCalendarProvider {
      *
      * @param {number} [courseId] Course to get.
      * @param {number} [categoryId] Category to get.
+     * @param  {boolean} [ignoreCache] True if it should ignore cached data (it will always fail in offline or server down).
      * @param {string} [siteId] Site ID. If not defined, current site.
      * @return {Promise<any>} Promise resolved with the response.
      */
-    getUpcomingEvents(courseId?: number, categoryId?: number, siteId?: string): Promise<any> {
+    getUpcomingEvents(courseId?: number, categoryId?: number, ignoreCache?: boolean, siteId?: string): Promise<any> {
 
         return this.sitesProvider.getSite(siteId).then((site) => {
 
@@ -1269,11 +1283,16 @@ export class AddonCalendarProvider {
                 data.categoryid = categoryId;
             }
 
-            const preSets = {
+            const preSets: CoreSiteWSPreSets = {
                 cacheKey: this.getUpcomingEventsCacheKey(courseId, categoryId),
                 updateFrequency: CoreSite.FREQUENCY_SOMETIMES
             };
 
+            if (ignoreCache) {
+                preSets.getFromCache = false;
+                preSets.emergencyCache = false;
+            }
+
             return site.read('core_calendar_get_calendar_upcoming_view', data, preSets).then((response) => {
                 this.storeEventsInLocalDB(response.events, siteId);