private async Task ConfigureVideoWatermarkingAsync(OrganizationModel organizationModel)
{
var folderIdentifier = new FolderIdentifier(organizationModel.Identifier, ":watermarks");
var folder = await api.Folder.GetAsync(folderIdentifier);
if (folder == null)
{
folder = await api.Folder.PutAsync(new FolderModel(folderIdentifier));
}
var fileIdentifier = new FileIdentifier(folder.Identifier, "video.png");
var file = await api.File.GetAsync(fileIdentifier);
if (file == null)
{
var assembly = typeof(PCMSProvisioning).Assembly;
using (var stream = assembly.GetManifestResourceStream("Documents.Provisioning.Resources.watermarks.video.png"))
await api.File.UploadAsync(
new FileModel(fileIdentifier)
{
MimeType = "image/png",
Name = "video.png",
Length = stream.Length
},
stream
);
}
}
public async Task <PathServiceState> OpenFolder(FolderIdentifier identifier, bool skipPathParse = false, CancellationToken cancellationToken = default(CancellationToken))
{
var folder = await Connection.Folder.GetAsync(identifier, new List <PopulationDirective>
{
new PopulationDirective
{
Name = nameof(FolderModel.Files)
// and paging bits
}
});
if (folder != null)
{
var state = new PathServiceState()
{
Folder = folder,
Paths = new PathProcessor(identifier)
};
// add and filter the path reservations from metadata
if (!skipPathParse)
{
state.Paths.Read(state.Folder);
}
return(state);
}
else
{
throw new Exception("Folder does not exist");
}
}
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
}
});
}
public async Task <PagedResults <AuditLogEntryModel> > ReadLog(FolderIdentifier folderIdentifier)
{
var logs = await connection.Log.LoadAsync(new[]
{
new PopulationDirective
{
MetadataFilter = new List <MetadataMatchModel>
{
new MetadataMatchModel
{
Name = "OrganizationKey",
Operator = "==",
Value = folderIdentifier.OrganizationKey
},
new MetadataMatchModel
{
Name = "FolderKey",
Operator = "==",
Value = folderIdentifier.FolderKey
},
new MetadataMatchModel
{
Name = "InternalOnly",
Operator = "==",
Value = "true"
}
}
}
});
return(logs);
}
public PathProcessor(FolderIdentifier folderIdentifier)
{
this.PathMap = new Dictionary <PathIdentifier, ManagerPathModel>();
this.FolderIdentifier = folderIdentifier;
Add(PathIdentifier.Root(folderIdentifier));
}
/// <summary>
/// This will move all the files from the not shared yet folder, and change their state to published. Adding comment
/// </summary>
public async Task PublishFolder(FolderIdentifier folderIdentifier, string customName)
{
// Setup our state so we have everything we need.
var folder = await connection.Folder.GetAsync(folderIdentifier, new List <PopulationDirective>
{
new PopulationDirective
{
Name = nameof(FolderModel.Files)
}
});
var packageDate = DateTime.UtcNow.ConvertToLocal(connection.UserTimeZone).ToString("MM/dd/yyyy hh:mm");
// we need to create a dated package into which will move these files.
var packageName = "Discovery Package: " + packageDate;
// we need to find all the files that are currently in the "Not Yet Shared" Folder.
var allFiles = folder.Files.Rows.ToList(); //A collection of files that we will use to build up our response.
// We need a list of files that we published, so we can generate our manifest
var publishedFiles = new List <FileModel>();
foreach (var file in allFiles)
{
// Get the current share state of the file
var shareState = file.Read <string>(MetadataKeyConstants.E_DISCOVERY_SHARE_STATE_META_KEY);
//TODO Check to make sure this .toString() on the enum will filter correctly.
if (shareState != null && shareState == EDiscoveryShareState.Staged.ToString())
{
// commenting this out for now. I really want to work on how I should create these dated packages.
UpdateShareState(file, EDiscoveryShareState.Published);
TagSharePackage(file, packageName);
await connection.File.PutAsync(file);
publishedFiles.Add(file);
}
}
await UpsertPackageMap(folder, packageName, customName);
await this.GenerateManifest(
publishedFiles,
new PathIdentifier(folderIdentifier, "Compliance Reports"),
packageName,
packageDate
);
await this.auditLogStore.AddEntry(
new AuditLogEntry()
{
EntryType = AuditLogEntryType.eDiscoveryPackageCreated,
Message = "A Discovery Package was created.",
ModuleType = Modules.ModuleType.eDiscovery
},
folderIdentifier
);
}
private static List <AllowedOperation> GetAllowedOperationsForRecipient(FolderIdentifier folderIdentifier, ExternalUser recipient)
{
return(new List <AllowedOperation>()
{
AllowedOperation.GetAllowedOperationRegenPassword(folderIdentifier, recipient.Email),
AllowedOperation.GetAllowedOperationRemoveRecipient(folderIdentifier, recipient.Email),
});
}
public static UserIdentifier GetFolderScopedUserIdentifier(FolderIdentifier folderIdentifier, string userEmail, string prefix = null)
{
if (prefix != null)
{
prefix = $"{prefix}:";
}
return(new UserIdentifier(folderIdentifier as OrganizationIdentifier, $"{prefix}{folderIdentifier.FolderKey}:{userEmail}"));
}
private async Task <bool> FolderPrivilegeCheck(FolderIdentifier identifier, string privilegeName)
{
return((
await GetStore <IFolderStore>()
.GetOneAsync(identifier)
)
.PrivilegeCheck(privilegeName, SecurityContext));
}
public PathIdentifier GetOfficerPath(FolderIdentifier folderIdentifier, string firstName, string lastName)
{
var leoUploadFolder = new PathIdentifier(folderIdentifier, LEOUploadUtility.LEO_UPLOAD_PATH_KEY);
// Here we're adding a child folder to the leo upload whenever we add a new officer.
var childPath = leoUploadFolder.CreateChild($"{firstName} {lastName}");
return(childPath);
}
public async Task <PCMSAPIResponse <URLs> > GetURLs(
[FromBody] APIRequest <URLRequest> request
)
{
CheckAuthentication(request);
var connection = await ConnectionCreate(request);
var token = connection.Token;
var folderIdentifier = new FolderIdentifier(connection.UserIdentifier.OrganizationKey, $"Defendant:{request.Context.DefendantID}");
var folder = await connection.Folder.GetAsync(folderIdentifier);
if (folder == null)
{
folder = await connection.Folder.PutAsync(new FolderModel(folderIdentifier));
}
string autoDownloadKeys = null;
if (request.Parameters?.AutoDownloadUniques?.Any() ?? false)
{
autoDownloadKeys = string.Join("||", request.Parameters.AutoDownloadUniques);
}
token = UrlEncoder.Default.Encode(token);
var urlFormat = Configuration.FinalURL;
if (request.Parameters?.DeepLink != null)
{
urlFormat = Configuration.FinalURLDeepLink;
}
var redirect =
string.Format(
urlFormat,
request.Context.DefendantID,
UrlEncoder.Default.Encode(autoDownloadKeys ?? string.Empty),
request.Context.CountyID,
UrlEncoder.Default.Encode(request.Parameters?.DeepLink ?? string.Empty)
);
return(new PCMSAPIResponse <URLs>
{
Response = new URLs
{
IFrame = BuildHandoffURL(
redirect,
token),
GlobalSearch = BuildHandoffURL(
string.Format(Configuration.GlobalSearchURL, request.Context.CountyID),
token),
}
});
}
public static AllowedOperation GetAllowedOperationRequestOnlineFolder(FolderIdentifier folderIdentifier)
{
return(new AllowedOperation
{
DisplayName = "Restore Case",
BatchOperation = new RequestOnlineRequest
{
FolderIdentifier = folderIdentifier
}
});
}
public static AllowedOperation GetAllowedOperationSearch(FolderIdentifier folderIdentifier)
{
return(new AllowedOperation()
{
DisplayName = "Search",
IsSingleton = true,
BatchOperation = new Requests.SearchRequest()
{
FolderIdentifier = folderIdentifier,
}
});
}
public static AllowedOperation GetAllowedOperationPublish(FolderIdentifier folderIdentifier, int recipientCount)
{
return(new AllowedOperation()
{
DisplayName = "Turn Over",
BatchOperation = new PublishRequest()
{
FolderIdentifier = folderIdentifier,
eDiscoveryRecipientCount = recipientCount,
}
});
}
public static AllowedOperation GetAllowedOperationRemoveRecipient(FolderIdentifier folderIdentifier, string email)
{
return(new AllowedOperation()
{
DisplayName = "Remove Recipient",
BatchOperation = new RemoveRecipientRequest()
{
FolderIdentifier = folderIdentifier,
RecipientEmail = email,
}
});
}
private async Task IndexFolder(ISearch driver, FolderIdentifier folderIdentifier)
{
var pageIndex = 0;
var done = false;
await driver.DeleteFolderAsync(API.UserAccessIdentifiers, folderIdentifier);
while (!done)
{
var folderModel = await API.Folder.GetAsync(folderIdentifier, new List <PopulationDirective>
{
new PopulationDirective(nameof(FolderModel.Files))
{
Paging = new PagingArguments
{
PageSize = QUERY_PAGE_SIZE,
PageIndex = pageIndex
}
}
});
if (folderModel != null)
{
var files = folderModel.Files.Rows;
folderModel.Files.Rows = null; // decreasing the size of the next messages
foreach (var batch in files.Batch(ENQUEUE_BATCH_SIZE))
{
await API.Queue.EnqueueAsync(batch
.Where(f => !f.Read <bool>(MetadataKeyConstants.HIDDEN, defaultValue: false))
.Select(file => new QueuePair
{
QueueName = "Index",
Message = JsonConvert.SerializeObject(new IndexMessage
{
Action = IndexMessage.IndexActions.IndexFile,
Identifier = file.Identifier,
FolderModel = folderModel,
FileModel = file
})
}));
}
pageIndex++;
done = files.Count() < QUERY_PAGE_SIZE;
}
else
{
done = true;
}
}
}
internal static AllowedOperation GetAllowedOperationAddOfficer(FolderIdentifier folderIdentifier)
{
return(new AllowedOperation
{
DisplayName = "Add Officer",
IsSingleton = true,
BatchOperation = new AddOfficerRequest
{
FolderIdentifier = folderIdentifier
}
});
}
public static AllowedOperation GetAllowedOperationSave(FolderIdentifier folderIdentifier = null, FileIdentifier fileIdentifier = null)
{
return(new AllowedOperation()
{
IsSingleton = true,
BatchOperation = new SaveRequest()
{
FolderIdentifier = folderIdentifier, FileIdentifier = fileIdentifier
},
DisplayName = "Save",
Icons = new string[] { "save" },
});
}
public async Task <List <AuditLogEntry> > GetAllEntries(FolderIdentifier identifier)
{
var folder = await connection.Folder.GetAsync(identifier);
var entries = folder.Read <List <AuditLogEntry> >(AUDIT_LOG_LOCATION);
if (entries == null)
{
return(new List <AuditLogEntry>());
}
return(entries);
}
public static AllowedOperation GetAllowedOperationRegenPassword(FolderIdentifier folderIdentifier, string email)
{
return(new AllowedOperation()
{
DisplayName = "Regenerate Access Link/Password",
IsSingleton = true,
BatchOperation = new RegenerateRecipientPasswordRequest()
{
FolderIdentifier = folderIdentifier,
RecipientEmail = email
}
});
}
public static AllowedOperation GetAllowedOperationEditPackageName(FolderIdentifier folderIdentifier, string packageName)
{
return(new AllowedOperation()
{
DisplayName = "Edit Description",
IsSingleton = true,
BatchOperation = new EditPackageNameRequest()
{
FolderIdentifier = folderIdentifier,
PackageName = packageName,
}
});
}
private async Task ConfigureNotificationTemplatesAsync(OrganizationModel organizationModel)
{
var folderIdentifier = new FolderIdentifier(organizationModel.Identifier, ":templates");
var folder = await api.Folder.GetAsync(folderIdentifier);
if (folder == null)
{
folder = await api.Folder.PutAsync(new FolderModel(folderIdentifier));
}
var assembly = typeof(PCMSProvisioning).Assembly;
FileModel file = null;
FileIdentifier fileIdentifier = null;
fileIdentifier = new FileIdentifier(folder.Identifier, "upload.body.mustache");
file = await api.File.GetAsync(fileIdentifier);
if (file == null)
{
using (var stream = assembly.GetManifestResourceStream("Documents.Provisioning.Resources.templates.upload.body.mustache"))
await api.File.UploadAsync(
new FileModel(fileIdentifier)
{
MimeType = "text/plain",
Name = "upload.body.mustache",
Length = stream.Length
},
stream
);
}
fileIdentifier = new FileIdentifier(folder.Identifier, "upload.subject.mustache");
file = await api.File.GetAsync(fileIdentifier);
if (file == null)
{
using (var stream = assembly.GetManifestResourceStream("Documents.Provisioning.Resources.templates.upload.subject.mustache"))
await api.File.UploadAsync(
new FileModel(fileIdentifier)
{
MimeType = "text/plain",
Name = "upload.subject.mustache",
Length = stream.Length
},
stream
);
}
}
private async Task ConfigureSuggestedPathsFolder(OrganizationModel organizationModel, PCMSOrganizationModel pcms)
{
var suggestedPathsFolderIdentifier = new FolderIdentifier(organizationModel.Identifier, ":suggestedpaths");
var suggestedPathsFolder = await api.Folder.GetAsync(suggestedPathsFolderIdentifier)
?? new FolderModel(suggestedPathsFolderIdentifier)
.InitializeEmptyMetadata()
.InitializeEmptyPrivileges();
if (suggestedPathsFolder.Read <List <string> >("_paths") == null)
{
suggestedPathsFolder.Write("_paths", new string[0]);
await api.Folder.PutAsync(suggestedPathsFolder);
}
}
public async Task <List <AuditLogEntry> > GetEntries(FolderIdentifier identifier, ModuleType moduleType)
{
var folder = await connection.Folder.GetAsync(identifier);
var entries = folder.Read <List <AuditLogEntry> >(AUDIT_LOG_LOCATION);
if (entries != null)
{
//if(moduleType == ModuleType.eDiscovery)
//{
// return entries.Where(entry => entry.ModuleType == moduleType || entry.ModuleType == null).ToList();
//}
return(entries.Where(entry => entry.ModuleType == moduleType).OrderByDescending(e => e.Created).ToList());
}
return(new List <AuditLogEntry>());
}
private async Task <long> FolderIDLookup(FolderIdentifier identifier)
{
var folderEntity = await Database.Folder
.Where(f => f.FolderKey == identifier.FolderKey)
.Where(f => f.Organization.OrganizationKey == identifier.OrganizationKey)
.FirstOrDefaultAsync();
if (folderEntity == null)
{
throw new ObjectNotFound();
}
else
{
return(folderEntity.FolderID);
}
}
public async Task <FolderModel> PrivateFolderLoadAsync(OrganizationIdentifier organizationIdentifier)
{
var folderIdentifier = new FolderIdentifier(organizationIdentifier, PRIVATE_FOLDERKEY);
FolderStore.PrivilegeRead = "gateway";
var folder = await FolderStore.GetOneAsync(folderIdentifier);
if (folder == null)
{
folder = await FolderStore.InsertAsync(new FolderModel
{
Identifier = folderIdentifier
});
}
return(folder);
}
async Task ISearch.DeleteFolderAsync(
string[] securityIdentifiers,
FolderIdentifier folderIdentifier
)
{
Logger.LogInformation($"Delete {folderIdentifier}");
await client.DeleteByQueryAsync <Document>(s => s
.Query(q => q
.Bool(b => b
.Filter(
f => f.Term(d => d.OrganizationKey, folderIdentifier.OrganizationKey),
f => f.Term(d => d.FolderKey, folderIdentifier.FolderKey),
f => DoSecurity(f, securityIdentifiers)
)
)
)
);
}
public async Task <EDiscoveryStatisticsResponse> GetEDiscoveryStatistics(FolderIdentifier folderIdentifier)
{
var stats = new EDiscoveryStatisticsResponse();
// Setup our state so we have everything we need.
var folder = await connection.Folder.GetAsync(folderIdentifier, new List <PopulationDirective>
{
new PopulationDirective
{
Name = nameof(FolderModel.Files)
}
});
foreach (var file in folder.Files.Rows.ToList())
{
switch (EDiscoveryUtility.GetCurrentShareState(file))
{
case EDiscoveryShareState.NotShared:
// No Op here
break;
case EDiscoveryShareState.Staged:
stats.FilesStaged++;
break;
case EDiscoveryShareState.Published:
stats.FilesPublished++;
break;
default:
break;
}
}
stats.RecipientCount = folder.MetaEDiscoveryRecipientListRead().Count();
stats.IsEDiscoveryActive = this.IsModuleActive(folder);
return(stats);
}
private async Task EnsureFolderSecurityConfiguration(FolderIdentifier folderIdentifier)
{
await privilegedConnection.ConcurrencyRetryBlock(async() =>
{
var folder = await privilegedConnection.Folder.GetAsync(folderIdentifier);
if (!folder.Privilege("read")?.Any(a => a.OverrideKey == "edisc") ?? false)
{
folder.WriteACLs("read", new[] {
new ACLModel
{
OverrideKey = "edisc",
RequiredIdentifiers = new List <string>
{
"u:system",
"x:eDiscovery",
$"r:eDiscovery{{{folderIdentifier.FolderKey.Replace(" ", "_")}}}"
}
}
});
await privilegedConnection.Folder.PutAsync(folder);
}
});
}
private async Task ImportDefendant()
{
var defendantID = CurrentMessage.Key;
Logger.LogDebug($"Synchronizing: PCMS:{SynchronizeConfiguration.CountyID}/Defendant:{defendantID}");
var folderIdentifier = new FolderIdentifier(CurrentMessage.OrganizationIdentifier, $"Defendant:{defendantID}");
var folder = await API.Folder.GetAsync(folderIdentifier)
?? new FolderModel(folderIdentifier)
.InitializeEmptyMetadata()
.InitializeEmptyPrivileges();
await this.Reader("select * from ufDMSSynchronizeDefendant(@CountyID, @DefendantID)",
new Dictionary <string, object> {
{ "CountyID", SynchronizeConfiguration.CountyID },
{ "DefendantID", CurrentMessage.Key }
},
async reader =>
{
if (await reader.ReadAsync())
{
folder.Write("attribute.defendantid", (int)reader["DefendantID"]);
folder.Write("attribute.firstname", reader["FirstName"] as string);
folder.Write("attribute.lastname", reader["LastName"] as string);
folder.Write("attribute.casenumber", reader["CaseNumber"] as string);
folder.Write("attribute.casestatus", reader["CaseStatus"] as string);
folder.Write("attribute.defense.first", reader["DefenseFirstName"] as string);
folder.Write("attribute.defense.last", reader["DefenseLastName"] as string);
folder.Write("attribute.defense.email", reader["DefenseEmail"] as string);
folder.Write("attribute.ada.first", reader["ADAFirstName"] as string);
folder.Write("attribute.ada.last", reader["ADALastName"] as string);
folder.Write("attribute.ada.email", reader["ADAEmail"] as string);
folder.Write("attribute.closed", reader["IsClosed"] != DBNull.Value
? (bool)reader["IsClosed"]
: false
);
folder.Write("attribute.deleted", (int)reader["IsDeleted"] == 1);
// if eDiscovery has setup its permissions, we need to preserve them.
var eDiscoveryACLs = folder.Privilege("read")?.Where(a => a.OverrideKey == "edisc") ?? new ACLModel[0];
folder.WriteACLs("read",
BuildACLs(
reader["acl_read_0"] as string,
reader["acl_read_1"] as string,
reader["acl_read_2"] as string,
reader["acl_read_3"] as string
)
.Union(eDiscoveryACLs)
);
folder.WriteACLs("write",
BuildACLs(
reader["acl_write_0"] as string,
reader["acl_write_1"] as string
)
);
await API.Folder.PutAsync(folder);
}
else
{
throw new Exception($"Could not find DefendantID:{defendantID}");
}
}
);
}
