v1.0.0.3019-Alpha

Author: ITHitBuild

VirtualFileSystem/CustomData.cs

@@ -0,0 +1,164 @@
+using ITHit.FileSystem.Windows;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace VirtualFileSystem
+{
+    /// <summary>
+    /// Custom data stored with a file or folder placeholder, such ETag and original file/folder path. Max 4KB.
+    /// </summary>
+    /// <remarks>To avoid storing metatadata and keep footprit small, this class is is using custom serialization.</remarks>
+    internal class CustomData
+    {
+        /// <summary>
+        /// File ETag. Used to verify that the file on the server is not modified during client to server synchronization.
+        /// </summary>
+        /// <remarks>This field is required if the server does not provide locking capabilities.</remarks>
+        internal string ETag = "";
+
+        /// <summary>
+        /// Keeps the original file/folder path. Used to sync file/folder from user file system to remote storage 
+        /// if this app was not running when the file/folder was moved or renamed. This field allows to avoid 
+        /// delete-create sequence during client to server synchronization after app failure.
+        /// </summary>
+        internal string OriginalPath = "";
+
+        /// <summary>
+        /// Used for Microsoft Office lock files (~$file.ext) to store custom data during transactional save.
+        /// The original MS Office file is renamed and than deleted. As a result the ETag is lost and we can not 
+        /// send the ETag to the server when saving the file. 
+        /// As a solution, we copy custom data from the original file during lock file creation into this field. 
+        /// When the original file is being saved, we read ETag from the lock file.
+        /// </summary>
+        internal byte[] SavedData = new byte[] { };
+
+        /// <summary>
+        /// Serializes all custom data fields into the byte array.
+        /// </summary>
+        /// <returns>Byte array representing custom data.</returns>
+        internal byte[] Serialize()
+        {
+            using (MemoryStream m = new MemoryStream())
+            {
+                using (BinaryWriter writer = new BinaryWriter(m))
+                {
+                    writer.Write(ETag);
+                    writer.Write(OriginalPath);
+                    writer.Write(SavedData.Length);
+                    writer.Write(SavedData);
+                }
+                return m.ToArray();
+            }
+        }
+
+        /// <summary>
+        /// Deserializes custom data from byte array into object.
+        /// </summary>
+        /// <param name="data">Byte array representing custom data.</param>
+        /// <returns></returns>
+        internal static CustomData Desserialize(byte[] data)
+        {
+            if(data == null)
+            {
+                throw new ArgumentNullException("data");
+            }
+
+            CustomData obj = new CustomData();
+            using (MemoryStream m = new MemoryStream(data))
+            {
+                using (BinaryReader reader = new BinaryReader(m))
+                {
+                    obj.ETag = reader.ReadString();
+                    obj.OriginalPath = reader.ReadString();
+                    obj.SavedData = reader.ReadBytes(reader.ReadInt32());
+                }
+            }
+            return obj;
+        }
+    }
+
+    /// <summary>
+    /// Placeholder methods to get and set custom data associated with a placeholder, such as ETah and OriginalPath.
+    /// </summary>
+    internal static class PlaceholderItemExtensions
+    {
+        public static void SetCustomData(this PlaceholderItem placeholder, string eTag, string originalPath)
+        {
+            CustomData customData = new CustomData { ETag = eTag, OriginalPath = originalPath };
+            placeholder.SetCustomData(customData.Serialize());
+        }
+
+        public static void SetCustomData(Microsoft.Win32.SafeHandles.SafeFileHandle safeHandle, string eTag, string originalPath)
+        {
+            CustomData customData = new CustomData { ETag = eTag, OriginalPath = originalPath };
+            PlaceholderItem.SetCustomData(safeHandle, customData.Serialize());
+        }
+
+        public static void SetOriginalPath(this PlaceholderItem placeholder, string originalPath)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+
+            customData.OriginalPath = originalPath;
+            placeholder.SetCustomData(customData.Serialize());
+        }
+
+        public static string GetOriginalPath(this PlaceholderItem placeholder)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+            return customData.OriginalPath;
+        }
+
+        public static void SetETag(this PlaceholderItem placeholder, string eTag)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+
+            customData.ETag = eTag;
+            placeholder.SetCustomData(customData.Serialize());
+        }
+
+        public static string GetETag(this PlaceholderItem placeholder)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+            return customData.ETag;
+        }
+
+        public static void SetSavedData(this PlaceholderItem placeholder, byte[] saveData)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+
+            customData.SavedData = saveData;
+            placeholder.SetCustomData(customData.Serialize());
+        }
+
+        public static byte[] GetSavedData(this PlaceholderItem placeholder)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+            return customData.SavedData;
+        }
+
+        /// <summary>
+        /// Returns true if the file was moved in the user file system and changes not yet synched to the remote storage.
+        /// </summary>
+        public static bool IsMoved(this PlaceholderItem placeholder)
+        {
+            // If original path was never set, the file was just created, not moved.
+            string originalPath = placeholder.GetOriginalPath();
+            if (string.IsNullOrEmpty(originalPath))
+            {
+                return false;
+            }
+
+            // Otherwise verify that current file path and original file path are equal.
+            return !originalPath.Equals(placeholder.Path, StringComparison.InvariantCultureIgnoreCase);
+        }
+
+    }
+}

VirtualFileSystem/FsPath.cs

