Example #1
0
        /// <summary>
        /// Determines whether the currently logged on user has edit permissions on the specific item.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <returns>
        ///     <c>true</c> if the currently logged on user has edit permissions on the specific item; otherwise, <c>false</c>.
        /// </returns>
        public static bool CanEdit(VirtualFileBase item)
        {
            if (item == null)
            {
                return(false);
            }

            UnifiedDirectory dir = item as UnifiedDirectory;

            if (dir != null)
            {
                return(PrincipalInfo.HasAdminAccess || dir.QueryDistinctAccess(AccessLevel.Edit));
            }

            UnifiedFile file = item as UnifiedFile;

            if (file != null && (PrincipalInfo.HasAdminAccess || file.QueryDistinctAccess(AccessLevel.Edit)))
            {
                IVersioningFile versioningFile = file as IVersioningFile;
                return(versioningFile == null || !IsCheckedOutBySomeoneElse(versioningFile));
            }
            else
            {
                return(false);
            }
        }
Example #2
0
        /// <summary>
        /// Creates a temporary file in the supplied directory and writes stream content to file.
        /// </summary>
        /// <param name="baseDirectory">The directory where the temporary file is created.</param>
        /// <param name="fileContent">Content of the file.</param>
        /// <returns>A Unified File</returns>
        public static UnifiedFile CreateTempFile(UnifiedDirectory baseDirectory, Stream fileContent)
        {
            UnifiedFile file = CreateTempFile(baseDirectory);

            WriteToFile(fileContent, file, null);
            return(file);
        }
Example #3
0
        /// <summary>
        /// Copies a file to the target folder, optionally with a new file name.
        /// </summary>
        /// <param name="sourceFile">The source file.</param>
        /// <param name="targetDirectory">The target directory.</param>
        /// <param name="newName">The new name. Supply <c>null</c> to use the name of the source file.</param>
        public static void CopyFile(VirtualFile sourceFile, UnifiedDirectory targetDirectory, string newName)
        {
            if (String.IsNullOrEmpty(newName))
            {
                newName = sourceFile.Name;
            }

            string targetVirtualFilePath = VirtualPathUtility.Combine(targetDirectory.VirtualPath, newName);

            targetVirtualFilePath = FindAvailableVirtualPath(targetVirtualFilePath);

            UnifiedFile unifiedSourceFile = sourceFile as UnifiedFile;

            if (unifiedSourceFile != null)
            {
                // If the source file is a UnifiedFile use its copy implementation
                unifiedSourceFile.CopyTo(targetVirtualFilePath);
            }
            else
            {
                // If the source is unknown. i.e. implementing VirtualFile but not UnifiedFile.
                // Use the support methods of UnifiedFile to copy the source VirtualFile.
                UnifiedFile.CopyTo(sourceFile, targetVirtualFilePath);
            }
            //TODO: Implement copying of VersioningFile to a non-versioning provider.
            // The versioning providers overrides the [Copy/Move]To methods of UnifiedFile,
            // but throws an exception if trying to move or copy a file FROM a versioning
            // provider to another provider
        }
Example #4
0
 /// <summary>
 /// Deletes the items supplied in the <see cref="VirtualFileBaseCollection"/>.
 /// </summary>
 /// <param name="items">The items to delete.</param>
 public static void DeleteItems(VirtualFileBaseCollection items)
 {
     //Can only delete items inheriting from Unified[Directory/File]
     foreach (VirtualFileBase fileItem in items)
     {
         if (CanEdit(fileItem))
         {
             UnifiedDirectory directory = fileItem as UnifiedDirectory;
             if (directory != null)
             {
                 directory.Delete();
                 continue;
             }
             UnifiedFile file = fileItem as UnifiedFile;
             if (file != null)
             {
                 file.Delete();
                 continue;
             }
         }
         else
         {
             //TODO: What do we do with delete operation on unknown items.
             // Throw exception? Silently ignore? Logging!
         }
     }
 }
