webdav.client 5.20.5664

package/README.md

@@ -0,0 +1,98 @@
+# IT Hit WebDAV AJAX Library
+
+[Product Website](https://www.webdavsystem.com/ajax/) |
+[Demo Server](https://www.webdavserver.com/)
+
+
+## Cross-browser JavaScript library for opening documents from a web page and managing WebDAV servers.
+
+
+### API for Opening Docs from a Web Page
+
+Using WebDAV Ajax Library you can open documents from a web page and save back directly to server without download/upload steps. The library opens any document with associated application in Chrome, FireFox, Safari, Edge and IE on Windows, Mac OS X and Linux.
+
+```html
+<script src="ITHitWebDAVClient.js"></script>
+
+<script type="text/javascript">
+   
+    // Get your license ID here: https://www.webdavsystem.com/ajax/download/
+    ITHit.WebDAV.Client.LicenseId = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX';
+
+    function edit() {
+        ITHit.WebDAV.Client.DocManager.EditDocument(
+		    "https://server/folder/file.docx", "/");
+    }
+</script>
+
+<input type="button" value="Edit Document" onclick="edit()" />
+```
+[more...](https://www.webdavsystem.com/ajax/programming/open-doc-webpage/opening_ms_office_docs/)
+
+### Opening Document from a Website with Cookies Authentication 
+
+The library can open documents from a WebDAV server with cookies authentication: 
+
+```javascript
+function edit() {
+    ITHit.WebDAV.Client.DocManager.DavProtocolEditDocument(
+        'https://server/folder/file.ext', // Document URL(s)
+        'https://server/',                // Mount URL
+        protocolInstallMessage,           // Function to call if protocol app is not installed
+        null,                             // Reserved
+        'Current',                        // Which browser to copy cookies from: 'Current', 'All', 'None'
+        '.AspNet.ApplicationCookie',      // Cookie(s) to copy. Must be persistent.
+        '/Account/Login',                 // URL to navigate to if any cookie from the list is not found.
+        'Edit'                            // Command to execute: 'Edit', 'OpenWith', 'Print'
+    );
+}
+     
+function protocolInstallMessage(message) {
+    var installerFilePath = "/Plugins/" + ITHit.WebDAV.Client.DocManager.GetInstallFileName();
+ 
+    if (confirm("Opening this type of file requires a protocol installation. Select OK to download the protocol installer.")){
+        window.open(installerFilePath);
+    }
+}
+```
+[more...](https://www.webdavsystem.com/ajax/programming/open-doc-webpage/cookies-authentication/)
+
+### Using Ajax API for Managing WebDAV Server
+
+The library provides a high-level JavaScript API for managing WebDAV server content and building Ajax file managers.
+
+See how to list files on a WebDAV server, copy, move and delete items, read and set custom properties, lock items and discover locks.
+
+[more...](https://www.webdavsystem.com/ajax/programming/managing_hierarchy/)
+
+
+### Programming WebDAV Search Capabilities
+This article describes how to detect DASL search support, submit search queries, specify which properties to search and request custom properties to be returned in search results, such as snippet of text around search phrase.
+
+[more...](https://www.webdavsystem.com/ajax/programming/search/)
+
+### Re-branding and Building from Source Codes
+
+The Source Codes License is provided with complete Protocol Applications source codes. You can fully re-brand, localize and customize the protocol applications for Windows, OS X and Linux. The source codes are provided with build scripts that you can use to compile and build installers for each OS "in one click".
+
+[more...](https://www.webdavsystem.com/ajax/programming/open-doc-webpage/rebranding-building/)
+
+### Opening OS File Manager from a Web Page
+
+See how to jump from a web page to managing files using familiar desktop interface.
+
+The custom protocol provided with Ajax Library can mount WebDAV server to local file system and start OS File Manager  on Windows, Mac OS X and Linux.
+
+[more...](https://www.webdavsystem.com/ajax/programming/open-doc-webpage/opening_os_file_manager/)
+
+### Managing Locks on Your WebDAV Server
+
+Locks protect the document while being edited from concurrent modifications. Locks support on your WebDAV server is vital for Microsoft Office editing.
+
+While in most cases your WebDAV client, including Microsoft Office, will manage locks automatically you may need to discover locks support, enumerate locks and unlock a file if needed.
+
+[more...](https://www.webdavsystem.com/ajax/programming/locking/)
+
+### License 
+
+[License Agreement](https://www.webdavsystem.com/media/1175/it-hit-webdav-ajax-library-license-agreement.rtf)

package/Tests/DocManager/MsOfficeEditExtensions.js

@@ -0,0 +1,53 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('DocManager.MsOfficeEditExtensions');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.DocManager.MsOfficeEditExtensions
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.DocManager.MsOfficeEditExtensions', null, {}, /** @lends ITHit.WebDAV.Client.Tests.DocManager.MsOfficeEditExtensions */{
+
+    /**
+     * @param {string} [sDocumentUrl='http://localhost:87654/myfile.rtf']
+     */
+    EditRtfDocumentWithWord: function(sDocumentUrl) {
+		ITHit.WebDAV.Client.DocManager.IsMicrosoftOfficeDocument(sDocumentUrl);	// false
+		ITHit.WebDAV.Client.DocManager.MsOfficeEditExtensions.Word.push('rtf');
+		ITHit.WebDAV.Client.DocManager.IsMicrosoftOfficeDocument(sDocumentUrl);	// true
+		// Now .rtf file is opened with Microsoft Word.
+    },
+
+	/**
+     * @param {string} [sDocumentUrl='http://localhost:87654/myfile.rtf']
+     * @param {string} [sMountPoint='http://localhost:87654/']
+     * @param {function} [fProtocolInstallCallback]
+	 */
+	EditDocumentTest: function(sDocumentUrl, sMountPoint, fProtocolInstallCallback) {
+		ITHit.WebDAV.Client.DocManager.MsOfficeEditExtensions.Word.push("rtf");
+
+		// Now .rtf files are opened with Microsoft Word.
+		ITHit.WebDAV.Client.DocManager.EditDocument(sDocumentUrl, sMountPoint, fProtocolInstallCallback);
+
+		// or call
+		// ITHit.WebDAV.Client.DocManager.MicrosoftOfficeEditDocument(sDocumentUrl, fProtocolInstallCallback);
+	}
+
+});
+
+
+QUnit.test('MsOfficeEditExtensions test', function(test){
+	var oDocManager = ITHit.WebDAV.Client.DocManager;
+	test.ok(oDocManager.MsOfficeEditExtensions !== undefined, 'Check if ..DocManager.MsOfficeEditExtensions is defined');
+	test.ok(oDocManager.MsOfficeEditExtensions.Word !== undefined, 'Check if ..MsOfficeEditExtensions.Word is defined');
+	test.strictEqual(oDocManager.GetMsOfficeSchemaByExtension('docx'), 'ms-word', 'Check if schema for "docx" is "ms-word" (DocManager.GetMsOfficeSchemaByExtension)');
+	test.ok(oDocManager.IsMicrosoftOfficeDocument('filename.VDW'), 'Check "VDW" if it is in MsOfficeEditExtensions (IsMicrosoftOfficeDocument)');
+	test.ok(!oDocManager.IsMicrosoftOfficeDocument('filename.rtf'), 'Check "rtf" if it is not in MsOfficeEditExtensions');
+	// add 'rtf' to MsOffice file extensions
+	oDocManager.MsOfficeEditExtensions.Word.push('rtf');
+	test.ok(oDocManager.IsMicrosoftOfficeDocument('filename.rtf'), 'Check "rtf" if it is in MsOfficeEditExtensions now');
+
+	oDocManager.MsOfficeEditExtensions.Word.pop();
+	ITHit.WebDAV.Client.Tests.DocManager.MsOfficeEditExtensions.EditRtfDocumentWithWord('filename.rtf');
+});

package/Tests/Helper.js

@@ -0,0 +1,214 @@
+
+(function() {
+
+	window.Helper = {
+		_TestFolder: 'qtest_' + (new Date().getTime()) + '/',
+		_Folders: {},
+		_Files: {},
+
+		/**
+		 *
+		 * @param sRelativePath
+		 * @returns {string}
+		 */
+		GetPath: function(sRelativePath) {
+			return '/' + this._TestFolder + sRelativePath;
+		},
+
+		/**
+		 *
+		 * @param sRelativePath
+		 * @returns {string}
+		 */
+		GetAbsolutePath: function(sRelativePath) {
+			return this._GetHost() + this.GetPath(sRelativePath).substr(1);
+		},
+
+		GetSession: function() {
+			return window.webDavSession;
+		},
+
+		GetFolder: function(/** {string} ['/folder1/folder11/' | '/'] */ sPath, fCallback) {
+			var that = this;
+
+			if (this._Folders[sPath]) {
+				fCallback(that._Folders[sPath]);
+			} else {
+				sPath = sPath.replace(/^\//, "");
+
+				var sAbsolutePath = this._GetHost() + sPath;	// .substr(1);
+
+				var oSession = this.GetSession();
+				oSession.OpenFolderAsync(sAbsolutePath, null, function (oAsyncResult) {
+					if (oAsyncResult.Result === null) {
+						console.debug('ERROR :: Helper :: Can not get folder `' + sAbsolutePath + '` :: oAsyncResult.Error :: ', oAsyncResult.Error);
+						throw Error('Helper :: Can not get folder `' + sAbsolutePath + '` :: oAsyncResult.Error :: ' + oAsyncResult.Error);
+					}
+					that._Folders[sPath] = oAsyncResult.Result;
+					fCallback(oAsyncResult.Result);
+				});
+			}
+		},
+
+		/**
+		 * @param aPaths {string|string[]} paths to create. When all pathes have been created call fCallback
+		 * @param fCallback
+		 */
+		Create: function(aPaths, fCallback) {
+			aPaths = [].concat(aPaths);
+
+			var that = this;
+			this._CreateNext(aPaths, 0, function() {
+				var aItems = [];
+
+				for (var i = 0, l = aPaths.length; i < l; i++) {
+					if (aPaths[i] === '/') {
+						aItems.push(that._Folders['']);
+					} else if (aPaths[i].substr(-1) === '/') {
+						aItems.push(that._Folders[that._TestFolder + aPaths[i]]);
+					} else {
+						aItems.push(that._Files['/' + that._TestFolder + aPaths[i]]);
+					}
+				}
+
+				fCallback.apply(null, aItems);
+			});
+		},
+
+		/**
+		 * creates aPaths[i]. if "i" greater then aPaths.length - 1 fCallback will be called
+		 * @param aPaths
+		 * @param i {number}
+		 * @param fCallback
+		 */
+		_CreateNext: function(aPaths, i, fCallback) {
+			var sPath = aPaths[i];
+
+			if (!sPath) {
+				fCallback();
+				return;
+			}
+
+			var that = this;
+			if (/\/$/.test(sPath)) {
+				this._CreateFolder(sPath, function() {
+					that._CreateNext(aPaths, i + 1, fCallback);
+				});
+			} else {
+				this._CreateFile(sPath, function() {
+					that._CreateNext(aPaths, i + 1, fCallback);
+				});
+			}
+		},
+
+		CheckVersionsSupported: function(oFile, fCallback) {
+			oFile.GetSupportedFeaturesAsync(function(oAsyncResult) {
+
+				/** @typedef {ITHit.WebDAV.Client.OptionsInfo} oOptionsInfo */
+				var oOptionsInfo = oAsyncResult.Result;
+
+				if ((oOptionsInfo.VersionControl & ITHit.WebDAV.Client.Features.VersionControl) === 0) {
+					fCallback(false);
+					return;
+				}
+
+				if (oFile.VersionControlled) {
+					fCallback(true);
+					return;
+				}
+
+				oFile.PutUnderVersionControlAsync(true, null, function(oAsyncResult) {
+					fCallback(oAsyncResult.IsSuccess);
+				});
+			});
+		},
+
+		_GetHost: function() {
+			return window.ITHitTestsConfig.Url.replace(/\/?$/, '/');
+		},
+
+		/**
+		 *
+		 * @param sPath
+		 * @param fCallback
+		 * @private
+		 */
+		_CreateFolder: function(sPath, fCallback) {
+			var folders = this.GetPath(sPath).split('/');
+			folders.shift();
+
+			var that = this;
+			that._CreateFolderNext(folders, '', 0, fCallback);
+		},
+
+		_CreateFolderNext: function(folders, sParentFolder, i, fCallback) {
+			if (!folders[i]) {
+				fCallback();
+				return;
+			}
+
+			var sFolder = sParentFolder + folders[i] + '/';
+
+			if (this._Folders[sFolder]) {
+				this._CreateFolderNext(folders, sFolder, i + 1, fCallback);
+			} else {
+				var that = this;
+				this.GetFolder(sParentFolder || '/', function(oFolder) {
+					var sFolderName = folders[i] + '/';
+					oFolder.CreateFolderAsync(sFolderName, null, null, function (oAsyncResult) {
+						that._Folders[sFolder] = oAsyncResult.Result;
+						that._CreateFolderNext(folders, sFolder, i + 1, fCallback);
+					});
+				});
+			}
+		},
+
+		/**
+		 *
+		 * @param sPath
+		 * @param fCallback
+		 * @private
+		 */
+		_CreateFile: function(sPath, fCallback) {
+			var matches = /(.+\/)?([^/]+)$/.exec(sPath);
+			var folderRelative = matches[1] || '';
+			var file = matches[2];
+			var folder = this.GetPath(folderRelative);
+
+			if (folderRelative) {
+				var that = this;
+				this._CreateFolder(folderRelative, function() {
+					that._CreateFileItem(folder, file, fCallback);
+				});
+			} else {
+				this._CreateFileItem(folder, file, fCallback);
+			}
+		},
+
+		_CreateFileItem: function(folder, file, fCallback) {
+			if (this._Files[folder + file]) {
+				setTimeout(function() {
+					fCallback();
+				});
+				return;
+			}
+
+			var that = this;
+			this.GetFolder(folder, function(oFolder) {
+				oFolder.CreateFileAsync(file, null, 'test..', null, function(oAsyncResult) {
+					that._Files[folder + file] = oAsyncResult.Result;
+					fCallback(oAsyncResult.Result);
+				});
+			});
+		},
+
+		Destroy: function() {
+			this.GetFolder(this._TestFolder, function(oFolder) {
+				oFolder.DeleteAsync(null, function() {
+					// ok
+				});
+			});
+		}
+	};
+
+})();