Adding related items to plannings and events (superdesk#2110)

.eslintrc.js

@@ -12,6 +12,9 @@ module.exports = Object.assign({}, sharedConfigs, {
                 'camelcase': 0,
                 'no-prototype-builtins': 0, // allow hasOwnProperty
                 'react/prop-types': 0, // using interfaces
+
+                // can make functions harder to read; forces into rewriting the function to insert a debugger
+                'arrow-body-style': 0,
             },
         },
         {

client/actions/events/api.ts

@@ -1,6 +1,6 @@
-import {get, isEqual, cloneDeep, pickBy, has, find, every, take} from 'lodash';
+import {get, cloneDeep, has, find, every, take} from 'lodash';
 
-import {planningApi} from '../../superdeskApi';
+import {planningApi, superdeskApi} from '../../superdeskApi';
 import {ISearchSpikeState, IEventSearchParams, IEventItem, IPlanningItem, IEventTemplate} from '../../interfaces';
 import {appConfig} from 'appConfig';
 
@@ -9,6 +9,7 @@ import {
     POST_STATE,
     MAIN,
     TO_BE_CONFIRMED_FIELD,
+    TEMP_ID_PREFIX,
 } from '../../constants';
 import * as selectors from '../../selectors';
 import {
@@ -19,14 +20,15 @@ import {
     isPublishedItemId,
     isTemporaryId,
     gettext,
-    getTimeZoneOffset,
 } from '../../utils';
 
 import planningApis from '../planning/api';
 import eventsUi from './ui';
 import main from '../main';
 import {eventParamsToSearchParams} from '../../utils/search';
 import {getRelatedEventIdsForPlanning} from '../../utils/planning';
+import {planning} from '../../api/planning';
+import * as actions from '../../actions';
 
 /**
  * Action dispatcher to load a series of recurring events into the local store.
@@ -480,11 +482,11 @@ function markEventPostponed(event: IEventItem, reason: string, actionedDate: str
     };
 }
 
-const markEventHasPlannings = (event, planning) => ({
-    type: EVENTS.ACTIONS.MARK_EVENT_HAS_PLANNINGS,
+const setEventPlannings = (event_id, planning_ids) => ({
+    type: EVENTS.ACTIONS.SET_EVENT_PLANNINGS,
     payload: {
-        event_id: event,
-        planning_item: planning,
+        event_id,
+        planning_ids,
     },
 });
 
@@ -547,6 +549,90 @@ const uploadFiles = (event) => (
     }
 );
 
+function updateLinkedPlanningsForEvent(
+    eventId: IEventItem['_id'],
+
+    /**
+     * these must be final values
+     * missing items will be linked, extra items unlinked
+     */
+    associatedPlannings: Array<IPlanningItem>,
+):Promise<void> {
+    return planningApi.events.getLinkedPlanningItems(eventId).then((currentlyLinked) => {
+        const currentLinkedIds = new Set(currentlyLinked.map((item) => item._id));
+
+        const toLink: Array<IPlanningItem> =
+            associatedPlannings.filter(({_id}) => currentLinkedIds.has(_id) !== true);
+
+        const toUnlink: Array<IPlanningItem> = currentlyLinked
+            .filter((item) => {
+                const createdAt = new Date(item._created);
+                const now = new Date();
+
+                const ageSeconds = (now.getTime() - createdAt.getTime()) / 1000;
+                const tooRecent = ageSeconds < 30;
+
+                if (tooRecent) {
+                    /**
+                     * This is a hack to workaround our existing "fake ID" workaround.
+                     * In event editor it is possible to create a planning item and relate it to current event at once.
+                     * It would happen only after saving, thus while it's not saved yet, we use a fake ID
+                     * - which will not remain the same after saving.
+                     * This function computes a list of planning items which have to be linked
+                     * and which have to be unlinked based on a desired outcome
+                     * which is that only items specified in {@link associatedPlannings} must remain linked.
+                     * The problem arises that when item with a fake ID is saved, and ID changes,
+                     * that item will immediately get unlinked by this function, because there is no way that
+                     * the new ID could have been a part of {@link associatedPlannings}
+                     * (which is computed before saving).
+                     */
+                    return false;
+                } else {
+                    const needToUnlink = associatedPlannings.find(({_id}) => _id === item._id) == null;
+
+                    return needToUnlink;
+                }
+            });
+
+        return Promise.all(
+            [
+                ...toLink.map((planningItem) => {
+                    const linkType = planningItem._temporary?.link_type;
+
+                    if (linkType == null) {
+                        superdeskApi.utilities.logger.error(
+                            new Error('linkType expected but not found'),
+                        );
+
+                        return Promise.resolve(planningItem);
+                    }
+
+                    const patch: Partial<IPlanningItem> = {
+                        related_events: [
+                            ...(planningItem.related_events ?? []),
+                            {_id: eventId, link_type: linkType},
+                        ],
+                    };
+
+                    return planning.update(planningItem, patch);
+                }),
+                ...toUnlink.map((planningItem) => {
+                    const patch: Partial<IPlanningItem> = {
+                        related_events: (planningItem.related_events ?? [])
+                            .filter((item) => item._id !== eventId),
+                    };
+
+                    return planning.update(planningItem, patch);
+                }),
+            ],
+        ).then((updatedPlanningItems) => {
+            planningApi.redux.store.dispatch<any>(planningApis.receivePlannings(updatedPlanningItems));
+
+            return null;
+        });
+    });
+}
+
 const save = (original, updates) => (
     (dispatch) => {
         let promise;
@@ -561,7 +647,7 @@ const save = (original, updates) => (
             promise = Promise.resolve({});
         }
 
-        return promise.then((originalEvent) => {
+        return promise.then((originalEvent): any => {
             const originalItem = eventUtils.modifyForServer(cloneDeep(originalEvent), true);
             const eventUpdates = eventUtils.getEventDiff(originalItem, updates);
 
@@ -574,9 +660,20 @@ const save = (original, updates) => (
                 EVENTS.UPDATE_METHODS[0].value :
                 eventUpdates.update_method?.value ?? eventUpdates.update_method;
 
-            return originalEvent?._id != null ?
+            const createOrUpdatePromise: Promise<Array<IEventItem>> = originalEvent?._id != null ?
                 planningApi.events.update(originalItem, eventUpdates) :
                 planningApi.events.create(eventUpdates);
+
+            return createOrUpdatePromise.then(([updatedEvent]: Array<IEventItem>) => {
+                if (updates.associated_plannings == null) {
+                    return Promise.resolve([updatedEvent]);
+                }
+
+                return updateLinkedPlanningsForEvent(
+                    updatedEvent._id,
+                    updates.associated_plannings.filter(({_id}) => !_id.startsWith(TEMP_ID_PREFIX)),
+                ).then(() => [updatedEvent]);
+            });
         });
     }
 );
@@ -757,7 +854,7 @@ const self = {
     silentlyFetchEventsById,
     cancelEvent,
     markEventCancelled,
-    markEventHasPlannings,
+    setEventPlannings,
     rescheduleEvent,
     updateEventTime,
     markEventPostponed,

client/actions/events/notifications.ts

@@ -348,6 +348,12 @@ const onEventDeleted = (e, data) => (
         }
     });
 
+const onEventLinkUpdated = (e, data: IWebsocketMessageData['EVENT_LINK_UPDATED']) => (
+    (dispatch, getState) => {
+        dispatch(eventsApi.setEventPlannings(data.event, data.links));
+        dispatch(main.fetchItemHistory({_id: data.event, type: ITEM_TYPE.EVENT}));
+    });
+
 // eslint-disable-next-line consistent-this
 const self = {
     onEventCreated,
@@ -363,6 +369,7 @@ const self = {
     onEventPostChanged,
     onEventExpired,
     onEventDeleted,
+    onEventLinkUpdated,
 };
 
 export const planningEventTemplateEvents = {
@@ -386,27 +393,28 @@ export const planningEventTemplateEvents = {
 
 // Map of notification name and Action Event to execute
 self.events = {
-    'events:created': () => (self.onEventCreated),
-    'events:created:recurring': () => (self.onRecurringEventCreated),
-    'events:updated': () => (self.onEventUpdated),
-    'events:updated:recurring': () => (self.onEventUpdated),
-    'events:lock': () => (self.onEventLocked),
-    'events:unlock': () => (self.onEventUnlocked),
-    'events:spiked': () => (self.onEventSpiked),
-    'events:unspiked': () => (self.onEventUnspiked),
-    'events:cancel': () => (self.onEventCancelled),
-    'events:reschedule': () => (self.onEventScheduleChanged),
-    'events:reschedule:recurring': () => (self.onEventScheduleChanged),
-    'events:postpone': () => (self.onEventPostponed),
-    'events:posted': () => (self.onEventPostChanged),
-    'events:posted:recurring': () => (self.onEventPostChanged),
-    'events:unposted': () => (self.onEventPostChanged),
-    'events:unposted:recurring': () => (self.onEventPostChanged),
-    'events:update_time': () => (self.onEventScheduleChanged),
-    'events:update_time:recurring': () => (self.onEventScheduleChanged),
-    'events:update_repetitions:recurring': () => (self.onEventScheduleChanged),
+    'events:created': () => self.onEventCreated,
+    'events:created:recurring': () => self.onRecurringEventCreated,
+    'events:updated': () => self.onEventUpdated,
+    'events:updated:recurring': () => self.onEventUpdated,
+    'events:lock': () => self.onEventLocked,
+    'events:unlock': () => self.onEventUnlocked,
+    'events:spiked': () => self.onEventSpiked,
+    'events:unspiked': () => self.onEventUnspiked,
+    'events:cancel': () => self.onEventCancelled,
+    'events:reschedule': () => self.onEventScheduleChanged,
+    'events:reschedule:recurring': () => self.onEventScheduleChanged,
+    'events:postpone': () => self.onEventPostponed,
+    'events:posted': () => self.onEventPostChanged,
+    'events:posted:recurring': () => self.onEventPostChanged,
+    'events:unposted': () => self.onEventPostChanged,
+    'events:unposted:recurring': () => self.onEventPostChanged,
+    'events:update_time': () => self.onEventScheduleChanged,
+    'events:update_time:recurring': () => self.onEventScheduleChanged,
+    'events:update_repetitions:recurring': () => self.onEventScheduleChanged,
     'events:expired': () => self.onEventExpired,
-    'events:delete': () => (self.onEventDeleted),
+    'events:delete': () => self.onEventDeleted,
+    'event:link_updated': () => self.onEventLinkUpdated,
     ...planningEventTemplateEvents,
 };
 

client/actions/main.ts

@@ -1,9 +1,7 @@
 import {get, isEmpty, isEqual, isNil, omit} from 'lodash';
 import moment from 'moment';
 
-import {appConfig as config} from 'appConfig';
-
-const appConfig = config as IPlanningConfig;
+import {appConfig} from 'appConfig';
 
 import {IUser} from 'superdesk-api';
 import {planningApi, superdeskApi} from '../superdeskApi';
@@ -21,7 +19,6 @@ import {
     ITEM_TYPE,
     IEventTemplate,
     IEventItem,
-    IPlanningConfig,
 } from '../interfaces';
 
 import {

client/actions/planning/notifications.ts

@@ -1,6 +1,6 @@
 import {get} from 'lodash';
 
-import {IWebsocketMessageData, ITEM_TYPE} from '../../interfaces';
+import {IWebsocketMessageData, ITEM_TYPE, IPlanningAppState} from '../../interfaces';
 import {planningApi} from '../../superdeskApi';
 
 import {gettext, lockUtils} from '../../utils';
@@ -10,7 +10,7 @@ import planning from './index';
 import assignments from '../assignments/index';
 
 import * as selectors from '../../selectors';
-import {events, fetchAgendas} from '../index';
+import {fetchAgendas} from '../index';
 import main from '../main';
 import {showModal, hideModal} from '../index';
 import eventsPlanning from '../eventsPlanning';
@@ -34,12 +34,6 @@ const onPlanningCreated = (_e: {}, data: IWebsocketMessageData['PLANNING_CREATED
             return Promise.resolve();
         }
 
-        // Update Redux store to mark Event's to have Planning items
-        for (let eventId of data.event_ids) {
-            dispatch(events.api.markEventHasPlannings(eventId, data.item));
-            dispatch(main.fetchItemHistory({_id: eventId, type: ITEM_TYPE.EVENT}));
-        }
-
         dispatch(main.setUnsetLoadingIndicator(true));
         return dispatch(planning.ui.scheduleRefetch())
             .then(() => dispatch(eventsPlanning.ui.scheduleRefetch()))
@@ -53,7 +47,9 @@ const onPlanningCreated = (_e: {}, data: IWebsocketMessageData['PLANNING_CREATED
  */
 const onPlanningUpdated = (_e: {}, data: IWebsocketMessageData['PLANNING_UPDATED']) => (
     (dispatch, getState) => {
-        if (data.item == null) {
+        const updatedPlanningId = data.item;
+
+        if (updatedPlanningId == null) {
             return Promise.resolve();
         } else if (selectors.general.sessionId(getState()) === data.session && (
             selectors.general.modalType(getState()) === MODALS.ADD_TO_PLANNING ||
@@ -64,21 +60,15 @@ const onPlanningUpdated = (_e: {}, data: IWebsocketMessageData['PLANNING_UPDATED
             return Promise.resolve();
         }
 
-        // Update Redux store to mark Event's to have Planning items
-        for (let eventId of data.event_ids) {
-            dispatch(events.api.markEventHasPlannings(eventId, data.item));
-            dispatch(main.fetchItemHistory({_id: eventId, type: ITEM_TYPE.EVENT}));
-        }
-
         const promises = [];
 
         promises.push(dispatch(planning.ui.scheduleRefetch())
             .then((results) => {
                 if (selectors.general.currentWorkspace(getState()) === WORKSPACE.ASSIGNMENTS) {
                     const currentPreviewId = selectors.main.previewId(getState());
 
-                    if (currentPreviewId === data.item) {
-                        dispatch(planning.api.fetchById(data.item, {force: true}));
+                    if (currentPreviewId === updatedPlanningId) {
+                        dispatch(planning.api.fetchById(updatedPlanningId, {force: true}));
                     }
                 }
 
@@ -89,9 +79,26 @@ const onPlanningUpdated = (_e: {}, data: IWebsocketMessageData['PLANNING_UPDATED
             promises.push(dispatch(fetchAgendas()));
         }
 
-        promises.push(dispatch(main.fetchItemHistory({_id: data.item, type: ITEM_TYPE.PLANNING})));
-        promises.push(dispatch(udpateAssignment(data.item)));
-        promises.push(dispatch(planning.featuredPlanning.getAndUpdateStoredPlanningItem(data.item)));
+        promises.push(dispatch(main.fetchItemHistory({_id: updatedPlanningId, type: ITEM_TYPE.PLANNING})));
+        promises.push(dispatch(udpateAssignment(updatedPlanningId)));
+        promises.push(dispatch(planning.featuredPlanning.getAndUpdateStoredPlanningItem(updatedPlanningId)));
+        promises.push(new Promise<void>((resolve) => {
+            const state: IPlanningAppState = getState();
+
+            if ( // check if websocket notification contains updates of items currently in store
+                state.planning.plannings[updatedPlanningId] != null
+                || (data.event_ids ?? []).some((id) => state.events.events[id] != null)
+            ) {
+                return planningApi.planning.getById(updatedPlanningId, true, true)
+                    .then((latestPlanning: IPlanningItem) => {
+                        planningApi.locks.reloadSoftLocksForRelatedEvents(latestPlanning);
+
+                        resolve();
+                    });
+            } else {
+                resolve();
+            }
+        }));
 
         return Promise.all(promises);
     }