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);
}
}
