New packages org (#2639)

New packages org

lib/content-services/document-list/components/content-action/content-action-list.component.spec.ts

@@ -0,0 +1,79 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { async, TestBed } from '@angular/core/testing';
+import { DataTableModule } from '@alfresco/core';
+import { MaterialModule } from '../../../material.module';
+import { DocumentListService } from '../../services/document-list.service';
+import { ContentActionModel } from './../../models/content-action.model';
+import { DocumentListComponent } from './../document-list.component';
+import { ContentActionListComponent } from './content-action-list.component';
+
+describe('ContentColumnList', () => {
+
+    let documentList: DocumentListComponent;
+    let actionList: ContentActionListComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                DataTableModule,
+                MaterialModule
+            ],
+            declarations: [
+                DocumentListComponent
+            ],
+            providers: [
+                DocumentListService
+            ],
+            schemas: [
+                CUSTOM_ELEMENTS_SCHEMA
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        documentList = (TestBed.createComponent(DocumentListComponent).componentInstance as DocumentListComponent);
+        actionList = new ContentActionListComponent(documentList);
+    });
+
+    it('should register action', () => {
+        spyOn(documentList.actions, 'push').and.callThrough();
+
+        let action = new ContentActionModel();
+        let result = actionList.registerAction(action);
+
+        expect(result).toBeTruthy();
+        expect(documentList.actions.push).toHaveBeenCalledWith(action);
+    });
+
+    it('should require document list instance to register action', () => {
+        actionList = new ContentActionListComponent(null);
+        let action = new ContentActionModel();
+        expect(actionList.registerAction(action)).toBeFalsy();
+    });
+
+    it('should require action instance to register', () => {
+        spyOn(documentList.actions, 'push').and.callThrough();
+        let result = actionList.registerAction(null);
+
+        expect(result).toBeFalsy();
+        expect(documentList.actions.push).not.toHaveBeenCalled();
+    });
+
+});

lib/content-services/document-list/components/content-action/content-action-list.component.ts

@@ -0,0 +1,45 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ /* tslint:disable:component-selector  */
+
+import { Component } from '@angular/core';
+
+import { ContentActionModel } from './../../models/content-action.model';
+import { DocumentListComponent } from './../document-list.component';
+
+@Component({
+    selector: 'content-actions',
+    template: ''
+})
+export class ContentActionListComponent {
+
+    constructor(private documentList: DocumentListComponent) {
+    }
+
+    /**
+     * Registers action handler within the parent document list component.
+     * @param action Action model to register.
+     */
+    registerAction(action: ContentActionModel): boolean {
+        if (this.documentList && action) {
+            this.documentList.actions.push(action);
+            return true;
+        }
+        return false;
+    }
+}

lib/content-services/document-list/components/content-action/content-action.component.spec.ts

@@ -0,0 +1,294 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { async, TestBed } from '@angular/core/testing';
+import { ContentService, TranslationService, NotificationService } from '@alfresco/core';
+import { DataTableModule } from '@alfresco/core';
+import { MaterialModule } from '../../../material.module';
+
+import { DocumentListService } from '../../services/document-list.service';
+import { FileNode } from '../../../mock';
+import { ContentActionHandler } from './../../models/content-action.model';
+import { DocumentActionsService } from './../../services/document-actions.service';
+import { FolderActionsService } from './../../services/folder-actions.service';
+import { NodeActionsService } from './../../services/node-actions.service';
+import { DocumentListComponent } from './../document-list.component';
+import { ContentActionListComponent } from './content-action-list.component';
+import { ContentActionComponent } from './content-action.component';
+
+describe('ContentAction', () => {
+
+    let documentList: DocumentListComponent;
+    let actionList: ContentActionListComponent;
+    let documentActions: DocumentActionsService;
+    let folderActions: FolderActionsService;
+
+    let contentService: ContentService;
+    let translateService: TranslationService;
+    let notificationService: NotificationService;
+    let nodeActionsService: NodeActionsService;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                DataTableModule,
+                MaterialModule
+            ],
+            providers: [
+                DocumentListService
+            ],
+            declarations: [
+                DocumentListComponent
+            ],
+            schemas: [
+                CUSTOM_ELEMENTS_SCHEMA
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        contentService = TestBed.get(ContentService);
+        translateService = <TranslationService> { addTranslationFolder: () => {}};
+        nodeActionsService = new NodeActionsService(null, null, null);
+        notificationService = new NotificationService(null);
+        documentActions = new DocumentActionsService(nodeActionsService);
+        folderActions = new FolderActionsService(nodeActionsService, null, contentService);
+
+        documentList = (TestBed.createComponent(DocumentListComponent).componentInstance as DocumentListComponent);
+        actionList = new ContentActionListComponent(documentList);
+    });
+
+    it('should register within parent actions list', () => {
+        spyOn(actionList, 'registerAction').and.stub();
+
+        let action = new ContentActionComponent(actionList, null, null);
+        action.ngOnInit();
+
+        expect(actionList.registerAction).toHaveBeenCalled();
+    });
+
+    it('should setup and register model', () => {
+        let action = new ContentActionComponent(actionList, null, null);
+        action.target = 'document';
+        action.title = '<title>';
+        action.icon = '<icon>';
+
+        expect(documentList.actions.length).toBe(0);
+        action.ngOnInit();
+
+        expect(documentList.actions.length).toBe(1);
+
+        let model = documentList.actions[0];
+        expect(model.target).toBe(action.target);
+        expect(model.title).toBe(action.title);
+        expect(model.icon).toBe(action.icon);
+    });
+
+    it('should get action handler from document actions service', () => {
+
+        let handler = function () {
+        };
+        spyOn(documentActions, 'getHandler').and.returnValue(handler);
+
+        let action = new ContentActionComponent(actionList, documentActions, null);
+        action.target = 'document';
+        action.handler = '<handler>';
+        action.ngOnInit();
+
+        expect(documentActions.getHandler).toHaveBeenCalledWith(action.handler);
+        expect(documentList.actions.length).toBe(1);
+
+        let model = documentList.actions[0];
+        expect(model.handler).toBe(handler);
+    });
+
+    it('should get action handler from folder actions service', () => {
+        let handler = function () {
+        };
+        spyOn(folderActions, 'getHandler').and.returnValue(handler);
+
+        let action = new ContentActionComponent(actionList, null, folderActions);
+        action.target = 'folder';
+        action.handler = '<handler>';
+        action.ngOnInit();
+
+        expect(folderActions.getHandler).toHaveBeenCalledWith(action.handler);
+        expect(documentList.actions.length).toBe(1);
+
+        let model = documentList.actions[0];
+        expect(model.handler).toBe(handler);
+    });
+
+    it('should require target to get system handler', () => {
+        spyOn(folderActions, 'getHandler').and.stub();
+        spyOn(documentActions, 'getHandler').and.stub();
+
+        let action = new ContentActionComponent(actionList, documentActions, folderActions);
+        action.handler = '<handler>';
+
+        action.ngOnInit();
+        expect(documentList.actions.length).toBe(1);
+        expect(folderActions.getHandler).not.toHaveBeenCalled();
+        expect(documentActions.getHandler).not.toHaveBeenCalled();
+
+        action.target = 'document';
+        action.ngOnInit();
+        expect(documentActions.getHandler).toHaveBeenCalled();
+
+        action.target = 'folder';
+        action.ngOnInit();
+        expect(folderActions.getHandler).toHaveBeenCalled();
+    });
+
+    it('should be case insensitive for document target', () => {
+        spyOn(documentActions, 'getHandler').and.stub();
+
+        let action = new ContentActionComponent(actionList, documentActions, null);
+        action.target = 'DoCuMeNt';
+        action.handler = '<handler>';
+
+        action.ngOnInit();
+        expect(documentActions.getHandler).toHaveBeenCalledWith(action.handler);
+    });
+
+    it('should be case insensitive for folder target', () => {
+        spyOn(folderActions, 'getHandler').and.stub();
+
+        let action = new ContentActionComponent(actionList, null, folderActions);
+        action.target = 'FoLdEr';
+        action.handler = '<handler>';
+
+        action.ngOnInit();
+        expect(folderActions.getHandler).toHaveBeenCalledWith(action.handler);
+    });
+
+    it('should use custom "execute" emitter', (done) => {
+        let emitter = new EventEmitter();
+
+        emitter.subscribe(e => {
+            expect(e.value).toBe('<obj>');
+            done();
+        });
+
+        let action = new ContentActionComponent(actionList, null, null);
+        action.target = 'document';
+        action.execute = emitter;
+
+        action.ngOnInit();
+        expect(documentList.actions.length).toBe(1);
+
+        let model = documentList.actions[0];
+        model.execute('<obj>');
+    });
+
+    it('should sync localizable fields with model', () => {
+
+        let action = new ContentActionComponent(actionList, null, null);
+        action.title = 'title1';
+        action.ngOnInit();
+
+        expect(action.model.title).toBe(action.title);
+
+        action.title = 'title2';
+        action.ngOnChanges(null);
+
+        expect(action.model.title).toBe('title2');
+    });
+
+    it('should not find document action handler with missing service', () => {
+        let action = new ContentActionComponent(actionList, null, null);
+        expect(action.getSystemHandler('document', 'name')).toBeNull();
+    });
+
+    it('should not find folder action handler with missing service', () => {
+        let action = new ContentActionComponent(actionList, null, null);
+        expect(action.getSystemHandler('folder', 'name')).toBeNull();
+    });
+
+    it('should find document action handler via service', () => {
+        let handler = <ContentActionHandler> function (obj: any, target?: any) {
+        };
+        let action = new ContentActionComponent(actionList, documentActions, null);
+        spyOn(documentActions, 'getHandler').and.returnValue(handler);
+        expect(action.getSystemHandler('document', 'name')).toBe(handler);
+    });
+
+    it('should find folder action handler via service', () => {
+        let handler = <ContentActionHandler> function (obj: any, target?: any) {
+        };
+        let action = new ContentActionComponent(actionList, null, folderActions);
+        spyOn(folderActions, 'getHandler').and.returnValue(handler);
+        expect(action.getSystemHandler('folder', 'name')).toBe(handler);
+    });
+
+    it('should not find actions for unknown target type', () => {
+        spyOn(folderActions, 'getHandler').and.stub();
+        spyOn(documentActions, 'getHandler').and.stub();
+
+        let action = new ContentActionComponent(actionList, documentActions, folderActions);
+
+        expect(action.getSystemHandler('unknown', 'name')).toBeNull();
+        expect(folderActions.getHandler).not.toHaveBeenCalled();
+        expect(documentActions.getHandler).not.toHaveBeenCalled();
+
+    });
+
+    it('should wire model with custom event handler', (done) => {
+        let action = new ContentActionComponent(actionList, documentActions, folderActions);
+        let file = new FileNode();
+
+        let handler = new EventEmitter();
+        handler.subscribe((e) => {
+            expect(e.value).toBe(file);
+            done();
+        });
+
+        action.execute = handler;
+
+        action.ngOnInit();
+        action.model.execute(file);
+    });
+
+    it('should allow registering model without handler', () => {
+        let action = new ContentActionComponent(actionList, documentActions, folderActions);
+
+        spyOn(actionList, 'registerAction').and.callThrough();
+        action.execute = null;
+        action.ngOnInit();
+
+        expect(action.model.handler).toBeUndefined();
+        expect(actionList.registerAction).toHaveBeenCalledWith(action.model);
+    });
+
+    it('should register on init', () => {
+        let action = new ContentActionComponent(actionList, null, null);
+        spyOn(action, 'register').and.callThrough();
+
+        action.ngOnInit();
+        expect(action.register).toHaveBeenCalled();
+    });
+
+    it('should require action list to register action with', () => {
+        let action = new ContentActionComponent(actionList, null, null);
+        expect(action.register()).toBeTruthy();
+
+        action = new ContentActionComponent(null, null, null);
+        expect(action.register()).toBeFalsy();
+    });
+});

