/// <summary>
/// Get the specified object
/// </summary>
internal override TModel Get(DataContext context, Guid key)
{
// We need to join, but to what?
// True to get the cache item
var cacheService = new AdoPersistenceCache(context);
var cacheItem = cacheService?.GetCacheItem <TModel>(key) as TModel;
if (cacheItem != null && context.Transaction == null)
{
if (cacheItem.LoadState < context.LoadState)
{
cacheItem.LoadAssociations(context);
cacheService?.Add(cacheItem);
}
return(cacheItem);
}
else
{
var domainQuery = this.m_settingsProvider.GetQueryBuilder().CreateQuery <TModel>(o => o.Key == key && o.ObsoletionTime == null).Build();
domainQuery.OrderBy <TRootEntity>(o => o.VersionSequenceId, Core.Model.Map.SortOrderType.OrderByDescending);
cacheItem = this.ToModelInstance(context.FirstOrDefault <TQueryReturn>(domainQuery), context);
if (cacheService != null)
{
cacheService.Add(cacheItem);
}
return(cacheItem);
}
}
/// <summary>
/// Perform a version aware get
/// </summary>
internal override TModel Get(DataContext context, Guid key)
{
// Attempt to get a cahce item
var cacheService = new AdoPersistenceCache(context);
var retVal = cacheService.GetCacheItem <TModel>(key);
if (retVal != null)
{
return(retVal);
}
else
{
var domainQuery = context.CreateSqlStatement <TDomain>().SelectFrom(typeof(TDomain), typeof(TDomainKey))
.InnerJoin <TDomain, TDomainKey>(o => o.Key, o => o.Key)
.Where <TDomain>(o => o.Key == key)
.OrderBy <TDomain>(o => o.VersionSequenceId, Core.Model.Map.SortOrderType.OrderByDescending);
// Is the most recent version obsolete? If so, un-obsolete it
var recentVersion = context.FirstOrDefault <CompositeResult <TDomain, TDomainKey> >(domainQuery);
if (recentVersion?.Object1.ObsoletionTime != null && !context.IsReadonly)
{
this.m_tracer.TraceWarning("Object {0} # {1} has no active versions - Possible BUG - Restoring previous version", recentVersion.GetType().FullName, recentVersion.Object2?.Key);
recentVersion.Object1.ObsoletionTime = null;
recentVersion.Object1.ObsoletionTimeSpecified = true;
recentVersion.Object1.ObsoletedByKey = null;
recentVersion.Object1.ObsoletedByKeySpecified = true;
recentVersion = context.Update(recentVersion);
}
return(this.CacheConvert(recentVersion, context));
}
}
/// <summary>
/// Perform a version aware get
/// </summary>
internal override TModel Get(DataContext context, Guid key)
{
// Attempt to get a cahce item
var cacheService = new AdoPersistenceCache(context);
var retVal = cacheService.GetCacheItem <TModel>(key);
if (retVal != null)
{
return(retVal);
}
else
{
var domainQuery = context.CreateSqlStatement <TDomain>().SelectFrom(typeof(TDomain), typeof(TDomainKey))
.InnerJoin <TDomain, TDomainKey>(o => o.Key, o => o.Key)
.Where <TDomain>(o => o.Key == key && o.ObsoletionTime == null)
.OrderBy <TDomain>(o => o.VersionSequenceId, Core.Model.Map.SortOrderType.OrderByDescending);
return(this.CacheConvert(context.FirstOrDefault <CompositeResult <TDomain, TDomainKey> >(domainQuery), context));
}
}
/// <summary>
/// Tru to load from cache
/// </summary>
protected virtual TModel CacheConvert(Object o, DataContext context)
{
if (o == null)
{
return(null);
}
var cacheService = new AdoPersistenceCache(context);
var idData = (o as CompositeResult)?.Values.OfType <IDbIdentified>().FirstOrDefault() ?? o as IDbIdentified;
var objData = (o as CompositeResult)?.Values.OfType <IDbBaseData>().FirstOrDefault() ?? o as IDbBaseData;
if (objData?.ObsoletionTime != null || idData == null || idData.Key == Guid.Empty)
{
return(this.ToModelInstance(o, context));
}
else
{
var cacheItem = cacheService?.GetCacheItem <TModel>(idData?.Key ?? Guid.Empty);
if (cacheItem != null)
{
if (cacheItem.LoadState < context.LoadState)
{
cacheItem.LoadAssociations(context);
cacheService?.Add(cacheItem);
}
return(cacheItem);
}
else
{
cacheItem = this.ToModelInstance(o, context);
if (context.Transaction == null)
{
cacheService?.Add(cacheItem);
}
}
return(cacheItem);
}
}
/// <summary>
/// Override cache conversion
/// </summary>
protected override Act CacheConvert(object dataInstance, DataContext context)
{
if (dataInstance == null)
{
return(null);
}
DbActVersion dbActVersion = (dataInstance as CompositeResult)?.Values.OfType <DbActVersion>().FirstOrDefault() ?? dataInstance as DbActVersion ?? context.FirstOrDefault <DbActVersion>(o => o.VersionKey == (dataInstance as DbActSubTable).ParentKey);
DbAct dbAct = (dataInstance as CompositeResult)?.Values.OfType <DbAct>().FirstOrDefault() ?? context.FirstOrDefault <DbAct>(o => o.Key == dbActVersion.Key);
Act retVal = null;
var cache = new AdoPersistenceCache(context);
if (!dbActVersion.ObsoletionTime.HasValue)
{
switch (dbAct.ClassConceptKey.ToString().ToUpper())
{
case ActClassKeyStrings.ControlAct:
retVal = cache?.GetCacheItem <ControlAct>(dbAct.Key);
break;
case ActClassKeyStrings.SubstanceAdministration:
retVal = cache?.GetCacheItem <SubstanceAdministration>(dbAct.Key);
break;
case ActClassKeyStrings.Observation:
var dbObs = (dataInstance as CompositeResult)?.Values.OfType <DbObservation>().FirstOrDefault() ?? context.FirstOrDefault <DbObservation>(o => o.ParentKey == dbActVersion.VersionKey);
if (dbObs != null)
{
switch (dbObs.ValueType)
{
case "ST":
retVal = cache?.GetCacheItem <TextObservation>(dbAct.Key);
break;
case "CD":
retVal = cache?.GetCacheItem <CodedObservation>(dbAct.Key);
break;
case "PQ":
retVal = cache?.GetCacheItem <QuantityObservation>(dbAct.Key);
break;
}
}
break;
case ActClassKeyStrings.Encounter:
retVal = cache?.GetCacheItem <PatientEncounter>(dbAct.Key);
break;
case ActClassKeyStrings.Condition:
default:
retVal = cache?.GetCacheItem <Act>(dbAct.Key);
break;
}
}
// Return cache value
if (retVal != null)
{
return(retVal);
}
else
{
return(base.CacheConvert(dataInstance, context));
}
}
/// <summary>
/// Perform the cache convert
/// </summary>
internal Entity DoCacheConvert(object dataInstance, DataContext context)
{
if (dataInstance == null)
{
return(null);
}
// Alright first, which type am I mapping to?
var dbEntityVersion = (dataInstance as CompositeResult)?.Values.OfType <DbEntityVersion>().FirstOrDefault() ?? dataInstance as DbEntityVersion ?? context.FirstOrDefault <DbEntityVersion>(o => o.VersionKey == (dataInstance as DbEntitySubTable).ParentKey);
var dbEntity = (dataInstance as CompositeResult)?.Values.OfType <DbEntity>().FirstOrDefault() ?? context.FirstOrDefault <DbEntity>(o => o.Key == dbEntityVersion.Key);
Entity retVal = null;
var cache = new AdoPersistenceCache(context);
if (!dbEntityVersion.ObsoletionTime.HasValue)
{
switch (dbEntity.ClassConceptKey.ToString().ToUpper())
{
case EntityClassKeyStrings.Device:
retVal = cache?.GetCacheItem <DeviceEntity>(dbEntity.Key);
break;
case EntityClassKeyStrings.NonLivingSubject:
retVal = cache?.GetCacheItem <ApplicationEntity>(dbEntity.Key);
break;
case EntityClassKeyStrings.Person:
var ue = (dataInstance as CompositeResult)?.Values.OfType <DbUserEntity>().FirstOrDefault() ?? context.FirstOrDefault <DbUserEntity>(o => o.ParentKey == dbEntityVersion.VersionKey);
if (ue != null)
{
retVal = cache?.GetCacheItem <UserEntity>(dbEntity.Key);
}
else
{
retVal = cache?.GetCacheItem <Person>(dbEntity.Key);
}
break;
case EntityClassKeyStrings.Patient:
retVal = cache?.GetCacheItem <Patient>(dbEntity.Key);
break;
case EntityClassKeyStrings.Provider:
retVal = cache?.GetCacheItem <Provider>(dbEntity.Key);
break;
case EntityClassKeyStrings.Place:
case EntityClassKeyStrings.CityOrTown:
case EntityClassKeyStrings.Country:
case EntityClassKeyStrings.CountyOrParish:
case EntityClassKeyStrings.State:
case EntityClassKeyStrings.ServiceDeliveryLocation:
retVal = cache?.GetCacheItem <Place>(dbEntity.Key);
break;
case EntityClassKeyStrings.Organization:
retVal = cache?.GetCacheItem <Organization>(dbEntity.Key);
break;
case EntityClassKeyStrings.Material:
retVal = cache?.GetCacheItem <Material>(dbEntity.Key);
break;
case EntityClassKeyStrings.ManufacturedMaterial:
retVal = cache?.GetCacheItem <ManufacturedMaterial>(dbEntity.Key);
break;
default:
retVal = cache?.GetCacheItem <Entity>(dbEntity.Key);
break;
}
}
// Return cache value
if (retVal != null)
{
return(retVal);
}
else
{
return(base.CacheConvert(dataInstance, context));
}
}