@@ -119,17 +119,76 @@ public static string GetAttString(string path)
         /// <param name="path">Path to a file or folder.</param>
         public static bool IsMsOfficeTemp(string path)
         {
-            return Path.GetFileName(path).StartsWith('~') && Path.GetExtension(path).Equals(".tmp", StringComparison.InvariantCultureIgnoreCase);
+            return (Path.GetFileName(path).StartsWith('~')   && Path.GetExtension(path).Equals(".tmp", StringComparison.InvariantCultureIgnoreCase))  // Word temp files
+                || (Path.GetFileName(path).StartsWith("ppt") && Path.GetExtension(path).Equals(".tmp", StringComparison.InvariantCultureIgnoreCase)); // PowerPoint temp files
         }
 
+        /// <summary>
+        /// Returns true if file system contains MS Office lock file (~$file.ext) in file 
+        /// system that corresponds to the provided path to MS Office file. 
+        /// </summary>
+        /// <param name="path">Path to MS Office file.</param>
         public static bool IsMsOfficeLocked(string path)
         {
-            //string lockFileName = $"~${Path.GetFileName(path)}";
-            //string lockPath = Path.Combine(Path.GetDirectoryName(path), lockFileName);
+            string lockPath = GetLockPathFromMsOfficePath(path);
+            return lockPath != null;
+        }
+
+
+        /// <summary>
+        /// Returns true if the provided path points to MS Office lock file (~$file.ext). 
+        /// </summary>
+        /// <param name="path">Path to lock file.</param>
+        public static bool IsMsOfficeLockFile(string path)
+        {
+            return Path.GetFileName(path).StartsWith("~$");
+        }
+
+        /*
+        public static string GetMsOfficePathFromLock(string msOfficeLockFilePath)
+        {
+            int separatorIndex = msOfficeLockFilePath.LastIndexOf(Path.DirectorySeparatorChar);
+            return msOfficeLockFilePath.Remove(separatorIndex + 1, "~$".Length);
+        }
+        */
 
-            int separatorIndex = path.LastIndexOf(Path.DirectorySeparatorChar);
-            string lockPath = path.Insert(separatorIndex + 1, "~$");
-            return File.Exists(lockPath);
+        /// <summary>
+        /// Returns MS Office lock file path if such file exists.
+        /// </summary>
+        /// <param name="msOfficeFilePath">MS Office file path.</param>
+        /// <returns>Lock file path.</returns>
+        /// <remarks>
+        /// mydoc.docx       -> ~$mydoc.docx
+        /// mydocfi.docx     -> ~$ydocfi.docx
+        /// mydocfile.docx   -> ~$docfile.docx
+        /// mydocfile.pptx   -> ~$mydocfile.pptx
+        /// mydocfile.ppt    -> ~$mydocfile.ppt
+        /// mydocfile.xlsx   -> ~$mydocfile.xlsx
+        /// mydocfile.xls    -> null
+        /// </remarks>
+        public static string GetLockPathFromMsOfficePath(string msOfficeFilePath)
+        {
+            string msOfficeLockFilePath = null;
+            int separatorIndex = msOfficeFilePath.LastIndexOf(Path.DirectorySeparatorChar);
+            if ((separatorIndex != -1) && !string.IsNullOrEmpty(Path.GetExtension(msOfficeFilePath)))
+            {
+                msOfficeLockFilePath = msOfficeFilePath.Insert(separatorIndex + 1, "~$");
+                if(FsPath.Exists(msOfficeLockFilePath))
+                {
+                    return msOfficeLockFilePath;
+                }
+                int fileNameLength = Path.GetFileNameWithoutExtension(msOfficeFilePath).Length;
+                if (fileNameLength > 6)
+                {
+                    int removeChars = fileNameLength == 7 ? 1 : 2;
+                    msOfficeLockFilePath = msOfficeLockFilePath.Remove(separatorIndex + 1 + "~$".Length, removeChars);
+                    if (FsPath.Exists(msOfficeLockFilePath))
+                    {
+                        return msOfficeLockFilePath;
+                    }
+                }
+            }
+            return null;
         }
 
         /// <summary>
@@ -159,7 +218,7 @@ public static bool IsHiddenOrTemp(string path)
         /// <param name="path">Path to a file or folder.</param>
         public static bool AvoidSync(string path)
         {
-            return IsMsOfficeLocked(path) || IsMsOfficeTemp(path) || IsHiddenOrTemp(path);
+            return IsMsOfficeLockFile(path) || IsMsOfficeLocked(path) || IsMsOfficeTemp(path) || IsHiddenOrTemp(path);
         }
 
         /// <summary>

VirtualFileSystem/Images/Down.ico

@@ -71,10 +71,14 @@ public static FileSystemItemBasicInfo GetUserFileSysteItemInfo(FileSystemInfo re
 
             // Here you will typically store the file ETag. You will send the ETag to 
             // the server inside If-Match header togater with updated content from client.
-            // This will make sure the file on the server is not modified.
+            // This will make sure the changes on the server is not overwritten.
             //
-            // In this sample, for the sake of simplicity, we use file last write time.
-            userFileSystemItem.CustomData = BitConverter.GetBytes(remoteStorageItem.LastWriteTime.ToBinary());
+            // In this sample, for the sake of simplicity, we use file last write time instead of ETag.
+            userFileSystemItem.CustomData = new CustomData
+            {
+                ETag = remoteStorageItem.LastWriteTime.ToBinary().ToString(),
+                OriginalPath = Mapping.ReverseMapPath(remoteStorageItem.FullName)
+            }.Serialize();
 
             if (remoteStorageItem is FileInfo)
             {