lib/content-services/document-list/components/content-action/content-action.component.ts

@@ -0,0 +1,159 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ /* tslint:disable:component-selector  */
+
+import { Component, EventEmitter, Input, OnChanges, OnInit, Output } from '@angular/core';
+
+import { ContentActionHandler } from '../../models/content-action.model';
+import { DocumentActionsService } from '../../services/document-actions.service';
+import { FolderActionsService } from '../../services/folder-actions.service';
+import { ContentActionModel } from './../../models/content-action.model';
+import { ContentActionListComponent } from './content-action-list.component';
+
+@Component({
+    selector: 'content-action',
+    template: '',
+    providers: [
+        DocumentActionsService,
+        FolderActionsService
+    ]
+})
+export class ContentActionComponent implements OnInit, OnChanges {
+
+    @Input()
+    title: string = 'Action';
+
+    @Input()
+    icon: string;
+
+    @Input()
+    handler: string;
+
+    @Input()
+    target: string;
+
+    @Input()
+    permission: string;
+
+    @Input()
+    disableWithNoPermission: boolean;
+
+    @Input()
+    disabled: boolean = false;
+
+    @Output()
+    execute = new EventEmitter();
+
+    @Output()
+    permissionEvent = new EventEmitter();
+
+    @Output()
+    error = new EventEmitter();
+
+    @Output()
+    success = new EventEmitter();
+
+    model: ContentActionModel;
+
+    constructor(
+        private list: ContentActionListComponent,
+        private documentActions: DocumentActionsService,
+        private folderActions: FolderActionsService) {
+        this.model = new ContentActionModel();
+    }
+
+    ngOnInit() {
+        this.model = new ContentActionModel({
+            title: this.title,
+            icon: this.icon,
+            permission: this.permission,
+            disableWithNoPermission: this.disableWithNoPermission,
+            target: this.target,
+            disabled: this.disabled
+        });
+
+        if (this.handler) {
+            this.model.handler = this.getSystemHandler(this.target, this.handler);
+        }
+
+        if (this.execute) {
+            this.model.execute = (value: any): void => {
+                this.execute.emit({ value });
+            };
+        }
+
+        this.register();
+    }
+
+    register(): boolean {
+        if (this.list) {
+            return this.list.registerAction(this.model);
+        }
+        return false;
+    }
+
+    ngOnChanges(changes) {
+        // update localizable properties
+        this.model.title = this.title;
+    }
+
+    getSystemHandler(target: string, name: string): ContentActionHandler {
+        if (target) {
+            let ltarget = target.toLowerCase();
+
+            if (ltarget === 'document') {
+                if (this.documentActions) {
+                    this.documentActions.permissionEvent.subscribe((permision) => {
+                        this.permissionEvent.emit(permision);
+                    });
+
+                    this.documentActions.error.subscribe((errors) => {
+                        this.error.emit(errors);
+                    });
+
+                    this.documentActions.success.subscribe((message) => {
+                        this.success.emit(message);
+                    });
+
+                    return this.documentActions.getHandler(name);
+                }
+                return null;
+            }
+
+            if (ltarget === 'folder') {
+                if (this.folderActions) {
+                    this.folderActions.permissionEvent.subscribe((permision) => {
+                        this.permissionEvent.emit(permision);
+                    });
+
+                    this.folderActions.error.subscribe((errors) => {
+                        this.error.emit(errors);
+                    });
+
+                    this.folderActions.success.subscribe((message) => {
+                        this.success.emit(message);
+                    });
+
+                    return this.folderActions.getHandler(name);
+                }
+                return null;
+            }
+        }
+        return null;
+    }
+}

