initial e2e integration (#329)

* e2e integration with ci

* update travis config

* try always build image

* build the app in production mode

* try to stop previous

* stop default postgresql service

* try upgrade selenium-webdriver

* disable Gecko for webdriver-manager

* use stable chrome and latest protractor

e2e/utilities/repo-client/apis/nodes/nodes-api.ts

@@ -0,0 +1,182 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2018 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { RepoApi } from '../repo-api';
+import { NodeBodyCreate, NODE_TYPE_FILE, NODE_TYPE_FOLDER } from './node-body-create';
+import { NodeContentTree, flattenNodeContentTree } from './node-content-tree';
+
+export class NodesApi extends RepoApi {
+    // nodes
+    getNodeByPath(relativePath: string = '/'): Promise<any> {
+        return this
+            .get(`/nodes/-my-`, { parameters: { relativePath } })
+            .catch(this.handleError);
+    }
+
+    getNodeById(id: string): Promise<any> {
+        return this
+            .get(`/nodes/${id}`)
+            .catch(this.handleError);
+    }
+
+    getNodeDescription(name: string, relativePath: string = '/') {
+        relativePath = (relativePath === '/')
+            ? `${name}`
+            : `${relativePath}/${name}`;
+
+        return this.getNodeByPath(`${relativePath}`)
+            .then(response => response.data.entry.properties['cm:description']);
+    }
+
+    deleteNodeById(id: string, permanent: boolean = true): Promise<any> {
+        return this
+            .delete(`/nodes/${id}?permanent=${permanent}`)
+            .catch(this.handleError);
+    }
+
+    deleteNodeByPath(path: string, permanent: boolean = true): Promise<any> {
+        return this
+            .getNodeByPath(path)
+            .then((response: any): string => response.data.entry.id)
+            .then((id: string): any => this.deleteNodeById(id, permanent))
+            .catch(this.handleError);
+    }
+
+    deleteNodes(names: string[], relativePath: string = '', permanent: boolean = true): Promise<any[]> {
+        return names.reduce((previous, current) => (
+            previous.then(() => this.deleteNodeByPath(`${relativePath}/${current}`, permanent))
+        ), Promise.resolve());
+    }
+
+    deleteNodesById(ids: string[], permanent: boolean = true): Promise<any[]> {
+        return ids.reduce((previous, current) => (
+            previous.then(() => this.deleteNodeById(current, permanent))
+        ), Promise.resolve());
+    }
+
+    // children
+    getNodeChildren(nodeId: string): Promise<any> {
+        return this
+            .get(`/nodes/${nodeId}/children`)
+            .catch(this.handleError);
+    }
+
+    createNode(nodeType: string, name: string, parentId: string = '-my-', title: string = '', description: string = ''): Promise<any> {
+        const data = {
+            name: name,
+            nodeType: nodeType,
+            properties: {
+                'cm:title': title, 'cm:description': description
+            }
+        };
+
+        return this
+            .post(`/nodes/${parentId}/children`, { data })
+            .catch(this.handleError);
+    }
+
+    createFile(name: string, parentId: string = '-my-', title: string = '', description: string = ''): Promise<any> {
+        return this.createNode('cm:content', name, parentId, title, description);
+    }
+
+    createFolder(name: string, parentId: string = '-my-', title: string = '', description: string = ''): Promise<any> {
+        return this.createNode('cm:folder', name, parentId, title, description);
+    }
+
+    createChildren(data: NodeBodyCreate[]): Promise<any> {
+        return this
+            .post(`/nodes/-my-/children`, { data })
+            .catch(this.handleError);
+    }
+
+    createContent(content: NodeContentTree, relativePath: string = '/'): Promise<any> {
+        return this.createChildren(flattenNodeContentTree(content, relativePath));
+    }
+
+    createFolders(names: string[], relativePath: string = '/'): Promise<any> {
+        return this.createContent({ folders: names }, relativePath);
+    }
+
+    createFiles(names: string[], relativePath: string = '/'): Promise<any> {
+        return this.createContent({ files: names }, relativePath);
+    }
+
+    // node content
+    getNodeContent(nodeId: string): Promise<any> {
+        return this
+            .get(`/nodes/${nodeId}/content`)
+            .catch(this.handleError);
+    }
+
+    editNodeContent(nodeId: string, content: string): Promise<any> {
+        return this
+            .put(`/nodes/${nodeId}/content`, { data: content })
+            .catch(this.handleError);
+    }
+
+    renameNode(nodeId: string, newName: string): Promise<any> {
+        return this
+            .put(`/nodes/${nodeId}`, { data: { name: newName } })
+            .catch(this.handleError);
+    }
+
+    // node permissions
+    setGranularPermission(nodeId: string, inheritPermissions: boolean = false, username: string, role: string): Promise<any> {
+        const data = {
+            permissions: {
+                isInheritanceEnabled: inheritPermissions,
+                locallySet: [
+                    {
+                        authorityId: username,
+                        name: role
+                    }
+                ]
+            }
+        };
+
+        return this
+            .put(`/nodes/${nodeId}`, { data })
+            .catch(this.handleError);
+    }
+
+    getNodePermissions(nodeId: string): Promise<any> {
+        return this
+            .get(`/nodes/${nodeId}?include=permissions`)
+            .catch(this.handleError);
+    }
+
+    // lock node
+    lockFile(nodeId: string, lockType: string = 'FULL') {
+        return this
+            .post(`/nodes/${nodeId}/lock?include=isLocked`, { data: { 'type': lockType } })
+            .catch(this.handleError);
+    }
+
+    unlockFile(nodeId: string) {
+        return this
+            .post(`/nodes/${nodeId}/unlock`)
+            .catch(this.handleError);
+    }
+}