Implemented the method 'addResourceTree' in the server class to make the resource tree creation easier

Author: AdrienCastex

lib/server/WebDAVServer.d.ts

@@ -9,6 +9,13 @@ import { FSManager, FSPath } from '../manager/FSManager';
 import { IUserManager } from '../user/IUserManager';
 import * as http from 'http';
 export { WebDAVServerOptions } from './WebDAVServerOptions';
+export interface IResourceTreeNode {
+    r?: IResource;
+    resource?: IResource;
+    c?: ResourceTreeNode[];
+    children?: ResourceTreeNode[];
+}
+export declare type ResourceTreeNode = IResourceTreeNode | IResource | IResourceTreeNode[] | IResource[];
 export declare class WebDAVServer {
     httpAuthentication: HTTPAuthentication;
     privilegeManager: IPrivilegeManager;
@@ -23,6 +30,8 @@ export declare class WebDAVServer {
     constructor(options?: WebDAVServerOptions);
     getResourceFromPath(path: FSPath | string[] | string, callback: ReturnCallback<IResource>): any;
     getResourceFromPath(path: FSPath | string[] | string, rootResource: IResource, callback: ReturnCallback<IResource>): any;
+    addResourceTree(resoureceTree: ResourceTreeNode, callback: (e: Error) => void): any;
+    addResourceTree(rootResource: IResource, resoureceTree: ResourceTreeNode, callback: (e: Error) => void): any;
     onUnknownMethod(unknownMethod: WebDAVRequest): void;
     start(port?: number): void;
     stop(callback: () => void): void;

lib/server/WebDAVServer.js

@@ -74,6 +74,78 @@ var WebDAVServer = (function () {
             }
         });
     };
+    WebDAVServer.prototype.addResourceTree = function (_rootResource, _resoureceTree, _callback) {
+        var _this = this;
+        var rootResource;
+        var resoureceTree;
+        var callback = _callback;
+        if (!callback) {
+            resoureceTree = _rootResource;
+            rootResource = this.rootResource;
+            callback = _resoureceTree;
+        }
+        else {
+            resoureceTree = _resoureceTree;
+            rootResource = _rootResource;
+        }
+        if (resoureceTree.constructor === Array) {
+            var array = resoureceTree;
+            if (array.length === 0) {
+                callback(null);
+                return;
+            }
+            var nb_1 = array.length;
+            var doneArray_1 = function (e) {
+                if (nb_1 <= 0)
+                    return;
+                if (e) {
+                    nb_1 = -1;
+                    callback(e);
+                    return;
+                }
+                --nb_1;
+                if (nb_1 === 0)
+                    callback(null);
+            };
+            array.forEach(function (r) { return _this.addResourceTree(rootResource, r, doneArray_1); });
+        }
+        else if (resoureceTree.fsManager) {
+            rootResource.addChild(resoureceTree, callback);
+        }
+        else {
+            var irtn = resoureceTree;
+            var resource_1 = irtn.r ? irtn.r : irtn.resource;
+            var children_1 = irtn.c ? irtn.c : irtn.children;
+            rootResource.addChild(resource_1, function (e) {
+                if (e) {
+                    callback(e);
+                    return;
+                }
+                if (children_1 && children_1.constructor !== Array) {
+                    _this.addResourceTree(resource_1, children_1, callback);
+                    return;
+                }
+                if (!children_1 || children_1.length === 0) {
+                    callback(null);
+                    return;
+                }
+                var nb = children_1.length;
+                function done(e) {
+                    if (nb <= 0)
+                        return;
+                    if (e) {
+                        nb = -1;
+                        callback(e);
+                        return;
+                    }
+                    --nb;
+                    if (nb === 0)
+                        callback(null);
+                }
+                children_1.forEach(function (c) { return _this.addResourceTree(resource_1, c, done); });
+            });
+        }
+    };
     WebDAVServer.prototype.onUnknownMethod = function (unknownMethod) {
         this.unknownMethod = unknownMethod;
     };

src/server/WebDAVServer.ts

@@ -15,6 +15,15 @@ import * as http from 'http'
 
 export { WebDAVServerOptions } from './WebDAVServerOptions'
 
+export interface IResourceTreeNode
+{
+    r ?: IResource
+    resource ?: IResource
+    c ?: ResourceTreeNode[]
+    children ?: ResourceTreeNode[]
+}
+export type ResourceTreeNode = IResourceTreeNode | IResource | IResourceTreeNode[] | IResource[];
+
 export class WebDAVServer
 {
     public httpAuthentication : HTTPAuthentication
@@ -115,6 +124,102 @@ export class WebDAVServer
         })
     }
 
+    addResourceTree(resoureceTree : ResourceTreeNode, callback : (e : Error) => void)
+    addResourceTree(rootResource : IResource, resoureceTree : ResourceTreeNode, callback : (e : Error) => void)
+    addResourceTree(_rootResource : IResource | ResourceTreeNode, _resoureceTree : ResourceTreeNode | (() => void), _callback ?: (e : Error) => void)
+    {
+        let rootResource : IResource
+        let resoureceTree : ResourceTreeNode
+        let callback = _callback;
+
+        if(!callback)
+        {
+            resoureceTree = _rootResource;
+            rootResource = this.rootResource;
+            callback = _resoureceTree as (e : Error) => void;
+        }
+        else
+        {
+            resoureceTree = _resoureceTree;
+            rootResource = _rootResource as IResource;
+        }
+
+        if(resoureceTree.constructor === Array)
+        {
+            const array = resoureceTree as any[];
+            if(array.length === 0)
+            {
+                callback(null);
+                return;
+            }
+
+            let nb = array.length;
+            const doneArray = function(e)
+            {
+                if(nb <= 0)
+                    return;
+                if(e)
+                {
+                    nb = -1;
+                    callback(e);
+                    return;
+                }
+                --nb;
+                if(nb === 0)
+                    callback(null);
+            }
+
+            array.forEach((r) => this.addResourceTree(rootResource, r, doneArray));
+        }
+        else if((resoureceTree as IResource).fsManager)
+        { // resoureceTree is IResource
+            rootResource.addChild(resoureceTree as IResource, callback);
+        }
+        else
+        { // resoureceTree is IResourceTreeNode
+            const irtn = resoureceTree as IResourceTreeNode;
+            const resource = irtn.r ? irtn.r : irtn.resource;
+            const children = irtn.c ? irtn.c : irtn.children;
+            rootResource.addChild(resource, (e) => {
+                if(e)
+                {
+                    callback(e);
+                    return;
+                }
+
+                if(children && children.constructor !== Array)
+                {
+                    this.addResourceTree(resource, children, callback)
+                    return;
+                }
+
+                if(!children || children.length === 0)
+                {
+                    callback(null);
+                    return;
+                }
+
+                let nb = children.length;
+                function done(e)
+                {
+                    if(nb <= 0)
+                        return;
+                    if(e)
+                    {
+                        nb = -1;
+                        callback(e);
+                        return;
+                    }
+                    --nb;
+                    if(nb === 0)
+                        callback(null);
+                }
+
+                children.forEach((c) => this.addResourceTree(resource, c, done));
+            })
+        }
+    }
+
     onUnknownMethod(unknownMethod : WebDAVRequest)
     {
         this.unknownMethod = unknownMethod;