lib/content-services/document-list/components/content-column/content-column-list.component.spec.ts

@@ -0,0 +1,87 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { async, TestBed } from '@angular/core/testing';
+import { DataColumn, DataTableModule } from '@alfresco/core';
+import { MaterialModule } from '../../../material.module';
+
+import { LogService } from '@alfresco/core';
+import { DocumentListService } from '../../services/document-list.service';
+import { DocumentListComponent } from './../document-list.component';
+import { ContentColumnListComponent } from './content-column-list.component';
+
+describe('ContentColumnList', () => {
+
+    let documentList: DocumentListComponent;
+    let columnList: ContentColumnListComponent;
+    let logService: LogService;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                DataTableModule,
+                MaterialModule
+            ],
+            declarations: [
+                DocumentListComponent
+            ],
+            providers: [
+                DocumentListService,
+                LogService
+            ],
+            schemas: [
+                CUSTOM_ELEMENTS_SCHEMA
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        documentList = (TestBed.createComponent(DocumentListComponent).componentInstance as DocumentListComponent);
+        logService = TestBed.get(LogService);
+        columnList = new ContentColumnListComponent(documentList, logService);
+
+        documentList.ngOnInit();
+    });
+
+    it('should register column within parent document list', () => {
+        let columns = documentList.data.getColumns();
+        expect(columns.length).toBe(0);
+
+        let column = <DataColumn> {};
+        let result = columnList.registerColumn(column);
+
+        expect(result).toBeTruthy();
+        expect(columns.length).toBe(1);
+        expect(columns[0]).toBe(column);
+    });
+
+    it('should require document list instance to register action', () => {
+        columnList = new ContentColumnListComponent(null, logService);
+        let col = <DataColumn> {};
+        expect(columnList.registerColumn(col)).toBeFalsy();
+    });
+
+    it('should require action instance to register', () => {
+        spyOn(documentList.actions, 'push').and.callThrough();
+        let result = columnList.registerColumn(null);
+
+        expect(result).toBeFalsy();
+        expect(documentList.actions.push).not.toHaveBeenCalled();
+    });
+
+});

lib/content-services/document-list/components/content-column/content-column-list.component.ts

@@ -0,0 +1,48 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ /* tslint:disable:component-selector  */
+
+import { DataColumn } from '@alfresco/core';
+import { LogService } from '@alfresco/core';
+import { Component } from '@angular/core';
+
+import { DocumentListComponent } from './../document-list.component';
+
+@Component({
+    selector: 'content-columns',
+    template: ''
+})
+export class ContentColumnListComponent {
+
+    constructor(private documentList: DocumentListComponent, private logService: LogService ) {
+        this.logService.log('ContentColumnListComponent is deprecated starting with 1.7.0 and may be removed in future versions. Use DataColumnListComponent instead.');
+    }
+
+    /**
+     * Registers column model within the parent document list component.
+     * @param column Column definition model to register.
+     */
+    registerColumn(column: DataColumn): boolean {
+        if (this.documentList && column) {
+            let columns = this.documentList.data.getColumns();
+            columns.push(column);
+            return true;
+        }
+        return false;
+    }
+}

lib/content-services/document-list/components/content-column/content-column.component.spec.ts

@@ -0,0 +1,98 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { async, TestBed } from '@angular/core/testing';
+import { LogService } from '@alfresco/core';
+import { DataTableModule } from '@alfresco/core';
+import { MaterialModule } from '../../../material.module';
+import { DocumentListService } from '../../services/document-list.service';
+import { DocumentListComponent } from './../document-list.component';
+import { ContentColumnListComponent } from './content-column-list.component';
+import { ContentColumnComponent } from './content-column.component';
+
+describe('ContentColumn', () => {
+
+    let documentList: DocumentListComponent;
+    let columnList: ContentColumnListComponent;
+    let logService: LogService;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                DataTableModule,
+                MaterialModule
+            ],
+            declarations: [
+                DocumentListComponent
+            ],
+            providers: [
+                DocumentListService,
+                LogService
+            ],
+            schemas: [
+                CUSTOM_ELEMENTS_SCHEMA
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        documentList = (TestBed.createComponent(DocumentListComponent).componentInstance as DocumentListComponent);
+        logService = TestBed.get(LogService);
+        columnList = new ContentColumnListComponent(documentList, logService);
+
+        documentList.ngOnInit();
+    });
+
+    it('should register model within parent column list', () => {
+        spyOn(columnList, 'registerColumn').and.callThrough();
+
+        let column = new ContentColumnComponent(columnList, logService);
+        column.ngAfterContentInit();
+
+        expect(columnList.registerColumn).toHaveBeenCalled();
+
+        let columns = documentList.data.getColumns();
+        expect(columns.length).toBe(1);
+        expect(columns[0]).toBe(column);
+    });
+
+    it('should setup screen reader title for thumbnail column', () => {
+        let column = new ContentColumnComponent(columnList, logService);
+        column.key = '$thumbnail';
+        column.ngOnInit();
+
+        expect(column.srTitle).toBe('Thumbnail');
+    });
+
+    it('should register on init', () => {
+        let column = new ContentColumnComponent(columnList, logService);
+        spyOn(column, 'register').and.callThrough();
+
+        column.ngAfterContentInit();
+        expect(column.register).toHaveBeenCalled();
+    });
+
+    it('should require action list to register action with', () => {
+        let column = new ContentColumnComponent(columnList, logService);
+        expect(column.register()).toBeTruthy();
+
+        column = new ContentColumnComponent(null, logService);
+        expect(column.register()).toBeFalsy();
+    });
+
+});

lib/content-services/document-list/components/content-column/content-column.component.ts

@@ -0,0 +1,79 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ /* tslint:disable:component-selector  */
+
+import { DataColumn } from '@alfresco/core';
+import { LogService } from '@alfresco/core';
+import { AfterContentInit, Component, ContentChild, Input, OnInit, TemplateRef } from '@angular/core';
+
+import { ContentColumnListComponent } from './content-column-list.component';
+
+@Component({
+    selector: 'content-column',
+    template: ''
+})
+export class ContentColumnComponent implements OnInit, AfterContentInit, DataColumn {
+
+    @Input()
+    key: string;
+
+    @Input()
+    type: string = 'text';
+
+    @Input()
+    format: string;
+
+    @Input()
+    sortable: boolean = false;
+
+    @Input()
+    title: string = '';
+
+    @ContentChild(TemplateRef)
+    template: any;
+
+    /**
+     * Title to be used for screen readers.
+     */
+    @Input('sr-title')
+    srTitle: string;
+
+    @Input('class')
+    cssClass: string;
+
+    constructor(private list: ContentColumnListComponent, private logService: LogService) {
+        this.logService.log('ContentColumnComponent is deprecated starting with 1.7.0 and may be removed in future versions. Use DataColumnComponent instead.');
+    }
+
+    ngOnInit() {
+        if (!this.srTitle && this.key === '$thumbnail') {
+            this.srTitle = 'Thumbnail';
+        }
+    }
+
+    ngAfterContentInit() {
+        this.register();
+    }
+
+    register(): boolean {
+        if (this.list) {
+            return this.list.registerColumn(this);
+        }
+        return false;
+    }
+}

lib/content-services/document-list/components/document-list.component.html

