v4.0.10509.0-Beta

Author: ITHitBuild

.gitignore

@@ -0,0 +1,9 @@
+################################################################################
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+################################################################################
+
+.vs/
+bin/
+obj/
+*.user
+*.cache

Common/Common.csproj

@@ -8,6 +8,6 @@
     <Description>Contains functionality common for all Virtual Drive samples, both for Windows and macOS.</Description>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ITHit.FileSystem" Version="4.0.10312.0-Beta" />
+    <PackageReference Include="ITHit.FileSystem" Version="4.0.10509.0-Beta" />
   </ItemGroup>
 </Project>

Common/FileSystemItemMetadataExt.cs

@@ -42,16 +42,9 @@ public class FileSystemItemMetadataExt : IFileSystemItemMetadata
         public string ETag { get; set; }
 
         /// <summary>
-        /// Indicates if the item is locked by another user in the remote storage.
-        /// This will set a read-only flag on this item.
+        /// Indicates if the item is locked in the remote storage.
         /// </summary>
-        /// <remarks>
-        /// Note that the read-only flag is a convenience-only feature. 
-        /// Typically the user will be notified by the application that the item can not be saved if 
-        /// she/he tries to update this item . 
-        /// Read-only flag does not protect this item from modifications.
-        /// </remarks>
-        public bool LockedByAnotherUser { get; set; } = false;
+        public bool IsLocked { get; set; } = false;
 
         /// <summary>
         /// Custom columns data to be displayed in the file manager.

Windows/Common/Common.Windows.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="5.0.0" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ITHit.FileSystem.Windows" Version="4.0.10312.0-Beta" />
+    <PackageReference Include="ITHit.FileSystem.Windows" Version="4.0.10509.0-Beta" />
     <ProjectReference Include="..\..\Common\Common.csproj" />
   </ItemGroup>
 </Project>

Windows/Common/ETagManager.cs

@@ -111,14 +111,19 @@ internal async Task MoveToAsync(string userFileSystemNewPath)
         /// </summary>
         internal void DeleteETag()
         {
-            File.Delete(eTagFilePath);
+            if (File.Exists(eTagFilePath))
+            {
+                File.Delete(eTagFilePath);
+            }
 
+            /*
             // If this is a folder, delete all eTags in this folder.
             string eTagFolderPath = GetETagFilePath(userFileSystemPath);
             if (Directory.Exists(eTagFolderPath))
             {
                 Directory.Delete(eTagFolderPath, true);
             }
+            */
         }
 
         /// <summary>

Windows/Common/ExternalDataManager.cs

@@ -16,8 +16,8 @@ namespace ITHit.FileSystem.Samples.Common.Windows
     /// </summary>
     /// <remarks>
     /// This class stores all custom data associated with the item outside of the placeholder.
-    /// We can not store item ID and custom data inside placeholder (using <see cref="IFileSystemItemMetadata.CustomData"/> 
-    /// and <see cref="ITHit.FileSystem.Windows.PlaceholderItem.GetCustomData"/>) because of the MS Office transactional save, 
+    /// We can not store item ID and custom data inside of the placeholder (using <see cref="IFileSystemItemMetadata.CustomData"/> 
+    /// and <see cref="ITHit.FileSystem.Windows.PlaceholderItem.GetCustomData"/>) because of the MS Office and AutoCAD transactional save, 
     /// which renames and deletes the file, so all custom data is lost.
     /// </remarks>
     public class ExternalDataManager
@@ -80,8 +80,8 @@ public ExternalDataManager(
         /// Indicates if the item was saved to the remote storage.
         /// </summary>
         /// <remarks>
-        /// MS Office transactional save, deletes and recreates the file.
-        /// To detect if this is a new file we must store some marker ouside of the file, 
+        /// MS Office and AutoCAD transactional save, deletes and recreates the file.
+        /// To detect if this is a new file, we must store some marker ouside of the file, 
         /// for the marker to survive the transactional save operation.
         /// </remarks>
         public bool IsNew
@@ -226,68 +226,16 @@ private async Task SetIconAsync(bool set, int id, string iconFile = null, string
             }
         }
 
