public Task <PagedCollection <IValueSet> > GetValueSetsAsync(
IPagerSettings pagerSettings,
IEnumerable <string> codeSystemCodes,
bool includeAllValueSetCodes = false)
{
return(this.FindValueSetsAsync(string.Empty, pagerSettings, codeSystemCodes, includeAllValueSetCodes));
}
public Task <PagedCollection <ICodeSystemCode> > GetCodeSystemCodesAsync(
IPagerSettings settings,
IEnumerable <Guid> codeSystemGuids,
bool includeRetired = false)
{
return(this.GetCodeSystemCodesAsync(string.Empty, settings, codeSystemGuids, includeRetired));
}
public Task <PagedCollection <IValueSetBackingItem> > GetValueSetBackingItemsAsync(
string filterText,
IPagerSettings pagerSettings,
IEnumerable <Guid> codeSystemGuids,
IEnumerable <ValueSetStatus> statusCodes,
bool latestVersionsOnly = true)
{
var dtos = latestVersionsOnly ? this.DbSet.Where(GetBaseExpression(statusCodes)) : this.DbSet.AsQueryable();
#pragma warning disable CA1307 // Specify StringComparison
if (!filterText.IsNullOrWhiteSpace())
{
dtos = dtos.Where(
dto => dto.ValueSetNM.Contains(filterText) ||
dto.ValueSetReferenceID.StartsWith(filterText));
}
#pragma warning restore CA1307 // Specify StringComparison
var systemCodes = codeSystemGuids as Guid[] ?? codeSystemGuids.ToArray();
if (systemCodes.Any())
{
var vsGuids = this.sharedContext.ValueSetCodes.Where(code => systemCodes.Contains(code.CodeSystemGuid))
.Select(code => code.ValueSetGUID)
.Distinct();
dtos = dtos.Join(vsGuids, dto => dto.ValueSetGUID, key => key, (dto, key) => dto);
}
var orderingStrategy = this.orderingStrategyFactory.GetValueSetStrategy(
this.sharedContext,
systemCodes);
dtos = orderingStrategy.SetOrdering(dtos, pagerSettings.AsOrderingParameters());
return(this.CreatePagedCollectionAsync(dtos, pagerSettings));
}
public Task <PagedCollection <IValueSet> > FindValueSetsAsync(
string nameFilterText,
IPagerSettings pagerSettings,
bool includeAllValueSetCodes = false)
{
return(this.FindValueSetsAsync(nameFilterText, pagerSettings, new string[] { }, includeAllValueSetCodes));
}
public Task<PagedCollection<IValueSetCode>> GetValueSetCodesAsync(
Guid valueSetGuid,
IPagerSettings settings,
IEnumerable<Guid> codeSystemGuids)
{
return this.GetValueSetCodesAsync(string.Empty, valueSetGuid, settings, codeSystemGuids);
}
public Task <PagedCollection <IValueSet> > GetValueSetsAsync(
IPagerSettings settings,
IEnumerable <ValueSetStatus> statusCodes,
bool latestVersionsOnly = true)
{
return(this.GetValueSetsAsync(settings, new List <Guid>(), statusCodes, latestVersionsOnly));
}
public Task <PagedCollection <IValueSetCode> > GetValueSetCodesAsync(
string filterText,
IPagerSettings settings,
IEnumerable <Guid> codeSystemGuids)
{
return(this.GetValueSetCodesAsync(filterText, Guid.Empty, settings, codeSystemGuids));
}
private async Task <PagedCollection <IValueSetCode> > CreatePagedCollectionAsync(
IQueryable <ValueSetCodeDto> source,
IPagerSettings pagerSettings)
{
var defaultItemsPerPage = this.sharedContext.Settings.DefaultItemsPerPage;
var pagingStrategy = this.pagingStrategyFactory.GetPagingStrategy <IValueSetCode>(defaultItemsPerPage);
var orderingStrategy = this.orderingStrategyFactory.GetValueSetCodeStrategy();
pagingStrategy.EnsurePagerSettings(pagerSettings);
var count = await source.CountAsync();
source = orderingStrategy.SetOrdering(source, pagerSettings.AsOrderingParameters());
var items = await source.Skip((pagerSettings.CurrentPage - 1) *pagerSettings.ItemsPerPage)
.Take(pagerSettings.ItemsPerPage)
.ToListAsync();
var factory = new ValueSetCodeFactory();
// Can't cache at this point since codeGuid can be null in db.
// If this changes in the future, caching should/could be implemented.
return(pagingStrategy.CreatePagedCollection(
items.Select(factory.Build),
count,
pagerSettings));
}
public Task<PagedCollection<IValueSetCode>> GetValueSetCodesAsync(
string filterText,
IPagerSettings settings,
IEnumerable<Guid> codeSystemGuids)
{
return this.valueSetCodeRepository.GetValueSetCodesAsync(filterText, settings, codeSystemGuids);
}
public Task <PagedCollection <IValueSet> > FindValueSetsAsync(
string filterText,
IPagerSettings pagerSettings,
IEnumerable <string> codeSystemCodes,
bool includeAllValueSetCodes = false)
{
var dtos = this.DbSet.Where(GetBaseExpression());
if (!filterText.IsNullOrWhiteSpace())
{
dtos = dtos.Where(dto => dto.ValueSetNM.Contains(filterText) || dto.ValueSetOID.StartsWith(filterText));
}
var systemCodes = codeSystemCodes as string[] ?? codeSystemCodes.ToArray();
if (systemCodes.Any())
{
var codevsid = this.SharedContext.ValueSetCodes.Where(code => systemCodes.Contains(code.CodeSystemCD))
.Select(code => code.ValueSetUniqueID)
.Distinct();
dtos = dtos.Join(codevsid, id => id.ValueSetUniqueID, sa => sa, (id, sa) => id);
}
return(this.CreatePagedCollectionAsync(dtos, pagerSettings, systemCodes, includeAllValueSetCodes));
}
public Task <PagedCollection <ICodeSystemCode> > GetCodeSystemCodesAsync(
IPagerSettings settings,
Guid codeSystemGuid,
bool includeRetired = false)
{
return(this.GetCodeSystemCodesAsync(settings, new[] { codeSystemGuid }, includeRetired));
}
public static IPagerSettings ValidateValueSetOrdering(IPagerSettings settings)
{
var vso = GetValidValueSetOrdering(settings.OrderBy, settings.Direction.ToString());
settings.Direction = vso.Direction;
settings.OrderBy = vso.FieldName;
return(settings);
}
public Task <PagedCollection <IValueSet> > GetValueSetsAsync(
IPagerSettings settings,
IEnumerable <Guid> codeSystemGuids,
IEnumerable <ValueSetStatus> statusCodes,
bool latestVersionsOnly = true)
{
return(this.GetValueSetsAsync(string.Empty, settings, codeSystemGuids, statusCodes, latestVersionsOnly));
}
public Task <PagedCollection <IValueSetSummary> > GetValueSetSummariesAsync(
string nameFilterText,
IPagerSettings pagerSettings,
IEnumerable <ValueSetStatus> statusCodes,
bool latestVersionsOnly = true)
{
return(this.GetValueSetSummariesAsync(nameFilterText, pagerSettings, new List <Guid>(), statusCodes, latestVersionsOnly));
}
public Task <PagedCollection <IValueSet> > GetValueSetsAsync(IPagerSettings settings, bool latestVersionsOnly = true)
{
return(this.GetValueSetsAsync(
settings,
new List <Guid>(),
new List <ValueSetStatus> {
ValueSetStatus.Active
},
latestVersionsOnly));
}
private async Task <PagedCollection <IValueSet> > CreatePagedCollectionAsync(
IQueryable <ValueSetDescriptionDto> source,
IPagerSettings pagerSettings,
IEnumerable <string> codeSystemCodes,
bool includeAllValueSetCodes = false)
{
this.pagingStrategy.EnsurePagerSettings(pagerSettings);
var count = await source.CountAsync();
var items = await source.OrderBy(this.SortExpression)
.Skip((pagerSettings.CurrentPage - 1) * pagerSettings.ItemsPerPage)
.Take(pagerSettings.ItemsPerPage)
.ToListAsync();
var valueSetUniqueIds = items.Select(item => item.ValueSetUniqueID).ToArray();
IModelMapper <ValueSetDescriptionDto, IValueSet> mapper;
if (includeAllValueSetCodes)
{
mapper = new ValueSetFullCodeListMapper(
this.isCustomValue,
this.Cache,
this.valueSetCodeRepository.GetValueSetCodes,
codeSystemCodes);
}
else
{
// remove any valueSetIds for valuesets already cached from partition query
var cachedValueSets = this.Cache
.GetItems(valueSetUniqueIds.Select(id => CacheKeys.ValueSetKey(id, codeSystemCodes)).ToArray())
.Select(obj => obj as IValueSet)
.Where(vs => vs != null);
valueSetUniqueIds = valueSetUniqueIds.Where(id => !cachedValueSets.Select(vs => vs.ValueSetUniqueId).Contains(id))
.ToArray();
// partition query
var systemCodes = codeSystemCodes as string[] ?? codeSystemCodes.ToArray();
var lookup = await this.valueSetCodeRepository.LookupValueSetCodes(valueSetUniqueIds, systemCodes);
var cachedValueSetDictionary = cachedValueSets.ToDictionary(vs => vs.ValueSetUniqueId, vs => vs);
mapper = new ValueSetShortCodeListMapper(
this.isCustomValue,
this.Cache,
lookup,
cachedValueSetDictionary,
this.valueSetCodeRepository.CountValueSetCodes,
systemCodes);
}
return(this.pagingStrategy.CreatePagedCollection(items, count, pagerSettings, mapper));
}
public Task <PagedCollection <IValueSet> > FindValueSetsAsync(
string nameFilterText,
IPagerSettings pagerSettings,
IEnumerable <string> codeSystemCodes,
bool includeAllValueSetCodes = false)
{
return(this.repository.FindValueSetsAsync(
nameFilterText,
pagerSettings,
codeSystemCodes,
includeAllValueSetCodes));
}
public Task <PagedCollection <ICodeSystemCode> > GetCodeSystemCodesAsync(
string filterText,
IPagerSettings pagerSettings,
IEnumerable <Guid> codeSystemGuids,
bool includeRetired = false)
{
return(this.codeSystemCodeRepository.GetCodeSystemCodesAsync(
filterText,
pagerSettings,
codeSystemGuids,
includeRetired));
}
public void EnsurePagerSettings(IPagerSettings pagerSettings)
{
if (pagerSettings.CurrentPage <= 0)
{
pagerSettings.CurrentPage = 1;
}
if (pagerSettings.ItemsPerPage < 0)
{
pagerSettings.ItemsPerPage = this.DefaultItemsPerPage;
}
}
public Task <PagedCollection <IValueSetCode> > GetValueSetCodesAsync(
string filterText,
Guid valueSetGuid,
IPagerSettings settings,
IEnumerable <Guid> codeSystemGuids)
{
var dtos = this.GetValueSetCodeQueryable(filterText, codeSystemGuids);
if (valueSetGuid != Guid.Empty)
{
dtos = dtos.Where(dto => dto.ValueSetGUID == valueSetGuid);
}
return(this.CreatePagedCollectionAsync(dtos, settings));
}
public Task <PagedCollection <IValueSet> > GetValueSetsAsync(
IReadOnlyCollection <string> valueSetUniqueIds,
IPagerSettings pagerSettings,
IEnumerable <string> codeSystemCodes,
bool includeAllValueSetCodes = false)
{
if (!valueSetUniqueIds.Any())
{
return(this.FindValueSetsAsync(string.Empty, pagerSettings, codeSystemCodes, includeAllValueSetCodes));
}
var dtos = this.DbSet.Where(GetBaseExpression()).Where(dto => valueSetUniqueIds.Contains(dto.ValueSetUniqueID));
return(this.CreatePagedCollectionAsync(dtos, pagerSettings, codeSystemCodes, includeAllValueSetCodes));
}
public PagedCollection <TResult> CreatePagedCollection(
IEnumerable <TResult> items,
int totalCount,
IPagerSettings pagerSettings)
{
return(new PagedCollection <TResult>
{
TotalItems = totalCount,
PagerSettings =
new PagerSettings
{
CurrentPage = pagerSettings.CurrentPage,
ItemsPerPage = pagerSettings.ItemsPerPage
},
TotalPages = (int)Math.Ceiling((double)totalCount / pagerSettings.ItemsPerPage),
Values = items.ToList()
});
}
public PagedCollection <TResult> CreatePagedCollection(
IEnumerable <TSrc> items,
int totalCount,
IPagerSettings pagerSettings,
IModelMapper <TSrc, TResult> mapper)
{
return(new PagedCollection <TResult>
{
TotalItems = totalCount,
PagerSettings =
new PagerSettings
{
CurrentPage = pagerSettings.CurrentPage,
ItemsPerPage = pagerSettings.ItemsPerPage
},
TotalPages = (int)Math.Ceiling((double)totalCount / pagerSettings.ItemsPerPage),
Values = items.Select(mapper.Map).ToList().AsReadOnly()
});
}
public async Task <PagedCollection <IValueSetSummary> > GetValueSetSummariesAsync(
string nameFilterText,
IPagerSettings pagerSettings,
IEnumerable <Guid> codeSystemGuids,
IEnumerable <ValueSetStatus> statusCodes,
bool latestVersionsOnly = true)
{
var backingItemPage = await this.valueSetBackingItemRepository.GetValueSetBackingItemsAsync(
nameFilterText,
pagerSettings,
codeSystemGuids,
statusCodes,
latestVersionsOnly).ConfigureAwait(false);
var countsDictionary =
await this.valueSetCodeCountRepository.BuildValueSetCountsDictionary(
backingItemPage.Values.Select(bi => bi.ValueSetGuid)).ConfigureAwait(false);
return(this.BuildValueSetsPage(backingItemPage, countsDictionary));
}
public Task <PagedCollection <ICodeSystemCode> > GetCodeSystemCodesAsync(
string filterText,
IPagerSettings pagerSettings,
IEnumerable <Guid> codeSystemGuids,
bool includeRetired)
{
var dtos = this.GetBaseQuery(includeRetired);
var systemGuids = codeSystemGuids as Guid[] ?? codeSystemGuids.ToArray();
if (systemGuids.Any())
{
dtos = dtos.Where(dto => systemGuids.Contains(dto.CodeSystemGUID));
}
if (!filterText.IsNullOrWhiteSpace())
{
dtos = dtos.Where(dto => dto.CodeDSC.Contains(filterText) || dto.CodeCD.StartsWith(filterText));
}
return(this.CreatePagedCollectionAsync(dtos, pagerSettings));
}
public async Task <PagedCollection <IValueSet> > GetValueSetsAsync(
string filterText,
IPagerSettings pagerSettings,
IEnumerable <Guid> codeSystemGuids,
IEnumerable <ValueSetStatus> statusCodes,
bool latestVersionsOnly = true)
{
var backingItemPage = await this.valueSetBackingItemRepository.GetValueSetBackingItemsAsync(
filterText,
pagerSettings,
codeSystemGuids,
statusCodes,
latestVersionsOnly);
var valueSetGuids = backingItemPage.Values.Select(bi => bi.ValueSetGuid).ToList();
var codes = await this.valueSetCodeRepository.BuildValueSetCodesDictionary(valueSetGuids);
var counts = await this.valueSetCodeCountRepository.BuildValueSetCountsDictionary(valueSetGuids);
return(this.BuildValueSetsPage(backingItemPage, codes, counts));
}
private async Task <PagedCollection <IValueSetBackingItem> > CreatePagedCollectionAsync(
IQueryable <ValueSetDescriptionDto> source,
IPagerSettings pagerSettings)
{
var defaultItemsPerPage = this.sharedContext.Settings.DefaultItemsPerPage;
var pagingStrategy =
this.pagingStrategyFactory.GetPagingStrategy <IValueSetBackingItem>(defaultItemsPerPage);
pagingStrategy.EnsurePagerSettings(pagerSettings);
var count = await source.CountAsync().ConfigureAwait(false);
var items = await source.Skip((pagerSettings.CurrentPage - 1) *pagerSettings.ItemsPerPage)
.Take(pagerSettings.ItemsPerPage)
.ToListAsync().ConfigureAwait(false);
var factory = new ValueSetBackingItemFactory();
return(pagingStrategy.CreatePagedCollection(
items.Select(i => this.cacheManager.GetOrSet(i.ValueSetGUID, () => factory.Build(i))).Values(),
count,
pagerSettings));
}
public Task <PagedCollection <ICodeSystemCode> > GetCodeSystemCodesAsync(
string filterText,
IPagerSettings pagerSettings,
IEnumerable <Guid> codeSystemGuids,
bool includeRetired)
{
var dtos = this.GetBaseQuery(includeRetired);
if (!filterText.IsNullOrWhiteSpace())
{
dtos = dtos.Where(
c => c.CodeDSC.Contains(filterText, StringComparison.OrdinalIgnoreCase) ||
c.CodeCD.Equals(filterText, StringComparison.OrdinalIgnoreCase));
}
var systemGuids = codeSystemGuids as Guid[] ?? codeSystemGuids.ToArray();
if (systemGuids.Any())
{
dtos = dtos.Where(c => systemGuids.Contains(c.CodeSystemGUID));
}
return(this.CreatePagedCollectionAsync(dtos, pagerSettings));
}
private async Task <PagedCollection <ICodeSystemCode> > CreatePagedCollectionAsync(
IQueryable <CodeSystemCodeDto> source,
IPagerSettings pagerSettings)
{
var defaultItemsPerPage = this.sharedContext.Settings.DefaultItemsPerPage;
var pagingStrategy = this.pagingStrategyFactory.GetPagingStrategy <ICodeSystemCode>(defaultItemsPerPage);
pagingStrategy.EnsurePagerSettings(pagerSettings);
var count = await source.CountAsync().ConfigureAwait(false);
var items = await source.OrderBy(dto => dto.CodeDSC)
.Skip((pagerSettings.CurrentPage - 1) * pagerSettings.ItemsPerPage)
.Take(pagerSettings.ItemsPerPage)
.ToListAsync().ConfigureAwait(false);
var factory = new CodeSystemCodeFactory(this.codeSystems.Value);
return(pagingStrategy.CreatePagedCollection(
items.Select(i => this.codeSystemCodeCachingManager.GetOrSet(i.CodeGUID, () => factory.Build(i))
).Values(),
count,
pagerSettings));
}
public Task<PagedCollection<IValueSetCode>> GetValueSetCodesAsync(Guid valueSetGuid, IPagerSettings settings)
{
return this.GetValueSetCodesAsync(valueSetGuid, settings, new List<Guid>());
}