@@ -0,0 +1,85 @@
+<adf-datatable
+    [selectionMode]="selectionMode"
+    [data]="data"
+    [actions]="contentActions"
+    [actionsPosition]="contentActionsPosition"
+    [multiselect]="multiselect"
+    [allowDropFiles]="allowDropFiles"
+    [contextMenu]="contextMenuActions"
+    [rowStyle]="rowStyle"
+    [rowStyleClass]="rowStyleClass"
+    [loading]="loading"
+    [noPermission]="noPermission"
+    [showHeader]="!isEmpty()"
+    (showRowContextMenu)="onShowRowContextMenu($event)"
+    (showRowActionsMenu)="onShowRowActionsMenu($event)"
+    (executeRowAction)="onExecuteRowAction($event)"
+    (rowClick)="onNodeClick($event.value?.node)"
+    (rowDblClick)="onNodeDblClick($event.value?.node)"
+    (row-select)="onNodeSelect($event.detail)"
+    (row-unselect)="onNodeUnselect($event.detail)">
+
+    <div *ngIf="!isEmptyTemplateDefined()">
+        <no-content-template>
+            <ng-template>
+                <adf-empty-list>
+                    <div class="adf-empty-list_template adf-empty-folder">
+                        <div class="adf-empty-folder-this-space-is-empty">{{'ADF-DOCUMENT-LIST.EMPTY.HEADER' | translate}}</div>
+                        <div fxHide.lt-md="true" class="adf-empty-folder-drag-drop">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate }}</div>
+                        <div fxHide.lt-md="true" class="adf-empty-folder-any-files-here-to-add">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.SUBTITLE' | translate }}</div>
+                        <img class="adf-empty-folder-image" [src]="emptyFolderImageUrl">
+                    </div>
+                    <!-- <div adf-empty-list-header class="adf-empty-list-header"> {{'ADF-DOCUMENT-LIST.EMPTY.HEADER' | translate}} </div> -->
+                </adf-empty-list>
+            </ng-template>
+        </no-content-template>
+    </div>
+
+    <div *ngIf="!isNoPermissionTemplateDefined()">
+        <no-permission-template>
+            <ng-template>
+                <div class="adf-no-permission__template">
+                    <mat-icon>ic_error</mat-icon>
+                    <p class="adf-no-permission__template--text">{{ 'ADF-DOCUMENT-LIST.NO_PERMISSION' | translate }}</p>
+                </div>
+            </ng-template>
+        </no-permission-template>
+    </div>
+
+    <div>
+        <loading-content-template>
+            <ng-template>
+                <div class="adf-document-list-loading-container">
+                    <mat-progress-spinner
+                        id="adf-document-list-loading"
+                        class="adf-document-list-loading-margin"
+                        [color]="'primary'"
+                        [mode]="'indeterminate'">
+                    </mat-progress-spinner>
+                </div>
+            </ng-template>
+        </loading-content-template>
+    </div>
+</adf-datatable>
+
+<ng-container *ngIf="isPaginationEnabled()">
+    <adf-pagination
+        *ngIf="isPaginationNeeded()"
+        class="adf-documentlist-pagination"
+        (changePageSize)="onChangePageSize($event)"
+        (changePageNumber)="onChangePageNumber($event)"
+        (nextPage)="onNextPage($event)"
+        (prevPage)="onPrevPage($event)"
+        [pagination]="pagination"
+        [supportedPageSizes]="supportedPageSizes">
+    </adf-pagination>
+
+    <adf-infinite-pagination
+        *ngIf="!isPaginationNeeded()"
+        [pagination]="pagination"
+        [pageSize]="pageSize"
+        [loading]="infiniteLoading"
+        (loadMore)="loadNextBatch($event)">
+            {{ 'ADF-DOCUMENT-LIST.LAYOUT.LOAD_MORE' | translate }}
+    </adf-infinite-pagination>
+</ng-container>

lib/content-services/document-list/components/document-list.component.scss

@@ -0,0 +1,133 @@
+@mixin adf-document-list-theme($theme) {
+    $foreground: map-get($theme, foreground);
+    $accent: map-get($theme, accent);
+
+    adf-datatable > table > tbody > tr.is-selected > td.adf-data-table-cell.adf-data-table-cell--image.image-table-cell > div > div > mat-icon > svg {
+        fill: mat-color($accent);
+        margin-top: -4px;
+        margin-left: -4px;
+        width: 32px;
+        height: 32px;
+    }
+
+    .document-list_empty_template {
+        text-align: center;
+        margin-top: 20px;
+        margin-bottom: 20px;
+    }
+
+    .document-list__this-space-is-empty {
+        height: 32px;
+        opacity: 0.26;
+        font-size: 24px;
+        line-height: 1.33;
+        letter-spacing: -1px;
+        color: mat-color($foreground, text);
+    }
+
+    .document-list__drag-drop {
+        height: 56px;
+        opacity: 0.54;
+        font-size: 56px;
+        line-height: 1;
+        letter-spacing: -2px;
+        color: mat-color($foreground, text);
+        margin-top: 40px;
+    }
+
+    .document-list__any-files-here-to-add {
+        height: 24px;
+        opacity: 0.54;
+        font-size: 16px;
+        line-height: 1.5;
+        letter-spacing: -0.4px;
+        color: mat-color($foreground, text)0;
+        margin-top: 17px;
+    }
+
+    .document-list__empty_doc_lib {
+        width: 565px;
+        height: 161px;
+        object-fit: contain;
+        margin-top: 17px;
+    }
+
+    .adf-document-list-loading-margin {
+        margin: auto;
+    }
+
+    .adf-document-list-loading-container {
+        min-height: 300px;
+        display: flex;
+        flex-direction: row;
+        height: 100%;
+    }
+
+    .adf-empty-list-header {
+        height: 32px;
+        opacity: 0.26 !important;
+        font-size: 24px;
+        line-height: 1.33;
+        letter-spacing: -1px;
+        color: mat-color($foreground, text);
+    }
+
+    .adf-documentlist-pagination {
+        color: mat-color($foreground, text);
+
+        .adf-pagination__block {
+            border-right: none;
+        }
+    }
+
+    .adf-empty-folder {
+
+        &-this-space-is-empty {
+            height: 32px;
+            opacity: 0.26;
+            font-size: 24px;
+            line-height: 1.33;
+            letter-spacing: -1px;
+            color: mat-color($foreground, text);
+        }
+
+        &-drag-drop {
+            min-height: 56px;
+            opacity: 0.54;
+            font-size: 53px;
+            line-height: 1;
+            letter-spacing: -2px;
+            color: mat-color($foreground, text);
+            margin-top: 40px;
+            word-break: break-all;
+            white-space: pre-line;
+
+            @media screen and ($mat-xsmall) {
+                font-size: 48px;
+            }
+        }
+
+        &-any-files-here-to-add {
+            min-height: 24px;
+            opacity: 0.54;
+            font-size: 16px;
+            line-height: 1.5;
+            letter-spacing: -0.4px;
+            color: mat-color($foreground, text);
+            margin-top: 17px;
+            word-break: break-all;
+            white-space: pre-line;
+        }
+
+        &-image {
+            width: 565px;
+            max-width: 100%;
+            object-fit: contain;
+            margin-top: 17px;
+
+            @media screen and ($mat-xsmall) {
+                width: 250px;
+            }
+        }
+    }
+}

lib/content-services/document-list/components/document-list.component.ts

