@progress/kendo-angular-scheduler 3.0.3-dev.202204061046 → 4.0.0-dev.202204140813

package/esm2015/editing-directives/base-edit.service.js

@@ -0,0 +1,307 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { parseDate, formatDate } from '@progress/kendo-angular-intl';
+import { toLocalDate } from '@progress/kendo-date-math';
+import { BehaviorSubject } from 'rxjs';
+import { setter } from '../common/setter';
+import { getter } from '../common/getter';
+import { defaultModelFields } from '../common/default-model-fields';
+import { isRecurring, isException, isPresent, cloneTo, assignField } from '../common/util';
+const DATE_FORMATS = [
+    "yyyyMMddTHHmmssSSSXXX",
+    "yyyyMMddTHHmmssXXX",
+    "yyyyMMddTHHmmss",
+    "yyyyMMddTHHmm",
+    "yyyyMMddTHH",
+    "yyyyMMdd"
+];
+/**
+ * A base implementation of the [edit service]({% slug api_scheduler_editservice %}) which persists data to traditional CRUD services such as OData.
+ *
+ * To support custom models, the `BaseEditService` class requires a [field map]({% slug api_scheduler_schedulermodelfields %}) as a constructor parameter. Subclasses require you to
+ * implement the `read` operation, which is not called directly by the base class, and the [`save`]({% slug api_scheduler_baseeditservice %}#toc-save) method which persists the created,
+ * updated, and deleted entities.
+ *
+ * The [`events`](#toc-events) observable will publish the current data which is set upon subscription by using, for example, an [async pipe](https://angular.io/api/common/AsyncPipe)
+ * ([more information]({% slug editing_directives_scheduler %}#toc-custom-service)).
+ *
+ * Implementations which utilize dedicated services, such as Google Calendar and Microsoft Exchange, will typically implement the
+ * [`EditService`]({% slug api_scheduler_editservice %}) of the Scheduler directly.
+ *
+ * See example in [this article]({% slug custom_reactive_editing_scheduler %}).
+ */
+export class BaseEditService {
+    /**
+     * Initializes the base edit service.
+     *
+     * @param fields - A field map that will be used for reading and modifying model objects. Defaults to the [`SchedulerEvent`]({% slug api_scheduler_schedulerevent %}) fields.
+     */
+    constructor(fields) {
+        /**
+         * An array of the currently loaded events which is populated by the derived class.
+         */
+        this.data = [];
+        /**
+         * The source subject for the `events` observable.
+         */
+        this.source = new BehaviorSubject([]);
+        this.createdItems = [];
+        this.updatedItems = [];
+        this.deletedItems = [];
+        this.events = this.source.asObservable();
+        this.fields = Object.assign(Object.assign({}, defaultModelFields), fields);
+        this.getId = getter(this.fields.id);
+        this.getRecurrenceId = getter(this.fields.recurrenceId);
+        this.getRecurrenceRule = getter(this.fields.recurrenceRule);
+        this.getRecurrenceExceptions = getter(this.fields.recurrenceExceptions);
+        this.getStart = getter(this.fields.start);
+        this.setId = setter(this.fields.id);
+        this.setRecurrenceRule = setter(this.fields.recurrenceRule);
+        this.setRecurrenceExceptions = setter(this.fields.recurrenceExceptions);
+        this.setRecurrenceId = setter(this.fields.recurrenceId);
+    }
+    create(event) {
+        this.logCreate(event);
+        this.saveChanges();
+    }
+    /*
+     * Creates an exception to a recurring series.
+     *
+     * The `createException` method performs the following operations:
+     * * Adds the start date of the event to the `recurrenceExceptions` of the master event (recurrence head).
+     * * Creates a new event that stores the recurrence exception itself.
+     */
+    createException(event, value) {
+        const exception = this.buildException(value);
+        this.logRemoveOccurrence(event);
+        this.logCreate(exception);
+        this.saveChanges();
+    }
+    update(event, value) {
+        this.assignValues(event, value);
+        this.logUpdate(event);
+        this.saveChanges();
+    }
+    remove(event) {
+        this.logRemove(event);
+        this.saveChanges();
+    }
+    removeSeries(event) {
+        const id = this.getId(event);
+        const recurrenceId = this.getRecurrenceId(event);
+        const isHead = this.isRecurrenceHead(event);
+        this.removeItemAndExceptions(isHead ? id : recurrenceId);
+        this.saveChanges();
+    }
+    removeOccurrence(event) {
+        this.logRemoveOccurrence(event);
+        this.saveChanges();
+    }
+    /**
+     * Returns the master recurring event for a specified recurring event.
+     *
+     * @param event - An event from the recurrence series.
+     * @returns the master recurring event for the series.
+     */
+    findRecurrenceMaster(event) {
+        const id = this.getId(event);
+        const recurrenceId = this.getRecurrenceId(event);
+        const headId = this.isRecurrenceHead(event) ? id : recurrenceId;
+        const index = this.itemIndex(headId, this.data);
+        return this.data[index];
+    }
+    /**
+     * Checks if the event is part of the recurrence series.
+     *
+     * @param event - The event that will be checked.
+     * @returns `true` if the event is an occurrence, an exception, or a master event. Otherwise, returns `false`.
+     */
+    isRecurring(event) {
+        return isRecurring(event, this.fields);
+    }
+    /**
+     * Checks if the event is a recurrence exception.
+     *
+     * @param event - The event that will be checked.
+     * @returns `true` if the event is a unique event which belongs to a recurrence series. Otherwise, returns `false`.
+     */
+    isException(event) {
+        return isException(event, this.fields);
+    }
+    /**
+     * Returns a Boolean value which indicates if the event is new.
+     * If the `ID` field is defined, the default implementation returns `true`.
+     * Can be overridden to implement different conditions.
+     *
+     * @param event - The event that will be checked.
+     */
+    isNew(event) {
+        const id = this.getId(event);
+        return !isPresent(id);
+    }
+    /**
+     * Returns the next `ID` that will be used for new events.
+     * The default implementation returns `undefined`.
+     */
+    nextId() {
+        return undefined;
+    }
+    /**
+     * Copies values to the target model instance.
+     * To copy the top-level fields, the base implementation uses
+     * [`Object.assign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign).
+     * To copy nested fields, override `assignValues` and handle the model-specific cases.
+     *
+     * @param target - The target object that will receive the field values.
+     * @param source - The source object from which the fields will be read.
+     */
+    assignValues(target, source) {
+        cloneTo(source, target);
+    }
+    /**
+     * Clones an existing model object.
+     * To copy the top-level model fields, the base creates an empty object and calls [`assignValues`](#toc-assignvalues).
+     * To create models of the correct type, override `cloneEvent`.
+     *
+     * @param event - The model instance to copy.
+     * @returns TEvent - The new model instance.
+     */
+    cloneEvent(event) {
+        const result = {};
+        this.assignValues(result, event);
+        return result;
+    }
+    /**
+     * A utility method which parses recurrence exception dates in an ISO format.
+     *
+     * @example
+     * ```ts-no-run
+     *   const exdates = '20180614T060000Z;20180615T060000Z';
+     *   const result = super.parseExceptions(exdates);
+     *
+     *   // console.log(result);
+     *   // Array [ Date 2018-06-14T03:00:00.000Z, Date 2018-06-15T03:00:00.000Z ]
+     * ```
+     *
+     * @param value - A comma-separated list of ISO-formatted dates.
+     * @returns Date[] - The recurrence exceptions as local dates.
+     */
+    parseExceptions(value) {
+        if (!isPresent(value) || value === '') {
+            return [];
+        }
+        return value
+            .split(';')
+            .map(ex => parseDate(ex, DATE_FORMATS) || undefined);
+    }
+    /**
+     * A utility method which serializes recurrence exception dates in an ISO format.
+     *
+     * @example
+     * ```ts-no-run
+     *   const exdates = [ new Date(2018, 5, 14, 3, 0, 0), new Date(2018, 5, 15, 3, 0, 0) ];
+     *   const result = super.serializeExceptions(exdates);
+     *
+     *   // console.log(result);
+     *   // '20180614T060000Z;20180615T060000Z'
+     * ```
+     *
+     * @param value - An array of `Date` instances.
+     * @returns string - A comma-separated list of ISO-formatted dates.
+     */
+    serializeExceptions(exceptions) {
+        if (!exceptions || exceptions.length === 0) {
+            return '';
+        }
+        return exceptions.map(date => formatDate(toLocalDate(date), 'yyyyMMddTHHmmss') + 'Z').join(';');
+    }
+    reset() {
+        this.data = [];
+        this.deletedItems = [];
+        this.updatedItems = [];
+        this.createdItems = [];
+    }
+    itemIndex(id, items) {
+        for (let idx = 0; idx < items.length; idx++) {
+            if (this.getId(items[idx]) === id) {
+                return idx;
+            }
+        }
+        return -1;
+    }
+    buildException(item) {
+        const fields = this.fields;
+        const head = this.findRecurrenceMaster(item);
+        const copy = this.cloneEvent(item);
+        assignField(copy, head, fields.id);
+        this.setId(copy, this.nextId());
+        this.setRecurrenceRule(copy, undefined);
+        this.setRecurrenceId(copy, this.getId(head));
+        return copy;
+    }
+    isRecurrenceHead(item) {
+        const id = this.getId(item);
+        const recurrenceRule = this.getRecurrenceRule(item);
+        return !!(id && recurrenceRule);
+    }
+    logCreate(item) {
+        this.data = [...this.data, item];
+        this.source.next(this.data);
+        this.createdItems.push(item);
+    }
+    logUpdate(item) {
+        const id = this.getId(item);
+        if (!this.isNew(item)) {
+            const index = this.itemIndex(id, this.updatedItems);
+            if (index !== -1) {
+                this.updatedItems.splice(index, 1, item);
+            }
+            else {
+                this.updatedItems.push(item);
+            }
+        }
+        else {
+            const index = this.createdItems.indexOf(item);
+            this.createdItems.splice(index, 1, item);
+        }
+    }
+    logRemove(item) {
+        const id = this.getId(item);
+        let index = this.itemIndex(id, this.data);
+        this.data = this.data.filter((_, i) => i !== index);
+        this.source.next(this.data);
+        index = this.itemIndex(id, this.createdItems);
+        if (index >= 0) {
+            this.createdItems.splice(index, 1);
+        }
+        else {
+            this.deletedItems.push(item);
+        }
+        index = this.itemIndex(id, this.updatedItems);
+        if (index >= 0) {
+            this.updatedItems.splice(index, 1);
+        }
+    }
+    logRemoveOccurrence(event) {
+        const head = this.findRecurrenceMaster(event);
+        const exceptionDate = this.getStart(event);
+        const currentExceptions = this.getRecurrenceExceptions(head) || [];
+        this.setRecurrenceExceptions(head, [...currentExceptions, exceptionDate]);
+        this.logUpdate(head);
+    }
+    removeItemAndExceptions(itemId) {
+        this.deletedItems = this.deletedItems.concat(this.data.filter(ev => this.getRecurrenceId(ev) === itemId || this.getId(ev) === itemId));
+    }
+    hasChanges() {
+        return this.deletedItems.length + this.updatedItems.length + this.createdItems.length > 0;
+    }
+    saveChanges() {
+        if (!this.hasChanges()) {
+            return;
+        }
+        this.save(this.createdItems, this.updatedItems, this.deletedItems);
+        this.reset();
+    }
+}

