@colijnit/sharedcomponents 261.1.0 → 261.1.2

package/projects/sharedcomponents/src/lib/components/files-upload/components/base-file-upload.component.ts

@@ -0,0 +1,549 @@
+import {
+    ComponentFactory,
+    ComponentFactoryResolver,
+    ComponentRef,
+    Directive,
+    EventEmitter,
+    HostBinding,
+    HostListener,
+    Input,
+    OnDestroy,
+    Output,
+    ViewContainerRef
+} from "@angular/core";
+import {ScreenConfigAdapterComponent} from "@colijnit/corecomponents_v12";
+import {Subscription} from "rxjs";
+import {TableName} from "../../../enum/table-name.enum";
+import {FileType} from "@colijnit/mainapi/build/enum/file-type.enum";
+import {
+    OperationCallbackSimpleFunction,
+    OperationWithAlwaysSuccessCallback
+} from "../../../interface/operation-callback-simple-function";
+import {InternalParam} from "../../../enum/internal-param.enum";
+import {FilesUploadConfigObjects} from "../../../enum/files-upload-config-objects";
+import {TagCategory} from "../../../enum/tag-category.enum";
+import {ArrayUtils} from "../../../utils/array-utils";
+import {RefCodeUtils} from "../../../utils/ref-code-utils";
+import {CoDocumentSharedFieldLogic} from "../../../utils/co-document-shared-field-logic";
+import {ObjectRightType} from "@colijnit/sharedapi/build/enum/object-right-type.enum";
+import {InputBoolean} from "../../../decorator/input-boolean.decorator";
+import {AppFileDropzoneComponent} from "../../app-file-dropzone/app-file-dropzone.component";
+import {FileUtils} from "@colijnit/mainapi/build/utils/file-utils";
+import {CoDocument} from "@colijnit/mainapi/build/model/co-document.bo";
+import {CoDocumentType} from "@colijnit/mainapi/build/enum/co-document-type.enum";
+import {FileUploadPopupComponent} from "../../file-upload-popup/file-upload-popup.component";
+import {SharedComponentsDictionaryService} from '../../../translation/shared-components-dictionary.service';
+import {CoDocumentRight} from '@colijnit/mainapi/build/model/co-document-right';
+
+
+
+// A base component that lets the user make a list of files from its device. Doesn't actually upload, but outputs chosen files as filesChanged.
+@Directive()
+export abstract class BaseFileUploadComponent implements ScreenConfigAdapterComponent, OnDestroy {
+    decimals: number;
+    forceReadonly: boolean;
+    maxLength: number;
+    objectConfigName: string;
+    redErrorBackground: boolean;
+    required: boolean;
+
+    // The fileType that the documents should be saved as, leave empty to automatically detect filetype. Also determines file picker filter
+    @Input()
+    public set fileType(value: FileType) {
+        if (value) {
+            this._fileType = value;
+            //TODO Documentdataloader fix
+            //this._coDocumentDataLoader.loadAllowedTypes().then(() => {this.handleAcceptedFileTypesLoaded(value)});
+        }
+    }
+
+    public get fileType(): FileType {
+        return this._fileType;
+    }
+
+    @Input()
+    public documents: CoDocument[] = [];
+
+    @Input()
+    public documentTable: TableName;
+
+    @Input()
+    public set documentKey(value: string) {
+        this._documentKey = value + ""; // force string
+    }
+
+    public get documentKey(): string {
+        return this._documentKey;
+    }
+
+    // The ability to drop files on the page
+    @Input()
+    public fullPageDrop: boolean = false;
+
+    // If user gets the ability of adding files.
+    @Input()
+    public canAdd: boolean = true;
+
+    @Input()
+    public dropMessage: string;
+
+    // Show add button
+    @Input()
+    public addWithButton: boolean = true;
+
+    // If user gets the ability of deleting files.
+    @Input()
+    public canDelete: boolean = true;
+
+    @Input()
+    @InputBoolean()
+    public noDragDropOrdering: boolean = false;
+
+    @Input()
+    @InputBoolean()
+    public set readonly(value: boolean) {
+        this._readonly = value;
+
+        if (this._popup && this._popup.instance) {
+            this._popup.instance.readonly = value;
+        }
+    }
+
+    public get readonly(): boolean {
+        return this._readonly;
+    }
+
+    @Input()
+    @InputBoolean()
+    public askBeforeDelete: boolean = true;
+
+    @Input()
+    @InputBoolean()
+    public resizeImages: boolean = false;
+
+    @Input()
+    public lockOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+    @Input()
+    public unlockOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+
+
+
+    @Input()
+    public beforeDeleteOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+    @Input()
+    public afterDeleteOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+    @Input()
+    public beforeCreateOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+    @Input()
+    public afterCreateOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+    @Input()
+    public beforeEditOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;
+
+    @Input()
+    @InputBoolean()
+    public dontAskBeforeDelete: boolean = false;
+
+    @Input()
+    @InputBoolean()
+    public noOwnDeleteOperation: boolean = false;
+
+    private _fileType: FileType;
+
+    @Input()
+    public set maxUploadSizeParam(value: InternalParam) {
+        if (value) {
+            this._setInternalParamObj(value);
+        }
+    }
+
+    @Input()
+    @InputBoolean()
+    public useWithoutSettingProps: boolean = false;
+
+    @Input()
+    public filesUploadConfigObjects: FilesUploadConfigObjects;
+
+    @Input()
+    @InputBoolean()
+    public medicalUserGroups: boolean = false;
+
+    @Input()
+    public tagCategory: TagCategory;
+
+    @Input()
+    public tagReferenceTable: TableName;
+
+    @Input()
+    @InputBoolean()
+    public displayReadWriteAccess: boolean;
+
+    // Use with customFileDropEvent
+    @Input() @InputBoolean()
+    public useCustomFileDropEvent: boolean = false;
+
+    // Use in conjunction with useCustomFileDropEvent
+    @Output()
+    public customFileDropEvent: EventEmitter<FileList> = new EventEmitter<FileList>();
+
+    // Emits if user wants to add multiple documents at once
+    @Output()
+    public readonly documentsAdded: EventEmitter<CoDocument[]> = new EventEmitter<CoDocument[]>();
+
+    @Output()
+    public readonly documentDeleted: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();
+
+    // Emits every time the order of documents was changed
+    @Output()
+    public readonly sortableListChanged: EventEmitter<CoDocument[]> = new EventEmitter<CoDocument[]>();
+
+    @Output()
+    public documentChangeEvent: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();
+
+    // Use this if consumer requires to perform extra actions, like locking a parent businessObject if it contains the collection of documents. Emit with true when popup opened, false for close
+    @Output()
+    public popupOpenedStateChange: EventEmitter<boolean> = new EventEmitter<boolean>();
+
+    @HostBinding("class.co-shared-hidden")
+    public hidden: boolean;
+
+    @HostListener("drop", ["$event"])
+    public onDrop(event: DragEvent): void {
+        event.preventDefault();
+        event.stopPropagation();
+
+        if (!this.useCustomFileDropEvent) {
+            this.filesPicked(event.dataTransfer.files);
+        } else {
+            this.customFileDropEvent.emit(event.dataTransfer.files);
+        }
+
+        this._clearDropzone();
+    }
+
+    @HostListener("dragend", ["$event"])
+    public onDragEnd(event: DragEvent): void {
+        event.dataTransfer.clearData();
+        this._clearDropzone();
+    }
+
+    @HostListener("dragover", ["$event"])
+    public onDragOver(event: DragEvent): void {
+        event.preventDefault();
+    }
+
+    @HostListener("dragenter", ["$event"])
+    public onDragEnter(event: DragEvent): void {
+        this._dragEnterTarget = event.target;
+        this._showDropzone();
+    }
+
+    @HostListener("dragleave", ["$event"])
+    public onDragLeave(event: DragEvent): void {
+        if (event.target === this._dragEnterTarget) {
+            this._clearDropzone();
+        }
+    }
+
+    public documentUnderEdit: CoDocument;
+    public acceptedUploadFormats: string;
+
+    protected _maxUploadFileSize: number;
+
+    private _dragEnterTarget: EventTarget;
+    private _documentKey: string = "";
+    private _dropZone: ComponentRef<AppFileDropzoneComponent>;
+    private _popup: ComponentRef<FileUploadPopupComponent>;
+    private _docChangeSub: Subscription;
+    private _popupCloseSub: Subscription;
+    private _readonly: boolean = false;
+
+    // private static readonly _dummyTrueFunction: OperationCallbackSimpleFunction = (object: any) => Promise.resolve(true);
+
+    constructor(
+
+        //protected _promptService: PromptService,
+        protected _dictionaryService: SharedComponentsDictionaryService,
+        //protected _userService: UserService,
+        protected _container: ViewContainerRef,
+        protected _factory: ComponentFactoryResolver,
+        //protected _generalDalRepository: GeneralDalRepository,
+        //protected _dataService: DataService,
+        //protected _baseDataDalRepository: BaseDataDalRepository,
+        //protected _coDocumentDataLoader: CoDocumentDataLoaderService
+    ) {
+
+    }
+
+    ngOnDestroy(): void {
+        this._clearDropzone();
+    }
+
+    private _showDropzone(): void {
+        if (!this._dropZone) {
+            const fact: ComponentFactory<AppFileDropzoneComponent> = this._factory.resolveComponentFactory(AppFileDropzoneComponent);
+            this._dropZone = this._container.createComponent(fact);
+            this._dropZone.instance.customDropActionMessage = this.dropMessage;
+        }
+    }
+
+    private _clearDropzone(): void {
+        this._container.clear();
+        if (this._dropZone) {
+            this._dropZone.destroy();
+            this._dropZone = undefined;
+        }
+    }
+
+    // Remove file from upload array.
+    public async handleDelete(file: CoDocument): Promise<boolean> {
+        let success: boolean = await this.beforeDeleteOperation(file);
+        try {
+            if (success) {
+                await this._delete(file);
+                success = true;
+            }
+        } finally {
+            await this.afterDeleteOperation(file);
+        }
+        return Promise.resolve(success);
+    }
+
+    private async _delete(file: CoDocument): Promise<void> {
+        let doDelete: boolean = true;
+        if (!this.dontAskBeforeDelete) {
+          //TODO make dialogService
+            //doDelete = await this._promptService.showYesNo("MESSAGE_DELETE_RECORD_QUESTION");
+        }
+        if (doDelete) {
+            if (!this.noOwnDeleteOperation) {
+                ArrayUtils.RemoveElement(file, this.documents);
+            }
+            this.documentDeleted.emit(file);
+        }
+    }
+
+    public handleSortingChange(docs: CoDocument[]): void {
+        this.sortableListChanged.emit(docs);
+    }
+
+    public async handleFileChange(event: any): Promise<void> {
+        if (event && event.target && event.target.files && event.target.files.length > 0) {
+            // check file sizes and extension
+            //Todo: fix this
+            //const allowedExtensions = await this._baseDataDalRepository.getAllowedExtensions();
+            let allFilesAreSmallEnough: boolean = true;
+            let allFilesHaveAllowedExtensions: boolean = true;
+            const sizeToCompare: number = this._maxUploadFileSize ? this._maxUploadFileSize : undefined;
+            const len: number = event.target.files.length;
+            for (let i: number = 0; i < len; i++) {
+                const uploadSizeAllowed = FileUtils.CheckMaxUploadSize(event.target.files[i], sizeToCompare);
+                if (!uploadSizeAllowed) {
+                    allFilesAreSmallEnough = false;
+                    break;
+                }
+                const extensionAllowed = true//FileUtils.CheckExtension(event.target.files[i], allowedExtensions);
+                if (!extensionAllowed) {
+                    allFilesHaveAllowedExtensions = false;
+                    break;
+                }
+            }
+
+            if (!allFilesAreSmallEnough) {
+              //TODO make dialogService
+                //this._promptService.showWarning(this._dictionaryService.get("FILE_TOO_LARGE_TO_UPLOAD", true, "" + [FileUtils.getMaxUploadSizeInMb(sizeToCompare)]));
+            } else if (!allFilesHaveAllowedExtensions) {
+                //const extensionsList = allowedExtensions.map(allowedExtension => allowedExtension.extension).sort().join(", ");
+                //this._promptService.showWarning(this._dictionaryService.get("FILE_HAS_DISALLOWED_EXTENSION", false, extensionsList));
+            } else {
+                const filesToAdd: CoDocument[] = await this.convertFilesIntoCoDocuments(event.target.files);
+
+                if (filesToAdd.length > 1) {
+                    this.documentsAdded.emit(filesToAdd);
+                } else {
+                    if (this.useWithoutSettingProps) {
+                        this.documentsAdded.next(filesToAdd);
+                    } else {
+                        this.documentUnderEdit = filesToAdd[0];
+                        this.openPopup();
+                    }
+                }
+            }
+        }
+    }
+
+    public async handleEditDocumentClick(docToEdit: CoDocument): Promise<void> {
+        this.documentUnderEdit = docToEdit;
+        const showPopup: boolean = await this.beforeEditOperation(docToEdit);
+        if (showPopup) {
+            this.openPopup();
+        }
+    }
+
+    public async openPopup(): Promise<void> {
+        this._createAndFillPopupInstance();
+
+        this._docChangeSub = this._popup.instance.documentChangeEvent.subscribe((doc: CoDocument) => {
+            this.documentChangeEvent.emit(doc);
+        });
+    }
+
+    public openPopupToAddDocumentByUrl(): void {
+        this._createDocumentToAddByUrl();
+        this._createAndFillPopupInstance(true);
+
+        this._docChangeSub = this._popup.instance.documentChangeEvent.subscribe((doc: CoDocument) => {
+            doc.fileName = doc.filePath;
+            this.documentChangeEvent.emit(doc);
+        });
+    }
+
+    private _createDocumentToAddByUrl(): void {
+        this.documentUnderEdit = new CoDocument();
+        this.documentUnderEdit.table = this.documentTable;
+        this.documentUnderEdit.key = this.documentKey;
+        this.documentUnderEdit.fileType = this.fileType;
+        this.documentUnderEdit.documentType = CoDocumentType.SaveAsLinkOnRandomLocation;
+        this.documentUnderEdit.pathIsUrl = true;
+        //TODO Fix user Input
+        //this.documentUnderEdit.creationUser = this._userService.userName.toUpperCase();
+        //this.documentUnderEdit.modifiedUser = this._userService.userName.toUpperCase();
+        this.documentUnderEdit.creationDate = new Date();
+        this.documentUnderEdit.modifiedDate = new Date();
+    }
+
+    private _createAndFillPopupInstance(addDocumentByUrl: boolean = false): void {
+        this.popupOpenedStateChange.emit(true);
+
+        const factory: ComponentFactory<FileUploadPopupComponent> = this._factory.resolveComponentFactory(FileUploadPopupComponent);
+
+        this._popup = this._container.createComponent(factory);
+
+        this._popup.instance.readonly = this._readonly;
+        this._popup.instance.addDocumentByUrl = addDocumentByUrl;
+        this._popup.instance.hasPublicAccessVisible = this.documentTable === TableName.Goods;
+        this._popup.instance.showDocumentReportPicker = (this.documentTable === TableName.Transactions || this.documentTable === TableName.TransactionLines);
+        this._popup.instance.documentUnderEdit = this.documentUnderEdit;
+        this._popup.instance.filesUploadConfigObjects = this.filesUploadConfigObjects;
+        this._popup.instance.medicalUserGroups = this.medicalUserGroups;
+        this._popup.instance.tagCategory = this.tagCategory;
+        this._popup.instance.displayReadWriteAccess = this.displayReadWriteAccess;
+        this._popup.instance.tagReferenceTable = this.tagReferenceTable;
+        this._popup.instance.publicationIds = RefCodeUtils.GetMultiRefCodeChoices(this.documentUnderEdit.publication);
+        this._popup.instance.storeGroupIds = this.documentUnderEdit.retailFormulas;
+
+        this._prepareFileRights();
+
+        this._popupCloseSub = this._popup.instance.popupCloseEvent.subscribe(() => {
+            this._unlockDocument();
+            this.popupOpenedStateChange.emit(false);
+            this._popupCloseSub.unsubscribe();
+            this._docChangeSub.unsubscribe();
+            this._popup.destroy();
+            this._popup = undefined;
+        });
+    }
+
+    protected async convertFilesIntoCoDocuments(files: FileList): Promise<CoDocument[]> {
+        const amountOfFiles: number = files.length;
+        const filesToAdd: CoDocument[] = [];
+
+        for (let i: number = 0; i < amountOfFiles; i++) {
+            const fileAsDocument: CoDocument = await this._getFileAsDocument(files[i]);
+            fileAsDocument.index = CoDocumentSharedFieldLogic.GenerateAvailableIndexNr(this.documents || []) + i;
+            filesToAdd.push(fileAsDocument);
+        }
+        return filesToAdd;
+    }
+
+    public async filesPicked(files: FileList): Promise<void> {
+        if (files && files.length) {
+            let allFilesAreValid: boolean = true;
+            const amountOfFiles: number = files.length;
+            for (let i: number = 0; i < amountOfFiles; i++) {
+                if (!FileUtils.CheckMaxUploadSize(files[i], this._maxUploadFileSize)) {
+                    allFilesAreValid = false;
+                    break;
+                }
+            }
+
+            if (!allFilesAreValid) {
+              //TODO make dialogService
+                //this._promptService.showWarning(this._dictionaryService.get("FILE_TOO_LARGE_TO_UPLOAD", true, "" + FileUtils.getMaxUploadSizeInMb(this._maxUploadFileSize).toString()));
+            } else {
+                const filesToAdd: CoDocument[] = await this.convertFilesIntoCoDocuments(files);
+
+                if (filesToAdd.length > 1 || this.useWithoutSettingProps) {
+                    this.documentsAdded.emit(filesToAdd);
+                } else {
+                    this.documentUnderEdit = filesToAdd[0]; // Setting docUnderEdit opens the popup window
+                    this.openPopup();
+                }
+            }
+        }
+    }
+
+    public handleAcceptedFileTypesLoaded(value: FileType): void {
+        //TODO fix loading
+        //this.acceptedUploadFormats = this._coDocumentDataLoader.getAllowedExtensionsForType(value);
+    }
+
+    private async _getFileAsDocument(file: File): Promise<CoDocument> {
+        const fileAsCoDocument: CoDocument = await FileUtils.ReadFileAsNewCoDocument(file, this.resizeImages);
+        // set some extra known fields for the codocument:
+        fileAsCoDocument.table = this.documentTable;
+        fileAsCoDocument.key = this.documentKey;
+        //TODO fix add users
+        //fileAsCoDocument.creationUser = this._userService.userName.toUpperCase();
+        //fileAsCoDocument.modifiedUser = this._userService.userName.toUpperCase();
+        fileAsCoDocument.creationDate = new Date();
+        fileAsCoDocument.modifiedDate = new Date();
+        fileAsCoDocument.fileType = this.fileType ? this.fileType : FileUtils.IsImageFile(file) ? FileType.Image : FileType.Document;
+
+        if (fileAsCoDocument) {
+            return fileAsCoDocument;
+        }
+    }
+
+    private async _setInternalParamObj(value: InternalParam): Promise<void> {
+        //TODO fix params
+        //const param: InternalParameterObject = await this._generalDalRepository.getInternalParamObject(value);
+        //this._maxUploadFileSize = isNaN(parseInt(param.value, 0)) ? undefined : parseInt(param.value, 0);
+    }
+
+    private async _lockDocument(): Promise<boolean> {
+        if (!this.documentUnderEdit.documentId) {
+            return true; // New document does not have an ID and therefore does not have to be locked
+        }
+
+        const lockOk: boolean = await this.lockOperation(CoDocument);
+        return lockOk;
+    }
+
+    private async _unlockDocument(): Promise<boolean> {
+      if (!this.documentUnderEdit.documentId) {
+        return true; // New document does not have an ID and therefore does not have to be locked
+      }
+
+      const unlockOk: boolean = await this.unlockOperation(CoDocument);
+      return unlockOk;
+    }
+
+    private _prepareFileRights(): void {
+        const len: number = this.documentUnderEdit.rights.length;
+        for (let i: number = 0; i < len; i++) {
+            const right: CoDocumentRight = this.documentUnderEdit.rights[i];
+            if (right.rightLevel === ObjectRightType.ReadWrite) {
+                this._popup.instance.userGroupsForWrite.push(right.userGroupId);
+            }
+            if (right.rightLevel === ObjectRightType.ReadOnly) {
+                this._popup.instance.userGroupsForRead.push(right.userGroupId);
+            }
+        }
+    }
+}

