public override async Task <PagedResults <OrganizationModel> > LoadRelatedToAsync <TRelatedModel>(
TRelatedModel related,
PopulationDirective filters,
IEnumerable <PopulationDirective> populateRelationships,
Action <OrganizationModel> securityPrepare
)
{
if (related == null) // GetAll organizations
{
var organizations = await DoIncludes(Database.Organization
.AsNoTracking())
.Where(o => o.OrganizationKey != null) // deleted
.Select(o => o.ToModel())
.ToListAsync();
var included = new List <OrganizationModel>();
foreach (var organization in organizations)
{
securityPrepare?.Invoke(organization);
if (filters != null && !filters.MetadataFilter.SatisfiedBy(organization))
{
continue;
}
if (!organization.PrivilegeCheck("read", SecurityContext, throwOnFail: false))
{
continue;
}
await PopulateFoldersAsync(organization, populateRelationships);
await PopulateUsersAsync(organization, populateRelationships);
included.Add(organization);
}
var paging = filters.Paging;
var page = included.Skip(paging.PageSize * paging.PageIndex).Take(paging.PageSize).ToList();
// todo: sort
return(new PagedResults <OrganizationModel>
{
Rows = page,
TotalMatches = included.Count
});
}
throw new Exception("Unknown relationship type");
}
public override async Task <PagedResults <UserModel> > LoadRelatedToAsync <TRelatedModel>(TRelatedModel related, PopulationDirective filters, IEnumerable <PopulationDirective> populateRelationships, Action <UserModel> securityPrepare)
{
if (typeof(TRelatedModel) == typeof(OrganizationModel))
{
var organization = related as OrganizationModel;
var users = await DoIncludes(Database.User
.AsNoTracking())
.Where(u =>
u.Organization.OrganizationKey == organization.Identifier.OrganizationKey
)
.Where(u => u.UserKey != null)
.Select(u => u.ToModel())
.ToListAsync();
foreach (var user in users)
{
securityPrepare?.Invoke(user);
}
var paging = filters.Paging;
// todo: sort
return(new PagedResults <UserModel>
{
Rows = users.Skip(paging.PageSize * paging.PageIndex).Take(paging.PageSize),
TotalMatches = users.Count
});
}
throw new Exception("Unknown relationship type");
}
public override async Task <PagedResults <FileModel> > LoadRelatedToAsync <TRelatedModel>(TRelatedModel related, PopulationDirective filters, IEnumerable <PopulationDirective> populateRelationships, Action <FileModel> securityPrepare)
{
if (typeof(TRelatedModel) == typeof(FolderModel))
{
var folder = related as FolderModel;
// Load the files from the database
var query = Database.File
.Where(f =>
f.Folder.Organization.OrganizationKey == folder.Identifier.OrganizationKey &&
f.Folder.FolderKey == folder.Identifier.FolderKey
)
.Where(f => f.Status == FileStatus.Normal)
.Where(f => f.FileKey != null) // deleted
.Include(f => f.Privileges)
.AsNoTracking();
var fileEntities = await query.ToListAsync();
var files = fileEntities.Select(e => e.ToModel(folder.Identifier.OrganizationKey, folder.Identifier.FolderKey));
var included = new List <FileModel>();
foreach (var file in files)
{
securityPrepare(file);
if (!filters.MetadataFilter.SatisfiedBy(file))
{
continue;
}
if (!file.PrivilegeCheck("read", SecurityContext, throwOnFail: false))
{
continue;
}
included.Add(file);
}
var paging = filters.Paging;
var page = included.Skip(paging.PageSize * paging.PageIndex).Take(paging.PageSize).ToList();
// todo: sort
return(new PagedResults <FileModel>
{
Rows = page,
TotalMatches = included.Count
});
}
throw new InvalidRelationshipException();
}
public override async Task <PagedResults <UploadChunkModel> > LoadRelatedToAsync <TRelatedModel>(TRelatedModel related, PopulationDirective filters, IEnumerable <PopulationDirective> populateRelationships, Action <UploadChunkModel> securityPrepare)
{
if (typeof(TRelatedModel) == typeof(UploadModel))
{
var upload = related as UploadModel;
// Load the files from the database
var uploadChunks = await DoIncludes(Database.UploadChunk
.AsNoTracking())
.Where(u =>
u.Upload.File.Folder.Organization.OrganizationKey == upload.Identifier.OrganizationKey &&
u.Upload.File.Folder.FolderKey == upload.Identifier.FolderKey &&
u.Upload.File.FileKey == upload.Identifier.FileKey &&
u.Upload.UploadKey == upload.Identifier.UploadKey
)
.Select(f => f.ToModel())
.ToListAsync();
var included = new List <UploadChunkModel>();
foreach (var uploadChunk in uploadChunks)
{
securityPrepare?.Invoke(uploadChunk);
included.Add(uploadChunk);
}
var paging = filters.Paging;
var page = included.Skip(paging.PageSize * paging.PageIndex).Take(paging.PageSize).ToList();
// todo: sort
return(new PagedResults <UploadChunkModel>
{
Rows = page,
TotalMatches = included.Count
});
}
throw new InvalidRelationshipException();
}
public override async Task <PagedResults <AuditLogEntryModel> > LoadRelatedToAsync <TRelatedModel>(
TRelatedModel related,
PopulationDirective filters,
IEnumerable <PopulationDirective> populateRelationships,
Action <AuditLogEntryModel> securityPrepare
)
{
string organizationKey = null;
string folderKey = null;
string userKey = null;
string fileKey = null;
if (typeof(TRelatedModel) == typeof(OrganizationIdentifier))
{
organizationKey = (related as OrganizationIdentifier)?.OrganizationKey;
}
if (typeof(TRelatedModel) == typeof(FolderIdentifier))
{
folderKey = (related as FolderIdentifier)?.FolderKey;
}
if (typeof(TRelatedModel) == typeof(FileIdentifier))
{
fileKey = (related as FileIdentifier)?.FileKey;
}
if (typeof(TRelatedModel) == typeof(UserIdentifier))
{
fileKey = (related as UserIdentifier)?.UserKey;
}
organizationKey = organizationKey ?? filters.MetadataFilter?.Where(m => m.Name == "OrganizationKey").FirstOrDefault()?.Value;
folderKey = folderKey ?? filters.MetadataFilter?.Where(m => m.Name == "FolderKey").FirstOrDefault()?.Value;
fileKey = fileKey ?? filters.MetadataFilter?.Where(m => m.Name == "FileKey").FirstOrDefault()?.Value;
userKey = userKey ?? filters.MetadataFilter?.Where(m => m.Name == "UserKey").FirstOrDefault()?.Value;
// this is not ideal. it's filtering for a very narrow use case
bool internalOnly = filters.MetadataFilter?.Where(m => m.Name == "InternalOnly").Any() ?? false;
var actionTypeFilter = filters.MetadataFilter?.Where(m => m.Name == "ActionType").FirstOrDefault();
DateTime?generatedAfter = TryParseDate(filters.MetadataFilter?.Where(p => p.Name == "Generated" && p.Operator == ">=").FirstOrDefault()?.Value);
DateTime?generatedBefore = TryParseDate(filters.MetadataFilter?.Where(p => p.Name == "Generated" && p.Operator == "<").FirstOrDefault()?.Value);
var query = Database.AuditLog
.Where(a =>
true &&
(organizationKey == null || a.OrganizationKey == organizationKey) &&
(folderKey == null || a.FolderKey == folderKey) &&
(fileKey == null || a.FileKey == fileKey) &&
(userKey == null || a.UserKey == userKey) &&
(actionTypeFilter == null || a.ActionType == actionTypeFilter.Value)
&& (generatedAfter == null || a.Generated >= generatedAfter) &&
(generatedBefore == null || a.Generated < generatedBefore)
&& (!internalOnly ||
(
!a.InitiatorUserKey.StartsWith("leo:") &&
!a.InitiatorUserKey.StartsWith("Defendant:")
)
)
)
.AsNoTracking()
.OrderByDescending(a => a.Generated);
var logEntities = await query.ToListAsync();
var logs = logEntities.Select(e => e.ToModel());
var included = new List <AuditLogEntryModel>();
foreach (var log in logs)
{
securityPrepare?.Invoke(log);
included.Add(log);
}
var paging = filters.Paging;
var page = included.Skip(paging.PageSize * paging.PageIndex).Take(paging.PageSize).ToList();
return(new PagedResults <AuditLogEntryModel>
{
Rows = page,
TotalMatches = included.Count
});
}