package/esm2015/editing-directives/edit-service.interface.js

@@ -0,0 +1,5 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export {};

package/esm2015/editing-directives/editing-directive-base.js

@@ -0,0 +1,218 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Input, Output, EventEmitter, Directive } from '@angular/core';
+import { merge } from 'rxjs';
+import { LocalEditService } from './local-edit.service';
+import { AddEvent } from '../events';
+import { groupResources, assignValues, clone, setField, getField } from '../common/util';
+import { diff, areEqual, seriesDate } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../scheduler.component";
+import * as i2 from "../editing/local-data-changes.service";
+import * as i3 from "../editing/dialogs.service";
+/**
+ * @hidden
+ */
+export class EditingDirectiveBase {
+    constructor(scheduler, localDataChangesService, dialogsService) {
+        this.scheduler = scheduler;
+        this.localDataChangesService = localDataChangesService;
+        this.dialogsService = dialogsService;
+        /**
+         * Fires before the editing directive renders the **Add** dialog.
+         */
+        this.add = new EventEmitter();
+        /**
+         * Fires before the editing directive renders the **Edit** dialog.
+         */
+        this.edit = new EventEmitter();
+        this.defaultTitle = 'No title';
+        this.defaultEditService = this.createDefaultService();
+        this.scheduler.editable = true;
+    }
+    /**
+     * The edit service that will handle the editing operations.
+     */
+    set editService(value) {
+        this.userEditService = value;
+    }
+    get editService() {
+        return this.userEditService || this.defaultEditService;
+    }
+    /**
+     * @hidden
+     */
+    ngOnInit() {
+        this.subscriptions = merge(this.scheduler.slotDblClick, this.scheduler.create).subscribe(this.addHandler.bind(this));
+        this.subscriptions.add(this.scheduler.removeConfirmed.subscribe(this.removeHandler.bind(this)));
+        this.subscriptions.add(this.scheduler.cancel.subscribe(this.cancelHandler.bind(this)));
+        this.subscriptions.add(this.scheduler.resizeEndConfirmed.subscribe(this.resizeEndHandler.bind(this)));
+        this.subscriptions.add(this.scheduler.dragEndConfirmed.subscribe(this.dragEndHandler.bind(this)));
+    }
+    /**
+     * @hidden
+     */
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    createDefaultService() {
+        return new LocalEditService(this.scheduler, this.localDataChangesService);
+    }
+    addHandler(args) {
+        this.closeEditor();
+        if (!this.isEnabled('add')) {
+            return;
+        }
+        const fields = this.scheduler.modelFields;
+        const dataItem = {};
+        setField(dataItem, fields.start, args.start);
+        setField(dataItem, fields.end, args.end);
+        setField(dataItem, fields.isAllDay, args.isAllDay);
+        setField(dataItem, fields.title, args.title);
+        const resources = groupResources(this.scheduler.group, this.scheduler.resources);
+        const slotResources = args.resources;
+        for (let idx = 0; idx < resources.length; idx++) {
+            const resource = resources[idx];
+            const value = getField(slotResources[idx], resource.valueField);
+            setField(dataItem, resource.field, resource.multiple ? [value] : value);
+        }
+        const addArgs = new AddEvent(this.scheduler, { dataItem });
+        this.add.emit(addArgs);
+        if (!addArgs.isDefaultPrevented()) {
+            this.scheduler.addEvent(this.createModel({
+                action: 'add',
+                isNew: true,
+                dataItem
+            }));
+        }
+    }
+    removeHandler({ dataItem }) {
+        if (!this.isEnabled('remove')) {
+            return;
+        }
+        if (this.editService.isRecurring(dataItem)) {
+            this.dialogsService.openRecurringConfirmationDialog(1 /* Remove */)
+                .subscribe((editMode) => {
+                if (editMode !== undefined) {
+                    this.handleRemove(dataItem, editMode);
+                }
+            });
+        }
+        else {
+            this.dialogsService.openRemoveConfirmationDialog()
+                .subscribe((shouldRemove) => {
+                if (shouldRemove) {
+                    this.handleRemove(dataItem, 0 /* Event */);
+                }
+            });
+        }
+    }
+    cancelHandler() {
+        this.closeEditor();
+    }
+    closeEditor() {
+        this.scheduler.closeEvent();
+    }
+    handleUpdate(item, value, mode) {
+        const svc = this.editService;
+        if (mode === 1 /* Occurrence */) {
+            svc.isException(item) ?
+                svc.update(item, value) :
+                svc.createException(item, value);
+        }
+        else {
+            // Item is not recurring or we're editing the entire series
+            svc.update(item, value);
+        }
+    }
+    handleRemove(item, mode) {
+        const svc = this.editService;
+        if (mode === 2 /* Series */) {
+            svc.removeSeries(item);
+        }
+        else if (mode === 1 /* Occurrence */) {
+            svc.isException(item) ?
+                svc.remove(item) :
+                svc.removeOccurrence(item);
+        }
+        else {
+            // Item is not recurring
+            svc.remove(item);
+        }
+    }
+    resizeEndHandler({ event, start, end }) {
+        if (areEqual(start, event.start) && areEqual(end, event.end)) {
+            return;
+        }
+        const dataItem = event.dataItem;
+        const fields = this.scheduler.modelFields;
+        let value = {};
+        setField(value, fields.start, start);
+        setField(value, fields.end, end);
+        if (this.editService.isRecurring(dataItem)) {
+            this.dialogsService.openRecurringConfirmationDialog(0 /* Edit */)
+                .subscribe((result) => {
+                let target = dataItem;
+                if (result === 2 /* Series */) {
+                    target = this.editService.findRecurrenceMaster(dataItem);
+                    setField(value, fields.start, seriesDate(target, dataItem, value, fields.start));
+                    setField(value, fields.end, seriesDate(target, dataItem, value, fields.end));
+                }
+                else if (result !== undefined) {
+                    value = assignValues(clone(dataItem), value);
+                }
+                this.handleUpdate(target, value, result);
+            });
+        }
+        else {
+            this.editService.update(dataItem, value);
+        }
+    }
+    dragEndHandler({ event: { dataItem }, start, end, resources, isAllDay }) {
+        const modelFields = this.scheduler.modelFields;
+        const resourceFields = groupResources(this.scheduler.group, this.scheduler.resources).map(r => r.field);
+        const fields = [modelFields.start, modelFields.end, modelFields.isAllDay].concat(resourceFields);
+        let value = clone(resources);
+        setField(value, modelFields.start, start);
+        setField(value, modelFields.end, end);
+        setField(value, modelFields.isAllDay, isAllDay);
+        if (!diff(dataItem, value, fields)) {
+            return;
+        }
+        if (this.editService.isRecurring(dataItem)) {
+            this.dialogsService.openRecurringConfirmationDialog(0 /* Edit */)
+                .subscribe((result) => {
+                let target = dataItem;
+                if (result === 2 /* Series */) {
+                    target = this.editService.findRecurrenceMaster(dataItem);
+                    setField(value, modelFields.start, seriesDate(target, dataItem, value, modelFields.start));
+                    setField(value, modelFields.end, seriesDate(target, dataItem, value, modelFields.end));
+                }
+                else if (result !== undefined) {
+                    value = assignValues(clone(dataItem), value);
+                }
+                this.handleUpdate(target, value, result);
+            });
+        }
+        else {
+            this.editService.update(dataItem, value);
+        }
+    }
+    isEnabled(action) {
+        const editable = this.scheduler.editable;
+        return editable && editable[action] !== false;
+    }
+}
+EditingDirectiveBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: EditingDirectiveBase, deps: [{ token: i1.SchedulerComponent }, { token: i2.LocalDataChangesService }, { token: i3.DialogsService }], target: i0.ɵɵFactoryTarget.Directive });
+EditingDirectiveBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: EditingDirectiveBase, inputs: { editService: "editService" }, outputs: { add: "add", edit: "edit" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: EditingDirectiveBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.SchedulerComponent }, { type: i2.LocalDataChangesService }, { type: i3.DialogsService }]; }, propDecorators: { add: [{
+                type: Output
+            }], edit: [{
+                type: Output
+            }], editService: [{
+                type: Input
+            }] } });

