public EDiscoveryManagerPathModel GetNotSharedYetPath(FolderModel folder) { // We need to get the staged count, as it will allow us to A. determine if we're going to show the not shared yet folder, // and B. a cound on the not shared yet folder. var stagedCount = EDiscoveryUtility.GetStagedCount(folder); var notSharedIdentifier = new PathIdentifier(folder.Identifier, EDiscoveryUtility.E_DISCOVERY_NOT_SHARED_PATH_KEY); var processor = new PathProcessor(folder.Identifier); processor.Read(folder, skipFolderPaths: true, pathReader: f => { if (f.ShareState() != EDiscoveryShareState.Staged) { return(null); } var sharePath = f.MetaEDiscoveryPathIdentifierRead(); if (sharePath != null) { return(notSharedIdentifier.CreateChild(sharePath.PathKey)); } return(null); }); return(new EDiscoveryManagerPathModel() { Identifier = notSharedIdentifier, Icons = new string[] { EDiscoveryUtility.EDISCOVERY_FOLDER_COLOR_STYLE }, Name = $"Not Shared Yet ({stagedCount.ToString()})", FullPath = "eDiscovery/Not Shared Yet", AllowedOperations = null, Paths = processor[notSharedIdentifier]?.Paths }); }
public List <EDiscoveryManagerPathModel> BuildDatedPackagesDynamicFolder(FolderModel folder) { var managerPaths = new List <EDiscoveryManagerPathModel>(); var packageMap = folder.Read <EDiscoveryPackageMap>(MetadataKeyConstants.E_DISCOVERY_PACKAGE_MAP_METAKEY); if (this.IsModuleActive(folder)) { // go through all the folders, and find all the foreach (var file in folder.Files.Rows .Where(f => f.Read <string>(MetadataKeyConstants.E_DISCOVERY_SHARE_PACKGAGE) != null) ) { var sharePackageName = file.Read <string>(MetadataKeyConstants.E_DISCOVERY_SHARE_PACKGAGE); var sharePackageIdentifier = new PathIdentifier(file.Identifier as FolderIdentifier, "eDiscovery/" + sharePackageName); // Here we're checking to make sure we haven't already added this 'dated share folder' if (!managerPaths.Any(mp => mp.Identifier.Equals(sharePackageIdentifier))) { var processor = new PathProcessor(folder.Identifier); processor.Read(folder, skipFolderPaths: true, pathReader: f => { var sharePath = f.MetaEDiscoveryPathIdentifierRead(); if (sharePackageName != null && f.Read <string>(MetadataKeyConstants.E_DISCOVERY_SHARE_PACKGAGE) != sharePackageName) { return(null); } if (sharePath != null) { return(sharePackageIdentifier.CreateChild(sharePath.PathKey)); } else { return(sharePath); } }); var packagePath = new EDiscoveryManagerPathModel() { Identifier = sharePackageIdentifier, Icons = new string[] { EDiscoveryUtility.EDISCOVERY_FOLDER_COLOR_STYLE }, Name = sharePackageName, FullPath = sharePackageIdentifier.FullName, Paths = processor[sharePackageIdentifier]?.Paths, CustomName = EDiscoveryUtility.GetCustomName(packageMap, sharePackageName), AllowedOperations = EDiscoveryUtility.IsUserEDiscovery(connection.UserAccessIdentifiers) ? new AllowedOperation[] { } : new AllowedOperation[] { AllowedOperation.GetAllowedOperationEditPackageName(folder.Identifier, sharePackageName) }, }; managerPaths.Add(packagePath); } } } return(managerPaths); }
protected override void AddSubpaths(List <IModule> activeModules, PathIdentifier identifier) { if (PackageIdentifier == null) { return; } var processor = new PathProcessor(identifier); processor.Read(state.Folder, skipFolderPaths: true, pathReader: f => { var sharePath = f.MetaEDiscoveryPathIdentifierRead(); if (PackageIdentifier.PathKey != EDiscoveryUtility.E_DISCOVERY_ALL_PACKAGE_PATH_KEY && f.Read <string>(MetadataKeyConstants.E_DISCOVERY_SHARE_PACKGAGE) != PackageName && f.Read <string>(MetadataKeyConstants.E_DISCOVERY_SHARE_PACKGAGE) != null) { return(null); } if (sharePath != null) { return(PackageIdentifier.CreateChild(sharePath.PathKey)); } else { return(sharePath); } }); var paths = RelativePathIdentifier != null ? processor[PackageIdentifier.CreateChild(RelativePathIdentifier.PathKey)].Paths : processor[PackageIdentifier].Paths; foreach (var p in paths) { allRows.Add(new ManagerPathModel { Identifier = p.Identifier, AllowedOperations = GetSubPathOperations(activeModules, p.Identifier), FullPath = p.FullPath, Icons = p.Icons, Name = p.Name, Paths = null }); } base.AddSubpaths(activeModules, identifier); }
public async Task <IEnumerable <ManagerPathModel> > SuggestAsync( PathIdentifier identifier, CancellationToken cancellationToken = default(CancellationToken) ) { if (identifier == null) { throw new ArgumentNullException(nameof(identifier)); } // we're querying the folder at this path location // presumably the one we are about to create a new folder in. // so we check the template structure (state.Structure) // and compare it to our current tree. var suggestedFolder = await Connection.Folder.GetAsync( new FolderIdentifier(identifier as OrganizationIdentifier, ":suggestedpaths") ); if (suggestedFolder != null) { // take note that we're NOT using the suggestedPath folder identifier // below. we're using the local path identifier var suggestedProcessor = new PathProcessor(identifier as FolderIdentifier); suggestedProcessor.Read(suggestedFolder, skipFiles: true); var structurePath = suggestedProcessor[identifier]; // not just pulling the folder, because OpenFolder may add paths for a variety of reasons var stateThisFolder = await OpenFolder(identifier as FolderIdentifier); var thisPath = stateThisFolder.Paths[identifier]; // suggestedPaths. // reject any subpaths that already exist return(structurePath.Paths? .Where(s => thisPath.Paths == null || !thisPath.Paths.Any(p => p.FullPath == s.FullPath)) ?? new ManagerPathModel[0]); } else { return(new ManagerPathModel[0]); } }
public override void BuildDynamicFolders(PathIdentifier identifier, ItemQueryResponse page, FolderModel folder, bool isRestrictedView) { if (!page?.PathTree?.Paths?.Any(p => p.Identifier.PathKey == EDiscoveryUtility.E_DISCOVERY_PATH_KEY) ?? false) { if (page.PathTree.Paths == null) { page.PathTree.Paths = new List <ManagerPathModel>(); } var managerPathModels = new List <ManagerPathModel>(); // we have to build up the children first. // First we get all the dated package dynamic paths. var datedPackagePaths = BuildDatedPackagesDynamicFolder(folder); var eDiscoveryIdentifier = new PathIdentifier(identifier) { PathKey = EDiscoveryUtility.E_DISCOVERY_PATH_KEY }; // Last the parent / root node of 'eDiscovery' var eDiscoveryPath = new ManagerPathModel { Identifier = eDiscoveryIdentifier, Icons = new string[] { EDiscoveryUtility.EDISCOVERY_FOLDER_COLOR_STYLE }, Name = EDiscoveryUtility.E_DISCOVERY_PATH_NAME, FullPath = EDiscoveryUtility.E_DISCOVERY_PATH_KEY, AllowedOperations = null, Paths = new List <ManagerPathModel>(), IsExpanded = datedPackagePaths.Count > 0 || EDiscoveryUtility.GetStagedCount(folder) > 0, }; if (datedPackagePaths.Any()) { var allPackagesIdentifier = new PathIdentifier(identifier as FolderIdentifier, EDiscoveryUtility.E_DISCOVERY_ALL_PACKAGE_PATH_KEY); var packageName = "All"; var processor = new PathProcessor(folder.Identifier); processor.Read(folder, skipFolderPaths: true, pathReader: f => { var sharePath = f.MetaEDiscoveryPathIdentifierRead(); if (sharePath != null) { return(allPackagesIdentifier.CreateChild(sharePath.PathKey)); } else { return(sharePath); } }); datedPackagePaths.Insert(0, new EDiscoveryManagerPathModel() { Identifier = allPackagesIdentifier, Icons = new string[] { EDiscoveryUtility.EDISCOVERY_FOLDER_COLOR_STYLE }, Name = packageName, FullPath = allPackagesIdentifier.FullName, Paths = processor[allPackagesIdentifier]?.Paths }); } eDiscoveryPath.Paths = eDiscoveryPath.Paths.Concat(datedPackagePaths).ToList(); if (!isRestrictedView) { eDiscoveryPath.Paths.Add(GetNotSharedYetPath(folder)); } page.PathTree.Paths.Add(eDiscoveryPath); } }