Example #5
0
        /// <summary>
        /// Moves a virtual file to a new directory, optioanlly renaming it in the process.
        /// </summary>
        /// <param name="sourceFile">The source file to be moved.</param>
        /// <param name="targetDirectory">The destination directory.</param>
        /// <param name="newName">An optional new name. Supply <c>null</c> to use the original name of the source file.</param>
        public static void MoveFile(VirtualFile sourceFile, UnifiedDirectory targetDirectory, string newName)
        {
            if (String.IsNullOrEmpty(newName))
            {
                newName = sourceFile.Name;
            }

            string targetVirtualFilePath = VirtualPathUtility.Combine(targetDirectory.VirtualPath, newName);

            UnifiedFile unifiedSourceFile = sourceFile as UnifiedFile;

            if (unifiedSourceFile != null)
            {
                IVersioningFile versioningFile = sourceFile as IVersioningFile;
                if (versioningFile != null)
                {
                    ThrowIfCheckedOut(versioningFile);
                }

                if (!IsPathAvailable(targetVirtualFilePath))
                {
                    throw new ArgumentException("Moving a file with the same name as a file or a folder in the target directory is not allowed");
                }

                unifiedSourceFile.MoveTo(targetVirtualFilePath);
            }
            // Can't move a file unless its a UnifiedFile. VirtualFile does not specify any remove methods.
        }
Example #6
0
        /// <summary>
        /// Creates a file using the contents of the supplied stream.
        /// </summary>
        /// <param name="directory">The directory in which to create the file.</param>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="checkInComment">An optional check in comment.</param>
        /// <param name="fileContent">Contents of the file.</param>
        /// <returns>The newly created file.</returns>
        public static UnifiedFile CreateFile(UnifiedDirectory directory, string fileName, string checkInComment, Stream fileContent)
        {
            UnifiedFile file = directory.CreateFile(fileName);

            WriteToFile(fileContent, file, checkInComment);
            return(file);
        }