@@ -0,0 +1,894 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    DataCellEvent,
+    DataColumn,
+    DataRowActionEvent,
+    DataSorting,
+    DataTableComponent,
+    ObjectDataColumn
+} from '@alfresco/core';
+import { AlfrescoApiService, AppConfigService, DataColumnListComponent, UserPreferencesService } from '@alfresco/core';
+import {
+    AfterContentInit, Component, ContentChild, ElementRef, EventEmitter, HostListener, Input, NgZone,
+    OnChanges, OnInit, Output, SimpleChanges, TemplateRef, ViewChild, ViewEncapsulation
+} from '@angular/core';
+import {
+    DeletedNodesPaging,
+    MinimalNodeEntity,
+    MinimalNodeEntryEntity,
+    NodePaging,
+    Pagination,
+    PersonEntry,
+    SitePaging
+} from 'alfresco-js-api';
+import { Observable, Subject } from 'rxjs/Rx';
+import { presetsDefaultModel } from '../models/preset.model';
+import { ImageResolver } from './../data/image-resolver.model';
+import { RowFilter } from './../data/row-filter.model';
+import { ShareDataRow } from './../data/share-data-row.model';
+import { ShareDataTableAdapter } from './../data/share-datatable-adapter';
+
+import { ContentActionModel } from './../models/content-action.model';
+import { PermissionStyleModel } from './../models/permissions-style.model';
+import { DocumentListService } from './../services/document-list.service';
+import { NodeEntityEvent, NodeEntryEvent } from './node.event';
+
+declare var require: any;
+
+export enum PaginationStrategy {
+    Finite,
+    Infinite
+}
+
+@Component({
+    selector: 'adf-document-list',
+    styleUrls: ['./document-list.component.scss'],
+    templateUrl: './document-list.component.html',
+    encapsulation: ViewEncapsulation.None
+})
+export class DocumentListComponent implements OnInit, OnChanges, AfterContentInit {
+
+    static SINGLE_CLICK_NAVIGATION: string = 'click';
+    static DOUBLE_CLICK_NAVIGATION: string = 'dblclick';
+    static DEFAULT_PAGE_SIZE: number = 20;
+
+    @ContentChild(DataColumnListComponent) columnList: DataColumnListComponent;
+
+    @Input()
+    permissionsStyle: PermissionStyleModel[] = [];
+
+    @Input()
+    locationFormat: string = '/';
+
+    @Input()
+    navigate: boolean = true;
+
+    @Input()
+    navigationMode: string = DocumentListComponent.DOUBLE_CLICK_NAVIGATION; // click|dblclick
+
+    @Input()
+    thumbnails: boolean = false;
+
+    @Input()
+    selectionMode: string = 'single'; // null|single|multiple
+
+    @Input()
+    multiselect: boolean = false;
+
+    @Input()
+    enablePagination: boolean = true;
+
+    @Input()
+    contentActions: boolean = false;
+
+    @Input()
+    contentActionsPosition: string = 'right'; // left|right
+
+    @Input()
+    contextMenuActions: boolean = false;
+
+    @Input()
+    pageSize: number = DocumentListComponent.DEFAULT_PAGE_SIZE;
+
+    @Input()
+    emptyFolderImageUrl: string = require('../../assets/images/empty_doc_lib.svg');
+
+    @Input()
+    allowDropFiles: boolean = false;
+
+    @Input()
+    sorting: string[];
+
+    @Input()
+    rowStyle: string;
+
+    @Input()
+    rowStyleClass: string;
+
+    @Input()
+    loading: boolean = false;
+
+    @Input()
+    paginationStrategy: PaginationStrategy = PaginationStrategy.Finite;
+
+    @Input()
+    supportedPageSizes: number[];
+
+    infiniteLoading: boolean = false;
+    noPermission: boolean = false;
+
+    selection = new Array<MinimalNodeEntity>();
+    skipCount: number = 0;
+    pagination: Pagination;
+
+    @Input()
+    rowFilter: RowFilter | null = null;
+
+    @Input()
+    imageResolver: ImageResolver | null = null;
+
+    // The identifier of a node. You can also use one of these well-known aliases: -my- | -shared- | -root-
+    @Input()
+    currentFolderId: string = null;
+
+    @Input()
+    folderNode: MinimalNodeEntryEntity = null;
+
+    @Input()
+    node: NodePaging = null;
+
+    @Output()
+    nodeClick: EventEmitter<NodeEntityEvent> = new EventEmitter<NodeEntityEvent>();
+
+    @Output()
+    nodeDblClick: EventEmitter<NodeEntityEvent> = new EventEmitter<NodeEntityEvent>();
+
+    @Output()
+    folderChange: EventEmitter<NodeEntryEvent> = new EventEmitter<NodeEntryEvent>();
+
+    @Output()
+    preview: EventEmitter<NodeEntityEvent> = new EventEmitter<NodeEntityEvent>();
+
+    @Output()
+    ready: EventEmitter<any> = new EventEmitter();
+
+    @Output()
+    error: EventEmitter<any> = new EventEmitter();
+
+    @ViewChild(DataTableComponent)
+    dataTable: DataTableComponent;
+
+    errorMessage;
+    actions: ContentActionModel[] = [];
+    emptyFolderTemplate: TemplateRef<any>;
+    noPermissionTemplate: TemplateRef<any>;
+    contextActionHandler: Subject<any> = new Subject();
+    data: ShareDataTableAdapter;
+
+    private layoutPresets = {};
+    private currentNodeAllowableOperations: string[] = [];
+    private CREATE_PERMISSION = 'create';
+    private defaultPageSizes = [5, 10, 15, 20];
+
+    constructor(private documentListService: DocumentListService,
+                private ngZone: NgZone,
+                private elementRef: ElementRef,
+                private apiService: AlfrescoApiService,
+                private appConfig: AppConfigService,
+                private preferences: UserPreferencesService) {
+        this.supportedPageSizes = appConfig.get('document-list.supportedPageSizes', this.defaultPageSizes);
+    }
+
+    getContextActions(node: MinimalNodeEntity) {
+        if (node && node.entry) {
+            let actions = this.getNodeActions(node);
+            if (actions && actions.length > 0) {
+                return actions.map((currentAction: ContentActionModel) => {
+                    return {
+                        model: currentAction,
+                        node: node,
+                        subject: this.contextActionHandler
+                    };
+                });
+            }
+        }
+        return null;
+    }
+
+    contextActionCallback(action) {
+        if (action) {
+            this.executeContentAction(action.node, action.model);
+        }
+    }
+
+    get hasCustomLayout(): boolean {
+        return this.columnList && this.columnList.columns && this.columnList.columns.length > 0;
+    }
+
+    getDefaultPageSize(): number {
+        let result = this.preferences.paginationSize;
+
+        const pageSizes = this.supportedPageSizes || this.defaultPageSizes;
+        if (pageSizes && pageSizes.length > 0 && pageSizes.indexOf(result) < 0) {
+            result = pageSizes[0];
+        }
+
+        return result;
+    }
+
+    ngOnInit() {
+        this.pageSize = this.getDefaultPageSize();
+        this.loadLayoutPresets();
+        this.data = new ShareDataTableAdapter(this.documentListService, null, this.getDefaultSorting());
+        this.data.thumbnails = this.thumbnails;
+        this.data.permissionsStyle = this.permissionsStyle;
+
+        if (this.rowFilter) {
+            this.data.setFilter(this.rowFilter);
+        }
+
+        if (this.imageResolver) {
+            this.data.setImageResolver(this.imageResolver);
+        }
+
+        this.contextActionHandler.subscribe(val => this.contextActionCallback(val));
+
+        this.enforceSingleClickNavigationForMobile();
+    }
+
+    ngAfterContentInit() {
+        let schema: DataColumn[] = [];
+
+        if (this.hasCustomLayout) {
+            schema = this.columnList.columns.map(c => <DataColumn> c);
+        }
+
+        if (!this.data) {
+            this.data = new ShareDataTableAdapter(this.documentListService, schema, this.getDefaultSorting());
+        } else if (schema && schema.length > 0) {
+            this.data.setColumns(schema);
+        }
+
+        let columns = this.data.getColumns();
+        if (!columns || columns.length === 0) {
+            this.setupDefaultColumns(this.currentFolderId);
+        }
+    }
+
+    ngOnChanges(changes: SimpleChanges) {
+        if (changes.folderNode && changes.folderNode.currentValue) {
+            this.loadFolder();
+        } else if (changes.currentFolderId && changes.currentFolderId.currentValue) {
+            if (changes.currentFolderId.previousValue !== changes.currentFolderId.currentValue) {
+                this.resetPagination();
+                this.folderNode = null;
+            }
+            if (!this.hasCustomLayout) {
+                this.setupDefaultColumns(changes.currentFolderId.currentValue);
+            }
+            this.loadFolderByNodeId(changes.currentFolderId.currentValue);
+        } else if (this.data) {
+            if (changes.node && changes.node.currentValue) {
+                this.resetSelection();
+                this.data.loadPage(changes.node.currentValue);
+            } else if (changes.rowFilter) {
+                this.data.setFilter(changes.rowFilter.currentValue);
+                if (this.currentFolderId) {
+                    this.loadFolderNodesByFolderNodeId(this.currentFolderId, this.pageSize, this.skipCount);
+                }
+            } else if (changes.imageResolver) {
+                this.data.setImageResolver(changes.imageResolver.currentValue);
+            }
+        }
+    }
+
+    reload(merge: boolean = false) {
+        this.ngZone.run(() => {
+            this.resetSelection();
+
+            if (this.folderNode) {
+                this.loadFolder(merge);
+            } else if (this.currentFolderId) {
+                this.loadFolderByNodeId(this.currentFolderId);
+            } else if (this.node) {
+                this.data.loadPage(this.node);
+                this.ready.emit();
+            }
+        });
+    }
+
+    isEmptyTemplateDefined(): boolean {
+        if (this.dataTable) {
+            if (this.emptyFolderTemplate) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    isNoPermissionTemplateDefined(): boolean {
+        if (this.dataTable) {
+            if (this.noPermissionTemplate) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    isMobile(): boolean {
+        return !!/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+    }
+
+    isEmpty() {
+        return !this.data || this.data.getRows().length === 0;
+    }
+
+    isPaginationEnabled() {
+        return this.enablePagination && !this.isEmpty();
+    }
+
+    isPaginationNeeded() {
+        return this.paginationStrategy === PaginationStrategy.Finite;
+    }
+
+    getNodeActions(node: MinimalNodeEntity | any): ContentActionModel[] {
+        let target = null;
+
+        if (node && node.entry) {
+            if (node.entry.isFile) {
+                target = 'document';
+            }
+
+            if (node.entry.isFolder) {
+                target = 'folder';
+            }
+
+            if (target) {
+                let ltarget = target.toLowerCase();
+                let actionsByTarget = this.actions.filter(entry => {
+                    return entry.target.toLowerCase() === ltarget;
+                }).map(action => new ContentActionModel(action));
+
+                actionsByTarget.forEach((action) => {
+                    this.checkPermission(node, action);
+                });
+
+                return actionsByTarget;
+            }
+        }
+
+        return [];
+    }
+
+    checkPermission(node: any, action: ContentActionModel): ContentActionModel {
+        if (action.permission) {
+            if (this.hasPermissions(node)) {
+                let permissions = node.entry.allowableOperations;
+                let findPermission = permissions.find(permission => permission === action.permission);
+                if (!findPermission && action.disableWithNoPermission === true) {
+                    action.disabled = true;
+                }
+            }
+        }
+        return action;
+    }
+
+    private hasPermissions(node: any): boolean {
+        return node.entry.allowableOperations ? true : false;
+    }
+
+    @HostListener('contextmenu', ['$event'])
+    onShowContextMenu(e?: Event) {
+        if (e && this.contextMenuActions) {
+            e.preventDefault();
+        }
+    }
+
+    performNavigation(node: MinimalNodeEntity): boolean {
+        if (this.canNavigateFolder(node)) {
+            this.currentFolderId = node.entry.id;
+            this.folderNode = node.entry;
+            this.skipCount = 0;
+            this.currentNodeAllowableOperations = node.entry['allowableOperations'] ? node.entry['allowableOperations'] : [];
+            this.loadFolder();
+            this.folderChange.emit(new NodeEntryEvent(node.entry));
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Invoked when executing content action for a document or folder.
+     * @param node Node to be the context of the execution.
+     * @param action Action to be executed against the context.
+     */
+    executeContentAction(node: MinimalNodeEntity, action: ContentActionModel) {
+        if (node && node.entry && action) {
+            let handlerSub;
+
+            if (typeof action.handler === 'function') {
+                handlerSub = action.handler(node, this, action.permission);
+            } else {
+                handlerSub = Observable.of(true);
+            }
+
+            if (typeof action.execute === 'function') {
+                handlerSub.subscribe(() => {
+                    action.execute(node);
+                });
+            }
+        }
+    }
+
+    loadFolder(merge: boolean = false) {
+        if (merge) {
+            this.infiniteLoading = true;
+        } else {
+            this.loading = true;
+        }
+
+        let nodeId = this.folderNode ? this.folderNode.id : this.currentFolderId;
+        if (nodeId) {
+            this.loadFolderNodesByFolderNodeId(nodeId, this.pageSize, this.skipCount, merge).catch(err => this.error.emit(err));
+        }
+    }
+
+    // gets folder node and its content
+    loadFolderByNodeId(nodeId: string) {
+        this.loading = true;
+        this.resetSelection();
+
+        if (nodeId === '-trashcan-') {
+            this.loadTrashcan();
+        } else if (nodeId === '-sharedlinks-') {
+            this.loadSharedLinks();
+        } else if (nodeId === '-sites-') {
+            this.loadSites();
+        } else if (nodeId === '-mysites-') {
+            this.loadMemberSites();
+        } else if (nodeId === '-favorites-') {
+            this.loadFavorites();
+        } else if (nodeId === '-recent-') {
+            this.loadRecent();
+        } else {
+            this.documentListService
+                .getFolderNode(nodeId)
+                .then(node => {
+                    this.folderNode = node;
+                    this.currentFolderId = node.id;
+                    this.skipCount = 0;
+                    this.currentNodeAllowableOperations = node['allowableOperations'] ? node['allowableOperations'] : [];
+                    return this.loadFolderNodesByFolderNodeId(node.id, this.pageSize, this.skipCount);
+                })
+                .catch(err => {
+                    if (JSON.parse(err.message).error.statusCode === 403) {
+                        this.loading = false;
+                        this.noPermission = true;
+                    }
+                    this.error.emit(err);
+                });
+        }
+    }
+
+    loadFolderNodesByFolderNodeId(id: string, maxItems: number, skipCount: number, merge: boolean = false): Promise<any> {
+        return new Promise((resolve, reject) => {
+            this.resetSelection();
+            this.documentListService
+                .getFolder(null, {
+                    maxItems: maxItems,
+                    skipCount: skipCount,
+                    rootFolderId: id
+                })
+                .subscribe(
+                    val => {
+                        if (this.isCurrentPageEmpty(val, skipCount)) {
+                            this.updateSkipCount(skipCount - maxItems);
+                            this.loadFolderNodesByFolderNodeId(id, maxItems, skipCount - maxItems).then(
+                                () => resolve(true),
+                                error => reject(error)
+                            );
+                        } else {
+                            this.data.loadPage(<NodePaging> val, merge);
+                            this.pagination = val.list.pagination;
+                            this.loading = false;
+                            this.infiniteLoading = false;
+                            this.ready.emit();
+                            resolve(true);
+                        }
+                    },
+                    error => {
+                        reject(error);
+                    });
+        });
+
+    }
+
+    resetSelection() {
+        this.dataTable.resetSelection();
+        this.selection = [];
+    }
+
+    resetPagination() {
+        this.skipCount = 0;
+    }
+
+    private loadTrashcan(): void {
+        const options = {
+            include: ['path', 'properties'],
+            maxItems: this.pageSize,
+            skipCount: this.skipCount
+        };
+        this.apiService.nodesApi.getDeletedNodes(options)
+            .then((page: DeletedNodesPaging) => this.onPageLoaded(page))
+            .catch(error => this.error.emit(error));
+    }
+
+    private loadSharedLinks(): void {
+        const options = {
+            include: ['properties', 'allowableOperations', 'path'],
+            maxItems: this.pageSize,
+            skipCount: this.skipCount
+        };
+        this.apiService.sharedLinksApi.findSharedLinks(options)
+            .then((page: NodePaging) => this.onPageLoaded(page))
+            .catch(error => this.error.emit(error));
+    }
+
+    private loadSites(): void {
+        const options = {
+            include: ['properties'],
+            maxItems: this.pageSize,
+            skipCount: this.skipCount
+        };
+
+        this.apiService.sitesApi.getSites(options)
+            .then((page: NodePaging) => this.onPageLoaded(page))
+            .catch(error => this.error.emit(error));
+    }
+
+    private loadMemberSites(): void {
+        const options = {
+            include: ['properties'],
+            maxItems: this.pageSize,
+            skipCount: this.skipCount
+        };
+
+        this.apiService.peopleApi.getSiteMembership('-me-', options)
+            .then((result: SitePaging) => {
+                let page: NodePaging = {
+                    list: {
+                        entries: result.list.entries
+                            .map(({ entry: { site } }: any) => ({
+                                entry: site
+                            })),
+                        pagination: result.list.pagination
+                    }
+                };
+
+                this.onPageLoaded(page);
+            })
+            .catch(error => this.error.emit(error));
+    }
+
+    private loadFavorites(): void {
+        const options = {
+            maxItems: this.pageSize,
+            skipCount: this.skipCount,
+            where: '(EXISTS(target/file) OR EXISTS(target/folder))',
+            include: ['properties', 'allowableOperations', 'path']
+        };
+
+        this.apiService.favoritesApi.getFavorites('-me-', options)
+            .then((result: NodePaging) => {
+                let page: NodePaging = {
+                    list: {
+                        entries: result.list.entries
+                            .map(({ entry: { target } }: any) => ({
+                                entry: target.file || target.folder
+                            }))
+                            .map(({ entry }: any) => {
+                                entry.properties = {
+                                    'cm:title': entry.title,
+                                    'cm:description': entry.description
+                                };
+                                return { entry };
+                            }),
+                        pagination: result.list.pagination
+                    }
+                };
+                this.onPageLoaded(page);
+            })
+            .catch(error => this.error.emit(error));
+    }
+
+    private loadRecent(): void {
+        this.apiService.peopleApi.getPerson('-me-')
+            .then((person: PersonEntry) => {
+                const username = person.entry.id;
+                const query = {
+                    query: {
+                        query: '*',
+                        language: 'afts'
+                    },
+                    filterQueries: [
+                        { query: `cm:modified:[NOW/DAY-30DAYS TO NOW/DAY+1DAY]` },
+                        { query: `cm:modifier:${username} OR cm:creator:${username}` },
+                        { query: `TYPE:"content" AND -TYPE:"app:filelink" AND -TYPE:"fm:post"` }
+                    ],
+                    include: ['path', 'properties', 'allowableOperations'],
+                    sort: [{
+                        type: 'FIELD',
+                        field: 'cm:modified',
+                        ascending: false
+                    }],
+                    paging: {
+                        maxItems: this.pageSize,
+                        skipCount: this.skipCount
+                    }
+                };
+
+                return this.apiService.searchApi.search(query);
+            })
+            .then((page: NodePaging) => this.onPageLoaded(page))
+            .catch(error => this.error.emit(error));
+    }
+
+    private onPageLoaded(page: NodePaging) {
+        if (page) {
+            this.data.loadPage(page);
+            this.pagination = page.list.pagination;
+            this.loading = false;
+            this.ready.emit();
+        }
+    }
+
+    private isCurrentPageEmpty(node, skipCount): boolean {
+        return !this.hasNodeEntries(node) && this.hasPages(skipCount);
+    }
+
+    private hasPages(skipCount): boolean {
+        return skipCount > 0 && this.isPaginationEnabled();
+    }
+
+    private hasNodeEntries(node): boolean {
+        return node && node.list && node.list.entries && node.list.entries.length > 0;
+    }
+
+    /**
+     * Creates a set of predefined columns.
+     */
+    setupDefaultColumns(preset: string = 'default'): void {
+        if (this.data) {
+            const columns = this.getLayoutPreset(preset);
+            this.data.setColumns(columns);
+        }
+    }
+
+    onPreviewFile(node: MinimalNodeEntity) {
+        if (node) {
+            this.preview.emit(new NodeEntityEvent(node));
+        }
+    }
+
+    onNodeClick(node: MinimalNodeEntity) {
+        const domEvent = new CustomEvent('node-click', {
+            detail: {
+                sender: this,
+                node: node
+            },
+            bubbles: true
+        });
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+
+        const event = new NodeEntityEvent(node);
+        this.nodeClick.emit(event);
+
+        if (!event.defaultPrevented) {
+            if (this.navigate && this.navigationMode === DocumentListComponent.SINGLE_CLICK_NAVIGATION) {
+                if (node && node.entry) {
+                    if (node.entry.isFile) {
+                        this.onPreviewFile(node);
+                    }
+
+                    if (node.entry.isFolder) {
+                        this.performNavigation(node);
+                    }
+                }
+            }
+        }
+    }
+
+    onNodeDblClick(node: MinimalNodeEntity) {
+        const domEvent = new CustomEvent('node-dblclick', {
+            detail: {
+                sender: this,
+                node: node
+            },
+            bubbles: true
+        });
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+
+        const event = new NodeEntityEvent(node);
+        this.nodeDblClick.emit(event);
+
+        if (!event.defaultPrevented) {
+            if (this.navigate && this.navigationMode === DocumentListComponent.DOUBLE_CLICK_NAVIGATION) {
+                if (node && node.entry) {
+                    if (node.entry.isFile) {
+                        this.onPreviewFile(node);
+                    }
+
+                    if (node.entry.isFolder) {
+                        this.performNavigation(node);
+                    }
+                }
+            }
+        }
+    }
+
+    onNodeSelect(event: { row: ShareDataRow, selection: Array<ShareDataRow> }) {
+        this.selection = event.selection.map(entry => entry.node);
+        const domEvent = new CustomEvent('node-select', {
+            detail: {
+                node: event.row.node,
+                selection: this.selection
+            },
+            bubbles: true
+        });
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+    }
+
+    onNodeUnselect(event: { row: ShareDataRow, selection: Array<ShareDataRow> }) {
+        this.selection = event.selection.map(entry => entry.node);
+        const domEvent = new CustomEvent('node-unselect', {
+            detail: {
+                node: event.row.node,
+                selection: this.selection
+            },
+            bubbles: true
+        });
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+    }
+
+    onShowRowContextMenu(event: DataCellEvent) {
+        if (this.contextMenuActions) {
+            let args = event.value;
+            let node = (<ShareDataRow> args.row).node;
+            if (node) {
+                args.actions = this.getContextActions(node) || [];
+            }
+        }
+    }
+
+    onShowRowActionsMenu(event: DataCellEvent) {
+        if (this.contentActions) {
+            let args = event.value;
+            let node = (<ShareDataRow> args.row).node;
+            if (node) {
+                args.actions = this.getNodeActions(node) || [];
+            }
+        }
+    }
+
+    onExecuteRowAction(event: DataRowActionEvent) {
+        if (this.contentActions) {
+            let args = event.value;
+            let node = (<ShareDataRow> args.row).node;
+            let action = (<ContentActionModel> args.action);
+            this.executeContentAction(node, action);
+        }
+    }
+
+    onChangePageSize(event: Pagination): void {
+        this.preferences.paginationSize = event.maxItems;
+        this.pageSize = event.maxItems;
+        this.skipCount = 0;
+        this.reload();
+    }
+
+    onChangePageNumber(page: Pagination): void {
+        this.pageSize = page.maxItems;
+        this.skipCount = page.skipCount;
+        this.reload();
+    }
+
+    onNextPage(event: Pagination): void {
+        this.skipCount = event.skipCount;
+        this.reload();
+    }
+
+    loadNextBatch(event: Pagination) {
+        this.skipCount = event.skipCount;
+        this.reload(true);
+    }
+
+    onPrevPage(event: Pagination): void {
+        this.skipCount = event.skipCount;
+        this.reload();
+    }
+
+    private enforceSingleClickNavigationForMobile(): void {
+        if (this.isMobile()) {
+            this.navigationMode = DocumentListComponent.SINGLE_CLICK_NAVIGATION;
+        }
+    }
+
+    private getDefaultSorting(): DataSorting {
+        let defaultSorting: DataSorting;
+        if (this.sorting) {
+            const [key, direction] = this.sorting;
+            defaultSorting = new DataSorting(key, direction);
+        }
+        return defaultSorting;
+    }
+
+    canNavigateFolder(node: MinimalNodeEntity): boolean {
+        if (this.isCustomSource(this.currentFolderId)) {
+            return false;
+        }
+
+        if (node && node.entry && node.entry.isFolder) {
+            return true;
+        }
+
+        return false;
+    }
+
+    isCustomSource(folderId: string): boolean {
+        const sources = ['-trashcan-', '-sharedlinks-', '-sites-', '-mysites-', '-favorites-', '-recent-'];
+
+        if (sources.indexOf(folderId) > -1) {
+            return true;
+        }
+
+        return false;
+    }
+
+    updateSkipCount(newSkipCount) {
+        this.skipCount = newSkipCount;
+    }
+
+    hasCurrentNodePermission(permission: string): boolean {
+        let hasPermission: boolean = false;
+        if (this.currentNodeAllowableOperations.length > 0) {
+            let permFound = this.currentNodeAllowableOperations.find(element => element === permission);
+            hasPermission = permFound ? true : false;
+        }
+        return hasPermission;
+    }
+
+    hasCreatePermission() {
+        return this.hasCurrentNodePermission(this.CREATE_PERMISSION);
+    }
+
+    private loadLayoutPresets(): void {
+        const externalSettings = this.appConfig.get('document-list.presets', null);
+
+        if (externalSettings) {
+            this.layoutPresets = Object.assign({}, presetsDefaultModel, externalSettings);
+        } else {
+            this.layoutPresets = presetsDefaultModel;
+        }
+
+    }
+
+    private getLayoutPreset(name: string = 'default'): DataColumn[] {
+        return (this.layoutPresets[name] || this.layoutPresets['default']).map(col => new ObjectDataColumn(col));
+    }
+}

lib/content-services/document-list/components/empty-folder/empty-folder-content.directive.spec.ts

@@ -0,0 +1,68 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { async, TestBed } from '@angular/core/testing';
+import { DataTableComponent, DataTableModule } from '@alfresco/core';
+import { MaterialModule } from '../../../material.module';
+import { DocumentListService } from '../../services/document-list.service';
+
+import { DocumentListComponent } from './../document-list.component';
+import { EmptyFolderContentDirective } from './empty-folder-content.directive';
+
+describe('EmptyFolderContent', () => {
+
+    let emptyFolderContent: EmptyFolderContentDirective;
+    let documentList: DocumentListComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                DataTableModule,
+                MaterialModule
+            ],
+            declarations: [
+                DocumentListComponent
+            ],
+            providers: [
+                DocumentListService
+            ],
+            schemas: [
+                CUSTOM_ELEMENTS_SCHEMA
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        documentList = (TestBed.createComponent(DocumentListComponent).componentInstance as DocumentListComponent);
+        documentList.dataTable = new DataTableComponent(null, null);
+        emptyFolderContent = new EmptyFolderContentDirective(documentList);
+    });
+
+    it('is defined', () => {
+        expect(emptyFolderContent).toBeDefined();
+    });
+
+    it('set template', () => {
+        emptyFolderContent.template = '<example>';
+
+        emptyFolderContent.ngAfterContentInit();
+
+        expect(emptyFolderContent.template).toBe(documentList.emptyFolderTemplate);
+        expect(emptyFolderContent.template).toBe(documentList.dataTable.noContentTemplate);
+    });
+});

lib/content-services/document-list/components/empty-folder/empty-folder-content.directive.ts

@@ -0,0 +1,36 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AfterContentInit, ContentChild, Directive, TemplateRef } from '@angular/core';
+import { DocumentListComponent } from './../document-list.component';
+
+@Directive({
+    selector: 'empty-folder-content'
+})
+export class EmptyFolderContentDirective implements AfterContentInit {
+
+    @ContentChild(TemplateRef)
+    template: any;
+
+    constructor(private documentList: DocumentListComponent) {
+    }
+
+    ngAfterContentInit() {
+        this.documentList.emptyFolderTemplate = this.template;
+        this.documentList.dataTable.noContentTemplate = this.template;
+    }
+}

lib/content-services/document-list/components/no-permission/no-permission-content.directive.spec.ts

@@ -0,0 +1,66 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { async, TestBed } from '@angular/core/testing';
+import { MatProgressSpinnerModule } from '@angular/material';
+import { DataTableComponent, DataTableModule } from '@alfresco/core';
+import { DocumentListService } from '../../services/document-list.service';
+import { MaterialModule } from '../../../material.module';
+
+import { DocumentListComponent } from './../document-list.component';
+import { NoPermissionContentDirective } from './no-permission-content.directive';
+
+describe('NoPermissionContentDirective', () => {
+
+    let noPermissionContent: NoPermissionContentDirective;
+    let documentList: DocumentListComponent;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                MaterialModule,
+                DataTableModule,
+                MatProgressSpinnerModule
+            ],
+            declarations: [
+                DocumentListComponent
+            ],
+            providers: [
+                DocumentListService
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        documentList = (TestBed.createComponent(DocumentListComponent).componentInstance as DocumentListComponent);
+        documentList.dataTable = new DataTableComponent(null, null);
+        noPermissionContent = new NoPermissionContentDirective(documentList);
+    });
+
+    it('should be defined', () => {
+        expect(noPermissionContent).toBeDefined();
+    });
+
+    it('should set template', () => {
+        noPermissionContent.template = '<example>';
+
+        noPermissionContent.ngAfterContentInit();
+
+        expect(noPermissionContent.template).toBe(documentList.noPermissionTemplate);
+        expect(noPermissionContent.template).toBe(documentList.dataTable.noPermissionTemplate);
+    });
+});

lib/content-services/document-list/components/no-permission/no-permission-content.directive.ts

@@ -0,0 +1,36 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AfterContentInit, ContentChild, Directive, TemplateRef } from '@angular/core';
+import { DocumentListComponent } from './../document-list.component';
+
+@Directive({
+    selector: 'no-permission-content'
+})
+export class NoPermissionContentDirective implements AfterContentInit {
+
+    @ContentChild(TemplateRef)
+    template: any;
+
+    constructor(private documentList: DocumentListComponent) {
+    }
+
+    ngAfterContentInit() {
+        this.documentList.noPermissionTemplate = this.template;
+        this.documentList.dataTable.noPermissionTemplate = this.template;
+    }
+}

lib/content-services/document-list/components/node.event.ts

@@ -0,0 +1,33 @@
+/*!
+ * @license
+ * Copyright 2016 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { BaseEvent } from '@alfresco/core';
+import { MinimalNodeEntity, MinimalNodeEntryEntity } from 'alfresco-js-api';
+
+export class NodeEntityEvent extends BaseEvent<MinimalNodeEntity> {
+    constructor(entity: MinimalNodeEntity) {
+        super();
+        this.value = entity;
+    }
+}
+
+export class NodeEntryEvent extends BaseEvent<MinimalNodeEntryEntity> {
+    constructor(entity: MinimalNodeEntryEntity) {
+        super();
+        this.value = entity;
+    }
+}