internal static AllowedOperation GetAllowedOperationAddRecipient(FolderIdentifier folderIdentifier, FolderModel folder) { var recipients = folder.MetaEDiscoveryRecipientListRead(); var defenseEmail = folder.Read <string>("attribute.defense.email"); AddRecipientRequest.AddRecipientDefaults defaults = defenseEmail == null || recipients.Any(r => r.Email == defenseEmail) ? new AddRecipientRequest.AddRecipientDefaults() : new AddRecipientRequest.AddRecipientDefaults { FirstName = folder.Read <string>("attribute.defense.first"), LastName = folder.Read <string>("attribute.defense.last"), Email = folder.Read <string>("attribute.defense.email") }; return(new AllowedOperation { DisplayName = "Add Recipient", IsSingleton = true, BatchOperation = new AddRecipientRequest { FolderIdentifier = folderIdentifier, Defaults = defaults } }); }
private Dictionary <string, string> FieldsFromMetadata(FolderModel folderModel, FileModel fileModel) { var fields = new Dictionary <string, string>(); var attributeLocators = folderModel.Read <List <AttributeLocator> >(MetadataKeyConstants.ATTRIBUTE_LOCATORS); if (attributeLocators != null) { foreach (var locator in attributeLocators) { if (locator.IsIndexed) { try { var value = fileModel.Read <string>(locator.Key) ?? folderModel.Read <string>(locator.Key); fields.Add(locator.Key, value); } catch (Exception) { // well... we tried } } } } return(fields); }
public void Read(FolderModel folder, bool skipFiles = false, bool skipFolderPaths = false, Func <FileModel, PathIdentifier> pathReader = null) { if (pathReader == null) { pathReader = APIModelExtensions.MetaPathIdentifierRead; } if (!skipFolderPaths) { Add(folder.Read("_paths", defaultValue: new List <string>()) .Select(p => new PathIdentifier(this.FolderIdentifier, p)) .ToList()); } if (!skipFiles) { // find any paths mentioned on folders foreach (var file in folder.Files.Rows) { var pathIdentifier = pathReader(file); if (pathIdentifier != null) { Add(pathIdentifier); } } } Process(); }
private async Task <long> MovePathToPath( FolderModel folder, PathIdentifier destinationPathIdentifier, PathIdentifier sourcePathIdentifier ) { // if we're moving // z of x/y/z to a/b/c // then pathDestination will be a/b/c/z var pathDestination = destinationPathIdentifier.CreateChild(sourcePathIdentifier.LeafName); long affectedCount = 0; // find files in contained by our source path, or a child of it var descendants = GetPathDescendants(folder, sourcePathIdentifier); foreach (var file in descendants) { var path = file.MetaPathIdentifierRead(); // todo: move this logic to PathProcessor // replace the old key with the new key path.PathKey = Regex.Replace ( path?.PathKey, $"^{Regex.Escape(sourcePathIdentifier.PathKey)}", pathDestination.PathKey ); file.MetaPathIdentifierWrite(path); await Connection.File.PutAsync(file); affectedCount++; } // update the folder's path reservations var paths = folder.Read <List <string> >("_paths"); if (paths != null) { var pathsAffected = 0; for (int i = 0; i < paths.Count; i++) { if (paths[i].StartsWith(sourcePathIdentifier.PathKey)) { pathsAffected++; paths[i] = paths[i].Replace( sourcePathIdentifier.PathKey, pathDestination.PathKey ); } } if (pathsAffected > 0) { folder.Write("_paths", paths); await Connection.Folder.PutAsync(folder); } } return(affectedCount); }
public static PasswordTouple GeneratePassword(FolderModel folder, string randomPasswordLengthLocation, string defaultPasswordLength, string passwordCharacterSetLocation) { var lengthValue = folder.Read <string>(randomPasswordLengthLocation) ?? defaultPasswordLength; var length = Int32.Parse(lengthValue); var charSet = folder.Read <string>(passwordCharacterSetLocation); // first generate a password var plainPassword = PasswordGenerator.GetRandomString(length, charSet); // Now generate a hash var hashedPassword = BCrypt.HashPassword(plainPassword); return(new PasswordTouple() { Plain = plainPassword, Hashed = hashedPassword }); }
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); }
public static List <ExternalUser> MetaExternalUserListRead(this FolderModel folder, string metadataKeyLocation, bool includeHash = true) { var externalUsers = folder.Read <List <ExternalUser> >(metadataKeyLocation, defaultValue: new List <ExternalUser>()); if (!includeHash) { foreach (var externalUser in externalUsers) { externalUser.PasswordHash = null; } } return(externalUsers); }
private List <FacetString> FacetsFromMetadata(FolderModel folderModel, FileModel fileModel) { var facets = new List <FacetString>(); var attributeLocators = folderModel.Read <List <AttributeLocator> >(MetadataKeyConstants.ATTRIBUTE_LOCATORS); if (attributeLocators != null) { foreach (var locator in attributeLocators) { if (locator.IsFacet) { var value = fileModel.Read <string>(locator.Key) ?? folderModel.Read <string>(locator.Key); facets.Add(new FacetString { Name = locator.Key, Value = value }); } } } var extension = fileModel.Extension; if (extension != null && extension.Length > 4) { extension = null; } facets.Add(new FacetString { Name = "extension", Value = extension }); return(facets); }
private async Task <ModelBase> RemoveOfficerAsync(RemoveOfficerRequest removeRequest) { FolderModel folder = null; await connection.ConcurrencyRetryBlock(async() => { folder = await connection.Folder.GetAsync(removeRequest.FolderIdentifier); var recipients = folder.MetaLEOUploadOfficerListRead(); var recipient = recipients.FirstOrDefault(f => f.Email == removeRequest.RecipientEmail); folder.MetaLEOUploadOfficerListRemove(removeRequest.RecipientEmail); var paths = folder.Read <List <string> >("_paths"); if (paths != null && recipient != null) { var officerPath = GetOfficerPath(folder.Identifier, recipient.FirstName, recipient.LastName); if (paths.Contains(officerPath.PathKey)) { paths = paths.Where(p => !p.StartsWith(officerPath.PathKey)).ToList(); } folder.Write("_paths", paths); } await connection.Folder.PutAsync(folder); }); await InitializePrivilegedConnectionAsync(); // Using the special connection here to delete the user. await privilegedConnection.User.DeleteAsync(ModuleUtility.GetFolderScopedUserIdentifier(folder.Identifier, removeRequest.RecipientEmail, "leo")); await this.auditLogStore.AddEntry( new AuditLogEntry() { EntryType = AuditLogEntryType.LEOUploadOfficerDeleted, Message = $"An officer has been removed {removeRequest.RecipientEmail}", ModuleType = Modules.ModuleType.LEOUpload }, folder.Identifier ); return(new RecipientResponse() { Email = removeRequest.RecipientEmail, }); }
public static DateTime?GetLinkExpirationDate(FolderModel folder, string ExpirationSecondsMetadataKeyLocation) { int?expirationSeconds = 2592000; // This is 30 days as a default if there's no settings in the databse. var expirationSecondsMetadata = folder.Read <int>(ExpirationSecondsMetadataKeyLocation); if (expirationSecondsMetadata > 0) { expirationSeconds = expirationSecondsMetadata; } DateTime?expirationDate = null; if (expirationSeconds != null) { expirationDate = DateTime.UtcNow.AddSeconds(expirationSeconds.Value); } return(expirationDate); }
private async Task UpsertPackageMap(FolderModel folder, string packageName, string customName) { // Here we're going to create a package map if one doesn't exist. var packageMap = folder.Read <EDiscoveryPackageMap>(MetadataKeyConstants.E_DISCOVERY_PACKAGE_MAP_METAKEY); // If this is the first package, we're going to create a package map. if (packageMap == null) { packageMap = new EDiscoveryPackageMap { Map = new Dictionary <string, PackageAttributes>() }; } packageMap.Map.Add(packageName, new PackageAttributes() { CustomName = customName }); folder.Write <EDiscoveryPackageMap>(MetadataKeyConstants.E_DISCOVERY_PACKAGE_MAP_METAKEY, packageMap); await connection.Folder.PutAsync(folder); }
public ManagerFolderModel ModelConvert(FolderModel folderModel) { var managerModel = new ManagerFolderModel { Identifier = folderModel.Identifier }; managerModel.Fields = new Dictionary <string, object>(); var fields = ReadMetadataFields(folderModel); if (fields != null) { foreach (var field in fields) { managerModel.Fields.Add( field.Identifier, folderModel.Read <string>(field.Key) ); } } return(managerModel); }
private static ManagerFieldBaseSchema GetFieldSchema(FolderModel folder) { return(folder.Read <ManagerFieldBaseSchema>(MetadataKeyConstants.SCHEMA_DEFINITION)); }
public static DataViewModel BuildDataViewModel(FolderModel folder) { // First we grab the schema. var schema = GetFieldSchema(folder); var dataModel = new Dictionary <string, object>(); // Now we have the schema we also need to build up the data model as well. if (schema != null && schema is ManagerFieldObject) { var managerFieldObject = schema as ManagerFieldObject; foreach (var property in managerFieldObject.Properties) { if (property.Value is ManagerFieldString) { dataModel.Add( property.Value.AttributeStorageLocationKey, // Read out of metadata, the property.value, which will be a base schema object. That object will have a AttributeStorageLocationKey // this will be where the actual value of this data is stored. folder.Read <string>(property.Value.AttributeStorageLocationKey) ); } if (property.Value is ManagerFieldInt) { dataModel.Add( property.Value.AttributeStorageLocationKey, folder.Read <int>(property.Value.AttributeStorageLocationKey) ); } if (property.Value is ManagerFieldBoolean) { dataModel.Add( property.Value.AttributeStorageLocationKey, folder.Read <bool>(property.Value.AttributeStorageLocationKey) ); } if (property.Value is ManagerFieldObject) { dataModel.Add( property.Value.AttributeStorageLocationKey, folder.Read <object>(property.Value.AttributeStorageLocationKey) ); } if (property.Value is ManagerFieldDecimal) { dataModel.Add( property.Value.AttributeStorageLocationKey, folder.Read <decimal>(property.Value.AttributeStorageLocationKey) ); } } return(new DataViewModel { DataModel = dataModel, DataSchema = schema, AllowedOperations = new List <AllowedOperation>() { AllowedOperation.GetAllowedOperationSave(folder.Identifier), } }); } else { return(null); } }
public override bool IsModuleActive(FolderModel folder) { //First we need to determine based on metadata whether leo upload is active for this folder. return(folder.Read <bool>(MetadataKeyConstants.LEO_UPLOAD_ACTIVE_METAKEY)); }
private List <ManagerFieldsMetadataModel> ReadMetadataFields(FolderModel folderModel) { return(folderModel.Read <List <ManagerFieldsMetadataModel> >(ManagerFieldsMetadataModel.METADATA_KEY_LIST)); }
public override bool IsModuleActive(FolderModel folder) { //First we need to determine based on metadata whether eArraignment is active for this folder. return(folder.Read <bool>(E_ARRAIGNMENT_ACTIVE)); }
public override bool IsModuleActive(FolderModel folder) { //First we need to determine based on metadata whether E-Discovery is active for this folder. return(folder.Read <bool>(MetadataKeyConstants.E_DISCOVERY_ACTIVE_METAKEY)); }