Example #7
0
        /// <summary>
        /// Moves a virtual directopry to a new location, optioanlly renaming it in the process.
        /// </summary>
        /// <param name="sourceDirectory">The source directory to be moved.</param>
        /// <param name="targetDirectory">The destination directory.</param>
        /// <param name="newName">An optional new name. Supply <c>null</c> to use the original name of the source file.</param>
        public static void MoveDirectory(VirtualDirectory sourceDirectory, UnifiedDirectory targetDirectory, string newName)
        {
            if (String.IsNullOrEmpty(newName))
            {
                newName = sourceDirectory.Name;
            }

            string targetVirtualDirectoryPath = VirtualPathUtility.Combine(targetDirectory.VirtualPath, newName);

            // TODO: Move this logic into UnifiedDirectoey it shouldn't be possible to orphan directories.
            if (!ValidatePathStructureForMove(sourceDirectory.VirtualPath, targetVirtualDirectoryPath))
            {
                throw new ArgumentException("Moving a folder below itself is not allowed.");
            }

            UnifiedDirectory unifiedSourceDirectory = sourceDirectory as UnifiedDirectory;

            if (unifiedSourceDirectory != null)
            {
                if (unifiedSourceDirectory.Parent.VirtualPath != targetDirectory.VirtualPath)
                {
                    VersioningDirectory versioningDirectory = sourceDirectory as VersioningDirectory;
                    if (versioningDirectory != null)
                    {
                        ThrowIfCheckedOut(versioningDirectory);
                    }
                }

                unifiedSourceDirectory.MoveTo(targetVirtualDirectoryPath);
            }
            // If source directory isn't a UnifiedDirectory we can't move it.
        }
        private List<VppFiles> ParseFiles(UnifiedDirectory directory)
        {
            var vppFiles = new List<VppFiles>();

            try
            {
                foreach (UnifiedFile file in directory.Files)
                {

                    var vppFile = new VppFiles
                        {
                            VirtualPath = file.VirtualPath,
                            VppPath = file.LocalPath
                        };
                    vppFiles.Add(vppFile);
                }

            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return vppFiles;
        }
Example #9
0
        /// <summary>
        /// Renames a virtual file or folder.
        /// </summary>
        /// <param name="sourceItem">The item to rename.</param>
        /// <param name="newName">The new name.</param>
        public static void RenameItem(VirtualFileBase sourceItem, string newName)
        {
            // Get the parent directory of the source item.
            string           sourceItemParentPath = VirtualPathUtility.GetDirectory(sourceItem.VirtualPath);
            UnifiedDirectory targetDirectory      = HostingEnvironment.VirtualPathProvider.GetDirectory(sourceItemParentPath) as UnifiedDirectory;

            MoveItem(sourceItem, targetDirectory, newName);
        }
Example #10
0
        /// <summary>
        /// Finds the last modified files.
        /// </summary>
        protected IList <UnifiedFile> FindLastModifiedFiles(string rootFolder, int maxCount)
        {
            var files = new List <UnifiedFile>();
            UnifiedDirectory directory = null;

            try
            {
                directory = HostingEnvironment.VirtualPathProvider.GetDirectory(rootFolder) as UnifiedDirectory;
            }
            catch (UnauthorizedAccessException) {}

            // If directory not found or access not granted for directory
            // return empty list
            if (directory == null)
            {
                ShowErrorMessage(Translate("/workroom/filelist/errormessage"));
                return(files);
            }

            UnifiedSearchQuery query = new UnifiedSearchQuery
            {
                ModifiedFrom  = DateTime.MinValue,
                ModifiedTo    = DateTime.Now,
                Path          = rootFolder,
                FreeTextQuery = String.Empty
            };

            UnifiedSearchHitCollection hits;

            try
            {
                hits = directory.Search(query);
            }
            catch (IOException)
            {
                ShowErrorMessage(Translate("/workroom/filelist/errormissingindex"));
                return(files);
            }

            for (int i = 0; i < hits.Count; i++)
            {
                try
                {
                    files.Add((UnifiedFile)HostingEnvironment.VirtualPathProvider.GetFile(hits[i].Path));
                }
                catch (UnauthorizedAccessException)
                {
                    // If user has limited access right we still want to show files with access granted.
                }
            }
            files.Sort(new FileModifiedComparer());

            if (files.Count > maxCount)
            {
                files.RemoveRange(maxCount - 1, files.Count - maxCount);
            }
            return(files);
        }
Example #11
0
 /// <summary>
 /// Moves a virtual file or folder to a new location, optionally renaming it at the same time.
 /// </summary>
 /// <param name="sourceItem">The source item to be moved.</param>
 /// <param name="targetDirectory">The destination directory.</param>
 /// <param name="newName">An optional new name. Supply <c>null</c> to use the original name of the source folder.</param>
 public static void MoveItem(VirtualFileBase sourceItem, UnifiedDirectory targetDirectory, string newName)
 {
     if (sourceItem.IsDirectory)
     {
         MoveDirectory((VirtualDirectory)sourceItem, targetDirectory, newName);
     }
     else
     {
         MoveFile((VirtualFile)sourceItem, targetDirectory, newName);
     }
 }
Example #12
0
 /// <summary>
 /// Copies a virtual file or folder to the target directory.
 /// </summary>
 /// <param name="sourceItem">The item to copy.</param>
 /// <param name="targetDirectory">The target directory.</param>
 public static void CopyItem(VirtualFileBase sourceItem, UnifiedDirectory targetDirectory)
 {
     if (sourceItem.IsDirectory)
     {
         CopyDirectory((VirtualDirectory)sourceItem, targetDirectory);
     }
     else
     {
         CopyFile((VirtualFile)sourceItem, targetDirectory);
     }
 }
Example #13
0
        public AmazonS3File(UnifiedDirectory directory, VirtualPathUnifiedProvider provider, string virtualPath, bool bypassAccessCheck, AmazonS3Object file)
            : base(directory, provider, virtualPath, bypassAccessCheck)
        {
            this._amazon = new AmazonS3Repository(((AmazonS3VirtualPathProvider)this.Provider).AwsAccessKey, ((AmazonS3VirtualPathProvider)this.Provider).AwsSecretKey, ((AmazonS3VirtualPathProvider)this.Provider).BucketName);
            this._summary = new AmazonS3Summary();
            this._virtualPath = virtualPath;

            if (file != null)
            {
                this._file = file;
            }
        }
Example #14
0
        /// <summary>
        /// Creates the page folder of the workroom start page, if it isn't already created.
        /// </summary>
        /// <param name="workroomPage">The workroom start page.</param>
        private static void CreateFolder(PageData workroomPage)
        {
            //We want to allow folder to be created without access checks performed therefore this
            //construction. Otherwise it would be enough to call CurrentPage.GetPageDirectory(true)
            UnifiedDirectory pageDirectory = workroomPage.GetPageDirectory(false);

            if (pageDirectory == null)
            {
                UnifiedDirectory rootDirectory = VirtualPathHandler.Instance.GetDirectory(VirtualPathHandler.PageDirectoryRootVirtualPath, true) as UnifiedDirectory;
                rootDirectory.CreateSubdirectory(workroomPage.Property["PageFolderID"].ToString());
            }
        }
Example #15
0
        /// <summary>
        /// Copies a directory to a new location, optionally with a new name.
        /// </summary>
        /// <param name="sourceDirectory">The source directory.</param>
        /// <param name="targetDirectory">The target directory.</param>
        /// <param name="newName">The optional new name of the directory. Supply <c>null</c> to use the name of the source directory.</param>
        public static void CopyDirectory(VirtualDirectory sourceDirectory, UnifiedDirectory targetDirectory, string newName)
        {
            if (String.IsNullOrEmpty(newName))
            {
                newName = sourceDirectory.Name;
            }

            string targetVirtualDirectoryPath = VirtualPathUtility.Combine(targetDirectory.VirtualPath, newName);

            // TODO: Move this check into VirtualPath implementation. It may be OK depending on the implementation.
            // Copying a snapshot will work, but a recursive "live" copy operation will fail with infinite recursion.
            if (!ValidatePathStructureForMove(sourceDirectory.VirtualPath, targetVirtualDirectoryPath))
            {
                throw new ArgumentException("Copying a folder below itself is not allowed");
            }

            // Check if we are pasting a folder to same location it's copied from.
            if (VirtualPathUtility.GetDirectory(sourceDirectory.VirtualPath) == targetDirectory.VirtualPath)
            {
                throw new ArgumentException("Pasting a folder to the same location as the source folder is not allowed");
            }

            if (!IsPathAvailable(targetVirtualDirectoryPath))
            {
                throw new ArgumentException("Pasting a folder with the same name as a file or a folder in the target directory is not allowed");
            }

            UnifiedDirectory unifiedSourceDirectory = sourceDirectory as UnifiedDirectory;

            if (unifiedSourceDirectory != null)
            {
                unifiedSourceDirectory.CopyTo(targetVirtualDirectoryPath);
            }
            else
            {
                UnifiedDirectory newDirectory = UnifiedDirectory.CreateDirectory(targetVirtualDirectoryPath);
                foreach (VirtualFileBase childItem in sourceDirectory.Children)
                {
                    CopyItem(childItem, newDirectory);
                }
            }
        }
Example #16
0
        /// <summary>
        /// Appends the cookie crumb links to the control upplied as targetControl.
        /// </summary>
        /// <param name="currentDirectory">The current directory.</param>
        /// <param name="targetControl">The target control to append cookie crumb links to.</param>
        private void AppendBreadCrumbs(UnifiedDirectory currentDirectory, Control targetControl)
        {
            if (currentDirectory == null || FileManager.RootVirtualPath == currentDirectory.VirtualPath)
            {
                // Reset the link enumeration when we reach the topmost directory.
                _linkId = 0;
            }
            else
            {
                // Append cookie crumb for the parent directory before adding for the current directory.
                AppendBreadCrumbs(currentDirectory.Parent, targetControl);
                Literal slash = new Literal();
                slash.Text = " / ";
                targetControl.Controls.Add(slash);
            }
            if (currentDirectory == null)
            {
                return;
            }
            string directoryName = currentDirectory.Name;

            if (currentDirectory.Parent != null && currentDirectory.Parent.IsFirstLevel)
            {
                PageData page = UnifiedDirectory.GetOwnerPageFromVirtualPath(currentDirectory.VirtualPath);
                if (page != null)
                {
                    directoryName = page.PageName;
                }
            }

            LinkButton b = new LinkButton();

            b.ID               = "link" + _linkId++;
            b.Text             = directoryName;
            b.CausesValidation = false;
            b.CommandArgument  = currentDirectory.VirtualPath;
            b.CommandName      = FileManagerCommandName.SelectFolder;
            b.Command         += new CommandEventHandler(RaiseCommand);
            targetControl.Controls.Add(b);
        }
Example #17
0
        /// <summary>
        /// Changes the enabled state of buttons based on current file manager state.
        /// </summary>
        private void EnableButtons()
        {
            Details.Enabled = IsDetailsAllowed();
            Version.Enabled = IsVersionAllowed();

            UnifiedDirectory currentDirectory = FileManager.CurrentVirtualDirectory;

            if (currentDirectory != null && currentDirectory.QueryDistinctAccess(AccessLevel.Create | AccessLevel.Edit | AccessLevel.Delete))
            {
                DisabledFunctionsMessage.Visible = false;
                AddFile.Enabled      = IsDefaultView();
                AddFolder.Enabled    = IsDefaultView();
                Rename.Enabled       = IsRenameAllowed();
                Delete.Enabled       = IsChangeAllowed();
                Cut.Enabled          = IsChangeAllowed();
                Copy.Enabled         = IsDefaultView() && FileManager.SelectedItems.Count > 0;
                Paste.Enabled        = IsDefaultView() && FileManager.PasteBuffer.Count > 0;
                Checkout.Enabled     = IsCheckOutAllowed();
                UndoCheckout.Enabled = IsUndoCheckOutAllowed();
                CheckIn.Enabled      = IsCheckInAllowed();
            }
            else
            {
                DisabledFunctionsMessage.Visible = true;
                AddFile.Enabled      = false;
                AddFolder.Enabled    = false;
                Rename.Enabled       = false;
                Delete.Enabled       = false;
                Cut.Enabled          = false;
                Copy.Enabled         = false;
                Paste.Enabled        = false;
                Checkout.Enabled     = false;
                UndoCheckout.Enabled = false;
                CheckIn.Enabled      = false;
            }

            ApplyDisabledCssClassToDisabledButtons();
        }
Example #18
0
        // TODO: For nice flexibility this should be a wrapper with plug-in provider support.
        // Since the base provider API doesn't support any modifications at all, we need custom implementations for every modification.
        // The UnifiedFile and UnifiedDirectory provides abstract API for modifications, but it's likely that the individual inheritors
        // are incompatible with each other. Meaning that moving a file between different providers are likely to fail.



        /// <summary>
        /// Pastes the files in the source collection to the supplied target directory.
        /// </summary>
        /// <param name="sourceItems">A collection of source items to paste.</param>
        /// <param name="targetDirectory">The destination directory.</param>
        /// <param name="pasteMode">
        /// Determines how the source files are treated when the paste operation is performed.
        /// <list type="table">
        ///     <listheader>
        ///         <term>pasteMode</term><description>Result</description>
        ///     </listheader>
        ///     <item>
        ///         <term><see cref="PasteMode.Copy"/></term>
        ///         <description>The source items are copied to the new location.</description>
        ///     </item>
        ///     <item>
        ///         <term><see cref="PasteMode.Cut"/></term>
        ///         <description>The source items are moved from their original location to the new location.</description>
        ///     </item>
        /// </list>
        /// </param>
        public static void PasteFiles(VirtualFileBaseCollection sourceItems, UnifiedDirectory targetDirectory, PasteMode pasteMode)
        {
            // Have to assume unified file
            // The Versioning VPP has copy/move support built in, but only for operations inside the Versioning file systems.
            foreach (VirtualFileBase sourceItem in sourceItems)
            {
                try
                {
                    if (pasteMode == PasteMode.Copy)
                    {
                        CopyItem(sourceItem, targetDirectory);
                    }
                    else if (pasteMode == PasteMode.Cut)
                    {
                        MoveItem(sourceItem, targetDirectory);
                    }
                }
                catch (FileIsCheckedOutException)
                {
                    continue;
                }
            }
        }
        private List <VppFiles> ParseFiles(UnifiedDirectory directory)
        {
            var vppFiles = new List <VppFiles>();

            try
            {
                foreach (UnifiedFile file in directory.Files)
                {
                    var vppFile = new VppFiles
                    {
                        VirtualPath = file.VirtualPath,
                        VppPath     = file.LocalPath
                    };
                    vppFiles.Add(vppFile);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(vppFiles);
        }
 public virtual void OnUnifiedFileAdded(UnifiedDirectory sender, UnifiedVirtualPathEventArgs e)
 {
     if (UnifiedFileAdded != null)
         UnifiedFileAdded(sender, e);
 }
Example #21
0
        /// <summary>
        /// Creates a temporary file in the supplied directory.
        /// </summary>
        /// <param name="baseDirectory">The directory where the temporary file is created.</param>
        /// <returns>A Unified File</returns>
        public static UnifiedFile CreateTempFile(UnifiedDirectory baseDirectory)
        {
            string virtualPath = FindAvailableVirtualPath(VirtualPathUtility.Combine(baseDirectory.VirtualPath, TempFileName + TempFileExtension));

            return(baseDirectory.CreateFile(VirtualPathUtility.GetFileName(virtualPath)));
        }
Example #22
0
 /// <summary>
 /// Moves a virtual directopry to a new location.
 /// </summary>
 /// <param name="sourceDirectory">The source directory to be moved.</param>
 /// <param name="targetDirectory">The destination directory.</param>
 public static void MoveDirectory(VirtualDirectory sourceDirectory, UnifiedDirectory targetDirectory)
 {
     MoveDirectory(sourceDirectory, targetDirectory, null);
 }
Example #23
0
 /// <summary>
 /// Moves a virtual file to another directory.
 /// </summary>
 /// <param name="sourceFile">The source file to be moved.</param>
 /// <param name="targetDirectory">The destination directory.</param>
 public static void MoveFile(VirtualFile sourceFile, UnifiedDirectory targetDirectory)
 {
     MoveFile(sourceFile, targetDirectory, null);
 }
Example #24
0
        private void GetImages(HashSet<string> images, UnifiedDirectory directory)
        {
            UnifiedFile[] files = directory.GetFiles();

            foreach (UnifiedFile file in files)
            {
                if (IsImage(file.Extension))
                {
                    images.Add(file.VirtualPath);
                }
            }

            UnifiedDirectory[] subDirectories = directory.GetDirectories();

            foreach (UnifiedDirectory subDirectory in subDirectories)
            {
                GetImages(images, subDirectory);
            }
        }
Example #25
0
 /// <summary>
 /// Moves a virtual file or folder to a new location.
 /// </summary>
 /// <param name="sourceItem">The source item to be moved.</param>
 /// <param name="targetDirectory">The destination directory.</param>
 public static void MoveItem(VirtualFileBase sourceItem, UnifiedDirectory targetDirectory)
 {
     MoveItem(sourceItem, targetDirectory, null);
 }
Example #26
0
 /// <summary>
 /// Creates a new directory in the supplied parent directory.
 /// </summary>
 /// <param name="parentDirectory">The parent directory in which to create a sub directory.</param>
 /// <param name="directoryName">Name of the new directory.</param>
 public static void CreateDirectory(UnifiedDirectory parentDirectory, string directoryName)
 {
     parentDirectory.CreateSubdirectory(directoryName);
 }
 public virtual void OnUnifiedDirectoryAdding(UnifiedDirectory sender, UnifiedVirtualPathEventArgs e)
 {
     if (UnifiedDirectoryAdding != null)
         UnifiedDirectoryAdding(sender, e);
 }