-        /*
-        /// <summary>
-        /// Sets or removes icon.
-        /// </summary>
-        /// <param name="set">True to display the icon. False - to remove the icon.</param>
-        private async Task SetIconAsync(bool set, int? id = null, string iconFile = null, string description = null)
-        {
-            IStorageItem storageItem = await FsPath.GetStorageItemAsync(userFileSystemPath);
-
-            if (storageItem == null)
-            {
-                // This method may be called on temp files, typically created by MS Office, that exist for a short period of time.
-                // StorageProviderItemProperties.SetAsync(null,) causes AccessViolationException 
-                // which is not handled by .NET (or handled by HandleProcessCorruptedStateExceptions) and causes a fatal crush.
-                return;
-            }
-
-            try
-            {
-                if (set)
-                {
-                    StorageProviderItemProperty propState = new StorageProviderItemProperty()
-                    {
-                        Id = id.Value,
-                        Value = description,
-                        IconResource = Path.Combine(virtualDrive.Settings.IconsFolderPath, iconFile)
-                    };
-                    await StorageProviderItemProperties.SetAsync(storageItem, new StorageProviderItemProperty[] { propState });
-                }
-                else
-                {
-                    await StorageProviderItemProperties.SetAsync(storageItem, new StorageProviderItemProperty[] { });
-                }
-            }
-
-            // Setting status icon failes for blocked files.
-            catch (FileNotFoundException)
-            {
-
-            }
-            catch (COMException)
-            {
-                // "Error HRESULT E_FAIL has been returned from a call to a COM component."
-            }
-            catch (Exception ex)
-            {
-                if (ex.HResult == -2147024499)
-                {
-                    // "The operation failed due to a conflicting cloud file property lock. (0x8007018D)"
-                }
-                else
-                {
-                    // Rethrow the exception preserving stack trace of the original exception.
-                    System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
-                }
-            }
-        }
-        */
-        
         /// <summary>
-        /// Sets or removes read-only attribute on files.
+        /// Indicates if the item is locked by another user in the remote storage.
+        /// This will call sets or removes the read-only flag in case the item is a file.
         /// </summary>
+        /// <remarks>
+        /// Call this method if the item is locked by another user. This will set read-only arrtibute on files. 
+        /// Note that the read-only flag is a convenience-only feature. It does not protect files from modifications.
+        /// Typically the user will be notified by the application that the item can not be saved if 
+        /// the application tries to update this item. 
+        /// </remarks>
         /// <param name="set">True to set the read-only attribute. False - to remove the read-only attribute.</param>
         public async Task<bool> SetLockedByAnotherUserAsync(bool set)
         {
@@ -549,25 +497,32 @@ private async Task CustomColumnsMoveToAsync(string userFileSystemNewPath)
         /// <summary>
         /// Deletes all custom data associated with the item.
         /// </summary>
-        public void Delete()
+        /// <param name="recursive">Deletes all data for subfolders if true.</param>
+        public void Delete(bool recursive = true)
         {
             DeleteCustomColumns();
             ETagManager.DeleteETag();
             LockManager.DeleteLock();
+
+            if(recursive)
+            {
+                // If this is a folder, delete all custom columns in this folder.
+                string customColumnsFolderPath = GetColumnsFilePath(userFileSystemPath);
+                if (Directory.Exists(customColumnsFolderPath))
+                {
+                    Directory.Delete(customColumnsFolderPath, true);
+                }
+            }
         }
 
         /// <summary>
         /// Deletes custom columns associated with a file.
         /// </summary>
         private void DeleteCustomColumns()
         {
-            File.Delete(customColumnsFilePath);
-
-            // If this is a folder, delete all custom columns in this folder.
-            string customColumnsFolderPath = GetColumnsFilePath(userFileSystemPath);
-            if (Directory.Exists(customColumnsFolderPath))
+            if (File.Exists(customColumnsFilePath))
             {
-                Directory.Delete(customColumnsFolderPath, true);
+                File.Delete(customColumnsFilePath);
             }
         }
     }