package/projects/sharedcomponents/src/lib/components/files-upload/components/drag-drop-container.component.ts

@@ -0,0 +1,131 @@
+import {
+  ElementRef,
+  Input,
+  Directive,
+  AfterViewInit,
+  OnDestroy,
+  Renderer2,
+  Output,
+  EventEmitter,
+  HostBinding
+} from "@angular/core";
+import {Subscription} from "rxjs";
+import {InputBoolean} from "../../../decorator/input-boolean.decorator";
+import {DragDropContainer} from "../../../businessobject/drag-drop-container";
+import {CoOrientation} from "@colijnit/corecomponents_v12";
+import {ArrayUtils} from "@colijnit/sharedapi/build/utils/array-utils";
+import {CoDropEvent} from "../../../event/co-drop-event";
+import {DragDropService} from "../../../service/drag-drop.service";
+
+@Directive({
+  selector: "drag-drop-container"
+})
+export class DragDropContainerComponent implements AfterViewInit, OnDestroy {
+
+    /**
+     * Model of list containing draggable items
+     */
+    @Input()
+    public sortableList: any[];
+
+    @Input()
+    @InputBoolean()
+    public handleSort: boolean = false;
+
+    @Input()
+    public set enabled(value: boolean) {
+        this._enabled = value;
+        this.handleEnabledChange();
+    }
+
+    /**
+     * Class of the handle to drag operations
+     */
+    @Input()
+    public dragHandle: string = "";
+
+    // Emits when the order of sortableList items changed after a drag-drop action.
+    @Output()
+    public sortingChange: EventEmitter<any[]> = new EventEmitter<any[]>();
+
+    @HostBinding("class.co-drag-drop-container")
+    public showClass: boolean = true;
+
+    private _container: DragDropContainer;
+    private _enabled: boolean = true;
+    private _handleOrderSub: Subscription;
+    private _initialized: boolean = false;
+
+    constructor(private _elementRef: ElementRef, private _renderer: Renderer2, private _dragDropService: DragDropService) {
+        this._dragDropService.renderer = this._renderer;
+        this._container = new DragDropContainer(_elementRef.nativeElement, CoOrientation.Vertical);
+    }
+
+    ngAfterViewInit(): void {
+        this._initialized = true;
+        this._createDragDrop();
+        if (this._initialized) {
+            this._updateEnableDisableContainer();
+        }
+    }
+
+    /**
+     * Cleanup...
+     */
+    ngOnDestroy(): void {
+        this._removeDragDrop();
+        this._elementRef = undefined;
+    }
+
+    public handleEnabledChange(): void {
+        if (!this._initialized) {
+            return;
+        }
+        if (this._enabled) {
+            this._dragDropService.enableContainer(this._container);
+            this._createDragDrop();
+        } else {
+            this._dragDropService.disableContainer(this._container);
+            this._removeDragDrop();
+            this._initialized = false;
+        }
+    }
+
+    private _createDragDrop(): void {
+        this._dragDropService.addContainer(this._container);
+        this._dragDropService.addDragHandle(this.dragHandle);
+        if (this.handleSort) { // subscribe drop event to be able to adapt the order of dropped items
+            this._handleOrderSub = this._dragDropService.drop.subscribe((event: CoDropEvent) => {
+                this._handleOrder(event.container, event.elementIndex, event.targetIndex);
+            });
+        }
+        this._initialized = true;
+    }
+
+    private _removeDragDrop(): void {
+        this._dragDropService.removeContainer(this._container);
+        this._dragDropService.removeDragHandle(this.dragHandle);
+        if (this._handleOrderSub) {
+            this._handleOrderSub.unsubscribe();
+        }
+    }
+
+    private _handleOrder(container: DragDropContainer, oldIndex: number, newIndex: number): void {
+        if (container !== this._container) {
+            return;
+        }
+        if (newIndex === -1) {
+            newIndex = this.sortableList.length;
+        }
+        ArrayUtils.MoveElement(this.sortableList[oldIndex], newIndex, this.sortableList);
+        this.sortingChange.emit(this.sortableList);
+    }
+
+    private _updateEnableDisableContainer(): void {
+        if (this._enabled) {
+            this._dragDropService.enableContainer(this._container);
+        } else {
+            this._dragDropService.disableContainer(this._container);
+        }
+    }
+}