package/esm2015/editing-directives/local-edit.service.js

@@ -0,0 +1,120 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { isPresent, isRecurring, isException, readEvent, getField, setField, assignValues, clone } from '../common/util';
+import { isDevMode } from '@angular/core';
+import { guid } from '@progress/kendo-angular-common';
+const isRecurrenceMaster = (ev) => !!(ev.id && ev.recurrenceRule);
+/**
+ * @hidden
+ */
+export class LocalEditService {
+    constructor(scheduler, localDataChangesService) {
+        this.scheduler = scheduler;
+        this.localDataChangesService = localDataChangesService;
+    }
+    get fields() {
+        return this.scheduler.modelFields;
+    }
+    get hasLocalData() {
+        return isPresent(this.localDataChangesService.data);
+    }
+    get data() {
+        if (this.hasLocalData) {
+            return this.localDataChangesService.data;
+        }
+        return this.scheduler.events;
+    }
+    create(item) {
+        const idField = this.fields.id;
+        const id = getField(item, idField);
+        if (!isPresent(id)) {
+            setField(item, idField, this.nextId());
+        }
+        this.data.push(item);
+        this.dataChanged();
+    }
+    createException(item, value) {
+        const exception = this.buildException(value);
+        this.removeOccurrenceInternal(item);
+        this.create(exception);
+    }
+    update(item, value) {
+        assignValues(item, value);
+        this.dataChanged();
+    }
+    remove(item) {
+        const idField = this.fields.id;
+        const itemId = getField(item, idField);
+        const data = this.data;
+        for (let idx = 0; idx < data.length; idx++) {
+            if (itemId === getField(data[idx], idField)) {
+                data.splice(idx, 1);
+                break;
+            }
+        }
+        this.dataChanged();
+    }
+    removeSeries(item) {
+        const event = readEvent(item, this.fields);
+        const isHead = isRecurrenceMaster(event);
+        this.removeItemAndExceptions(isHead ? event.id : event.recurrenceId);
+        this.dataChanged();
+    }
+    removeOccurrence(item) {
+        this.removeOccurrenceInternal(item);
+        this.dataChanged();
+    }
+    findRecurrenceMaster(item) {
+        const fields = this.scheduler.modelFields;
+        const event = readEvent(item, fields);
+        const headId = isRecurrenceMaster(event) ? event.id : event.recurrenceId;
+        return this.data.find((dataItem) => getField(dataItem, fields.id) === headId);
+    }
+    isRecurring(event) {
+        return isRecurring(event, this.scheduler.modelFields);
+    }
+    isException(event) {
+        return isException(event, this.scheduler.modelFields);
+    }
+    nextId() {
+        return guid();
+    }
+    buildException(item) {
+        const fields = this.fields;
+        const head = this.findRecurrenceMaster(item);
+        if (!head) {
+            if (isDevMode()) {
+                throw new Error('Unable to find recurrence head for event. Please check that recurrenceId is set and refers to an existing event.');
+            }
+            return;
+        }
+        const exception = clone(item);
+        setField(exception, fields.id, this.nextId());
+        setField(exception, fields.recurrenceId, getField(head, fields.id));
+        setField(exception, fields.recurrenceRule, null);
+        return exception;
+    }
+    removeItemAndExceptions(itemId) {
+        const data = this.data;
+        const fields = this.scheduler.modelFields;
+        for (let idx = data.length - 1; idx >= 0; idx--) {
+            if (itemId === getField(data[idx], fields.recurrenceId) || itemId === getField(data[idx], fields.id)) {
+                data.splice(idx, 1);
+            }
+        }
+    }
+    removeOccurrenceInternal(item) {
+        const fields = this.fields;
+        const head = this.findRecurrenceMaster(item);
+        const exceptionDate = getField(item, fields.start);
+        const currentExceptions = getField(head, fields.recurrenceExceptions) || [];
+        setField(head, fields.recurrenceExceptions, [...currentExceptions, exceptionDate]);
+    }
+    dataChanged() {
+        if (this.hasLocalData) {
+            this.localDataChangesService.changes.emit();
+        }
+    }
+}