Windows/Common/Filter/AutoCadFilterHelper.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+
+namespace ITHit.FileSystem.Samples.Common.Windows
+{
+    /// <summary>
+    /// Provides methods to detect AutoCAD files that should not be synced to the remote storage, 
+    /// such as AutoCAD temporary files and AutoCAD lock files.
+    /// </summary>
+    /// <remarks>
+    /// AutoCAD lock files (.dwl and .dwl2), are marked as hidden and filtered by the <see cref="FilterHelper.IsHiddenOrTemp"/> method.
+    /// </remarks>
+    internal class AutoCadFilterHelper
+    {
+        /// <summary>
+        /// Returns true if the file should NOT be synched to the remote storage. False - otherwise.
+        /// </summary>
+        /// <param name="path">Path to a file or folder.</param>
+        public static bool AvoidSync(string path)
+        {
+            return IsAutoCadTemp(path) || FilterHelper.IsHiddenOrTemp(path);
+        }
+
+        /// <summary>
+        /// Returns true if the file has .tmp extension, false - otherwise.
+        /// </summary>
+        /// <param name="path">Path to a file.</param>
+        /// <remarks>
+        /// sav1ea4afdc.tmp
+        /// Mechanical - Multileaders8f31c74f.tmp
+        /// Mechanical - Multileaders.bak
+        /// atmp91130947
+        /// </remarks>
+        private static bool IsAutoCadTemp(string path)
+        {
+            string extension = Path.GetExtension(path);
+            return (extension.Equals(".tmp", StringComparison.InvariantCultureIgnoreCase)
+                || extension.Equals(".bak", StringComparison.InvariantCultureIgnoreCase)
+                || (string.IsNullOrEmpty(extension) && Path.GetFileName(path).StartsWith("atmp", StringComparison.InvariantCultureIgnoreCase))
+                );
+        }
+
+        /// <summary>
+        /// Returns true if file system contains an AutoCAD lock-file (.dwl or .dwl2) in file 
+        /// system that corresponds to the provided path to AutoCAD file. False - otherwise.
+        /// </summary>
+        /// <param name="path">Path to the AutoCAD file.</param>
+        internal static bool IsAutoCadLocked(string path)
+        {
+            string lockPath = GetLockPathFromAutoCadPath(path);
+            return lockPath != null;
+        }
+
+        /// <summary>
+        /// Returns AutoCAD lock file path if such file exists. Null - otherwise.
+        /// </summary>
+        /// <param name="msOfficeFilePath">AutoCAD file path.</param>
+        /// <returns>Lock file path or null if the lock file is not found.</returns>
+        /// <remarks>
+        /// file.dwg -> file.dwl
+        /// </remarks>
+        private static string GetLockPathFromAutoCadPath(string autoCadFilePath)
+        {
+            string lockFilePath = Path.ChangeExtension(autoCadFilePath, "dwl");
+            return File.Exists(lockFilePath) ? lockFilePath : null;
+        }
+    }
+}

Windows/Common/Filter/FilterHelper.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+
+namespace ITHit.FileSystem.Samples.Common.Windows
+{
+    /// <summary>
+    /// Provides methods to detect hidden files, temporary files, lock files and files moved to recycle bin.
+    /// </summary>
+    public class FilterHelper
+    {
+        /// <summary>
+        /// Returns true if the file should NOT be synched to the remote storage. False - otherwise.
+        /// </summary>
+        /// <param name="path">Path to a file or folder.</param>
+        public static bool AvoidSync(string path)
+        {
+            return MsOfficeFilterHelper.AvoidSync(path) || AutoCadFilterHelper.AvoidSync(path) || IsHiddenOrTemp(path);
+        }
+
+        /// <summary>
+        /// Returns true if file system contains an application lock-file (~$*.docx, *.dwl, *.dwl2) in file 
+        /// system that corresponds to the provided path to the file file. False - otherwise.
+        /// </summary>
+        /// <param name="path">Path to the file to check the lock-file for.</param>
+        public static bool IsAppLocked(string path)
+        {
+            return MsOfficeFilterHelper.IsMsOfficeLocked(path) || AutoCadFilterHelper.IsAutoCadLocked(path);
+        }
+
+
+        /// <summary>
+        /// Returns true if the path points to a recycle bin folder.
+        /// </summary>
+        /// <param name="path">Path to the file or folder.</param>
+        public static bool IsRecycleBin(string path)
+        {
+            return path.IndexOf("\\$Recycle.Bin", StringComparison.InvariantCultureIgnoreCase) != -1;
+        }
+
+        /// <summary>
+        /// Returns true if the file or folder is marked with Hidden or Temporaty attributes.
+        /// </summary>
+        /// <param name="path">Path to a file or folder.</param>
+        /// <returns>
+        /// True if the file or folder is marked with Hidden or Temporaty attributes. 
+        /// Returns false if no Hidden or Temporaty attributes found or file/folder does not exists.
+        /// </returns>
+        internal static bool IsHiddenOrTemp(string path)
+        {
+            if (!System.IO.File.Exists(path) && !System.IO.Directory.Exists(path))
+            {
+                return false;
+            }
+
+            FileAttributes att = System.IO.File.GetAttributes(path);
+            return ((att & System.IO.FileAttributes.Hidden) != 0)
+                 || ((att & System.IO.FileAttributes.Temporary) != 0);
+        }
+    }
+}