This commit is contained in:
Zeeshaun
2026-03-13 09:11:35 -05:00
parent f004c8205a
commit c2d6bda458
197 changed files with 14970 additions and 0 deletions
@@ -0,0 +1,19 @@
using LCU.API.Internal.DocumentLib.Configurations;
using MongoDB.Driver;
namespace LCU.API.Internal.DocumentLib.Repositories;
public class DataClient : IDataClient
{
private readonly MongoClient _client;
public DataClient(DatabaseConfiguration config)
{
_client = new MongoClient(config.ConnectionString);
}
public MongoClient GetClient()
{
return _client;
}
}
@@ -0,0 +1,31 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.DocumentLib.Containers;
using LCU.API.Internal.DocumentLib.Utilities;
using MongoDB.Driver;
namespace LCU.API.Internal.DocumentLib.Repositories;
public class DocumentAuditRepository : IDocumentAuditRepository
{
private readonly IMongoCollection<DocumentAudit> _documentAudits;
public DocumentAuditRepository(IMongoCollectionFactory collectionFactory)
{
_documentAudits = collectionFactory.GetCollection<DocumentAudit>();
}
public async Task<List<DocumentAudit>> GetDocumentAudits(params Guid[] documentIds)
{
return await (await _documentAudits.FindAsync(doc => documentIds.Contains(doc.DocumentId))).ToListAsync();
}
public async Task<IEnumerable<DocumentAudit>> SaveDocumentAudits(params DocumentAudit[] documentAudit)
{
await _documentAudits.InsertManyAsync(documentAudit);
return documentAudit;
}
}
@@ -0,0 +1,269 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using LCU.API.Internal.DocumentLib.Containers;
using LCU.API.Internal.DocumentLib.Utilities;
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
using LCU.Library.Internal.DocumentModels.Requests.Search;
using Microsoft.Azure.Cosmos.Linq;
using MongoDB.Bson;
using MongoDB.Driver;
namespace LCU.API.Internal.DocumentLib.Repositories;
public class DocumentInformationRepository : IDocumentInformationRepository
{
private readonly IMongoCollection<DocumentInformation> _documents;
public DocumentInformationRepository(IMongoCollectionFactory collectionFactory)
{
_documents = collectionFactory.GetCollection<DocumentInformation>();
}
public async Task<DocumentInformation> GetDocumentInformation(Guid documentId)
{
return await _documents.Find(doc => doc.DocumentId == documentId)
.SingleOrDefaultAsync();
}
public async Task<List<DocumentInformation>> SearchDocumentInformation(DocumentInformationFilter filter, int? skip = null, int? take = null, List<SortableField>? sortDefinition = null)
{
var pipelineFilter = FilterFactory(filter);
var sorter = Sorter<DocumentInformation>.GetSorter(sortDefinition);
if (sorter != null) pipelineFilter = pipelineFilter.Sort(sorter);
if (skip.HasValue) pipelineFilter = pipelineFilter.Skip(skip.Value);
if (take.HasValue) pipelineFilter = pipelineFilter.Limit(take.Value);
var documentsInformation = await _documents.AggregateAsync(pipelineFilter);
return await documentsInformation.ToListAsync();
}
public async Task<long> CountDocuments(DocumentInformationFilter filter)
{
return (await _documents.AggregateAsync(FilterFactory(filter).Count())).Single().Count;
}
public async Task<DocumentInformation> GetDocumentInformationByBlobId(Guid documentBlobId)
{
return await _documents
.Find(doc => doc.DocumentBlobId == documentBlobId)
.SingleOrDefaultAsync();
}
public async Task<DocumentInformation> SaveDocumentInformation(DocumentInformation document)
{
await _documents.InsertOneAsync(document);
return document;
}
public async Task<DocumentInformation> UpdateDocumentInformation(Guid documentId, DocumentInformation newDocument)
{
await _documents.FindOneAndReplaceAsync(doc => doc.DocumentId == documentId, newDocument);
return newDocument;
}
public async Task<DocumentInformation> RemoveDocumentInformation(Guid documentId)
{
return await _documents.FindOneAndDeleteAsync(document => document.DocumentId == documentId);
}
public async Task<List<Guid>> GetDocumentsForCleanup(GetDocumentCleanupRequest request)
{
IList<FilterDefinition<DocumentInformation>> filterConcat = new List<FilterDefinition<DocumentInformation>>();
foreach(var documentCodeDetail in request.DocumentCodeDetailInfos)
{
var adjustedDate = DateTime.Now.AddMonths(documentCodeDetail.InternalRetentionMonths * -1);
var typeFilter = Builders<DocumentInformation>.Filter.Eq(x => x.Type, documentCodeDetail.DocumentCode);
var dateFilter = Builders<DocumentInformation>.Filter.Lt(x => x.CreatedDate, adjustedDate);
var groupFilter = Builders<DocumentInformation>.Filter.And(typeFilter, dateFilter);
filterConcat.Add(groupFilter);
}
var filter = Builders<DocumentInformation>.Filter;
var oneConcat = filter.Empty;
oneConcat &= filter.Or(filterConcat);
var nullFilter = Builders<DocumentInformation>.Filter.Ne(x => x.DocumentBlobId, null);
oneConcat &= filter.And(nullFilter);
var pipelineFilter = new EmptyPipelineDefinition<DocumentInformation>()
.Match(oneConcat)
.Limit(request.Limit);
var documentsInformation = await _documents.AggregateAsync(pipelineFilter);
return (await documentsInformation.ToListAsync()).Select(document => document.DocumentId).ToList();
}
private PipelineDefinition<DocumentInformation, DocumentInformation> FilterFactory(DocumentInformationFilter filter)
{
var builder = Builders<DocumentInformation>.Filter;
IList<FilterDefinition<DocumentInformation>> stageOneFiltersAnd = new List<FilterDefinition<DocumentInformation>>();
IList<FilterDefinition<DocumentInformation>> stageOneFiltersOr = new List<FilterDefinition<DocumentInformation>>();
IList<FilterDefinition<DocumentInformation>> stageTwoFiltersAnd = new List<FilterDefinition<DocumentInformation>>();
IList<FilterDefinition<DocumentInformation>> stageTwoFiltersOr = new List<FilterDefinition<DocumentInformation>>();
if (!string.IsNullOrWhiteSpace(filter.Name))
{
stageOneFiltersAnd.Add(builder.Eq("Name", filter.Name));
}
if (!string.IsNullOrWhiteSpace(filter.Type))
{
stageOneFiltersAnd.Add(builder.Eq("Type", filter.Type));
}
if (filter.TypeContainsAny != null && filter.TypeContainsAny.Any())
{
stageOneFiltersAnd.Add(builder.In("Type", filter.TypeContainsAny));
}
if (filter.ScanStatus != null)
{
stageOneFiltersAnd.Add(builder.Eq("ScanStatus", filter.ScanStatus));
}
if (!string.IsNullOrWhiteSpace(filter.Source))
{
stageOneFiltersAnd.Add(builder.Eq("Source", filter.Source));
}
if (!string.IsNullOrWhiteSpace(filter.DataSource))
{
stageOneFiltersAnd.Add(builder.Eq("DataSource", filter.DataSource));
}
if (filter.TraceId != null)
{
stageOneFiltersAnd.Add(builder.Eq("TraceId", filter.TraceId));
}
if (!string.IsNullOrWhiteSpace(filter.PersonNumbersEquals))
{
stageOneFiltersAnd.Add(builder.Eq("PersonNumbers", filter.PersonNumbersEquals));
}
if (filter.PersonNumbersContains != null && filter.PersonNumbersContains.Any())
{
stageOneFiltersAnd.Add(builder.All("PersonNumbers", filter.PersonNumbersContains));
}
if (filter.PersonNumbersContainsAny != null && filter.PersonNumbersContainsAny.Any())
{
stageOneFiltersAnd.Add(builder.In("PersonNumbers", filter.PersonNumbersContainsAny));
}
if (filter.OrganizationNumbersEquals != null && filter.OrganizationNumbersEquals.Any())
{
stageOneFiltersAnd.Add(builder.Eq("OrganizationNumbers", filter.OrganizationNumbersEquals));
}
if (filter.OrganizationNumbersContains != null && filter.OrganizationNumbersContains.Any())
{
stageOneFiltersAnd.Add(builder.All("OrganizationNumbers", filter.OrganizationNumbersContains));
}
if (filter.OrganizationNumbersContainsAny != null && filter.OrganizationNumbersContainsAny.Any())
{
stageOneFiltersAnd.Add(builder.In("OrganizationNumbers", filter.OrganizationNumbersContainsAny));
}
if (filter.AccountNumberEquals != null && filter.AccountNumberEquals.Any())
{
stageOneFiltersAnd.Add(builder.Eq("AccountNumber", filter.AccountNumberEquals));
}
if (filter.AccountNumberContainsAny != null && filter.AccountNumberContainsAny.Any())
{
stageOneFiltersAnd.Add(builder.In("AccountNumber", filter.AccountNumberContainsAny));
}
if (filter.AttributesEquals != null && filter.AttributesEquals.Any())
{
foreach (var keyValuePair in filter.AttributesEquals)
{
stageOneFiltersAnd.Add(builder.Eq($"Attributes.{keyValuePair.Key.Trim()}", keyValuePair.Value.Trim()));
}
}
if (filter.AttributesContains is not null)
{
foreach (var keyValuePair in filter.AttributesContains)
{
var queryExpr =
new BsonRegularExpression(
new Regex($"\\b({keyValuePair.Value.Trim()})\\b", RegexOptions.IgnoreCase));
stageTwoFiltersAnd.Add(builder.Regex($"Attributes.{keyValuePair.Key.Trim()}", queryExpr));
}
}
if (filter.AttributesContainsAny is not null)
{
foreach (var keyValuePair in filter.AttributesContainsAny)
{
foreach (var value in keyValuePair.Value.Split(','))
{
var queryExpr = new BsonRegularExpression(new Regex($"^{value.Trim()}$", RegexOptions.IgnoreCase));
stageTwoFiltersOr.Add(builder.Regex($"Attributes.{keyValuePair.Key.Trim()}", queryExpr));
}
}
}
if (filter.CreatedDateMinimum != null)
{
stageOneFiltersAnd.Add(builder.Gte("CreatedDate", filter.CreatedDateMinimum));
}
if (filter.CreatedDateMaximum != null)
{
stageOneFiltersAnd.Add(builder.Lte("CreatedDate", filter.CreatedDateMaximum));
}
if (filter.UploadDateMinimum != null)
{
stageOneFiltersAnd.Add(builder.Gte("UploadDate", filter.UploadDateMinimum));
}
if (filter.UploadDateMaximum != null)
{
stageOneFiltersAnd.Add(builder.Lte("UploadDate", filter.UploadDateMaximum));
}
if (filter.LastModifiedMinimum != null)
{
stageOneFiltersAnd.Add(builder.Gte("LastModifiedDate", filter.LastModifiedMinimum));
}
if (filter.LastModifiedDateMaximum != null)
{
stageOneFiltersAnd.Add(builder.Lte("LastModifiedDate", filter.LastModifiedDateMaximum));
}
var stageOneFilterConcat = builder.Empty;
if (stageOneFiltersAnd.Any())
{
stageOneFilterConcat &= builder.And(stageOneFiltersAnd);
}
if (stageOneFiltersOr.Any())
{
stageOneFilterConcat &= builder.Or(stageOneFiltersOr);
}
var stageTwoFilterConcat = builder.Empty;
if (stageTwoFiltersAnd.Any())
{
stageOneFilterConcat &= builder.And(stageTwoFiltersAnd);
}
if (stageTwoFiltersOr.Any())
{
stageTwoFilterConcat &= builder.Or(stageTwoFiltersOr);
}
return new EmptyPipelineDefinition<DocumentInformation>()
.Match(stageOneFilterConcat)
.Match(stageTwoFilterConcat);
}
}
@@ -0,0 +1,8 @@
using MongoDB.Driver;
namespace LCU.API.Internal.DocumentLib.Repositories;
public interface IDataClient
{
MongoClient GetClient();
}
@@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.DocumentLib.Containers;
namespace LCU.API.Internal.DocumentLib.Repositories;
public interface IDocumentAuditRepository
{
Task<List<DocumentAudit>> GetDocumentAudits(params Guid[] documentIds);
Task<IEnumerable<DocumentAudit>> SaveDocumentAudits(params DocumentAudit[] documentAudit);
}
@@ -0,0 +1,20 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.DocumentLib.Containers;
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
using LCU.Library.Internal.DocumentModels.Requests.Search;
namespace LCU.API.Internal.DocumentLib.Repositories;
public interface IDocumentInformationRepository
{
Task<DocumentInformation> GetDocumentInformation(Guid documentId);
Task<DocumentInformation> GetDocumentInformationByBlobId(Guid documentBlobId);
Task<List<DocumentInformation>> SearchDocumentInformation(DocumentInformationFilter filter, int? skip = null, int? take = null, List<SortableField>? sortDefinition = null);
Task<DocumentInformation> SaveDocumentInformation(DocumentInformation document);
Task<DocumentInformation> UpdateDocumentInformation(Guid documentId, DocumentInformation newDocument);
Task<DocumentInformation> RemoveDocumentInformation(Guid documentId);
Task<long> CountDocuments(DocumentInformationFilter filter);
Task<List<Guid>> GetDocumentsForCleanup(GetDocumentCleanupRequest request);
}