/// <summary>
/// Preload all entity data to load an image.
/// </summary>
/// <param name="imageId"></param>
public void PreloadImage(EntityRef imageId)
{
string query = "isOfType.id, name, fileDataHash, fileExtension, flags.id, documentFileType.id";
var request = new EntityRequest(imageId, query, "Preload image");
BulkPreloader.Preload(request);
}
/// <summary>
/// Preload all entity data to load an image.
/// </summary>
/// <param name="imageId"></param>
public void PreloadImageThumbnail(EntityRef imageId)
{
string query = "isOfType.id, name, fileDataHash, fileExtension, flags.id, documentFileType.id, imageHasThumbnails.{ isOfType.id, thumbnailScaling.id, imageWidth, imageHeight, imageBackgroundColor }";
var request = new EntityRequest(imageId, query, "Preload image");
BulkPreloader.Preload(request);
}
/// <summary>
/// Prefetch the workflow run and related workflow an activities.
/// </summary>
/// <param name="workflowRunId"></param>
private static void PrecacheWorkflow(long workflowId)
{
var expressionMapReq = "name, isOfType.id, expressionString, isTemplateString, argumentToPopulate.id, wfExpressionKnownEntities.{name, isOfType.id, referencedEntity.isOfType.id}";
var activityArgumentReq = @"
name, isOfType.id, argumentIsMandatory"; // We are not loading any of the value fields as they are only used is storing and loading state
var activityTypeReq = "name, activityExecutionClass.{isOfType.id, typeName, assemblyName}, {inputArguments, internalArguments, outputArguments}.{" + activityArgumentReq + @"}, exitPoints.isOfType.id";
var wfActivityReq = "name, isOfType.{" + activityTypeReq + @"}, expressionMap.{" + expressionMapReq + "}";
var workflowRequest = @"
name, isOfType.{" + activityTypeReq + @"},
runtimeProperties.{name, isOfType.id},
containedActivities.{" + wfActivityReq + @"},
transitions.{name, fromActivity.isOfType.id, fromExitPoint.isOfType.id, toActivity.isOfType.id},
firstActivity.isOfType.id,
terminations.{fromActivity.isOfType.id, fromExitPoint.isOfType.id, workflowExitPoint.isOfType.id},
workflowExitPoint.isOfType.id,
variables.{" + activityArgumentReq + @"},
expressionParameters.{argumentInstanceActivity.isOfType.id, argumentInstanceArgument.isOfType.id, isOfType.id},
inputArgumentForAction.{" + activityArgumentReq + @"},
expressionMap.{" + expressionMapReq + @"}";
BulkPreloader.Preload(new EntityRequest(workflowId, workflowRequest, "Preload workflow " + workflowId.ToString()));
}
public void CleanPreload( )
{
BulkResultCache.Clear( );
BulkSqlQueryCache.Clear( );
using (new SecurityBypassContext( ))
{
BulkPreloader.TenantWarmup( );
}
}
/// <summary>
/// Pre-load report entities.
/// </summary>
/// <param name="reportId">The ID of the report to preload.</param>
public static void PreloadReport(EntityRef reportId)
{
using (MessageContext messageContext = new MessageContext("Reports"))
{
messageContext.Append(() => string.Format("Preload report {0}", reportId));
var rq = new EntityRequest(reportId, ReportPreloaderQuery, "Preload report " + reportId.ToString( ));
BulkPreloader.Preload(rq);
}
}
public void B_Clear_And_Warm()
{
if (ReportId == 0)
{
ReportId = CodeNameResolver.GetInstance("Forms", "Report").Id;
}
TestHelpers.ClearServerCaches();
BulkPreloader.TenantWarmup();
}
public void ReportPreloadTest( )
{
if (_reportId == 0)
{
_reportId = CodeNameResolver.GetInstance("Student report", "Report").Id;
}
var rq = new EntityRequest(_reportId, ReportHelpers.ReportPreloaderQuery, "ReportPreloadTest");
rq.IgnoreResultCache = true;
BulkPreloader.Preload(rq);
}
/// <summary>
/// Get the relationships that may have policies that are effected by the deletion of the entity.
/// </summary>
IEnumerable <Tuple <Relationship, Direction> > GetRelsWithPotentialPolicies(IResourceTriggerFilterPolicyCache policyCache, IEntity entity)
{
var forwardRelIds = EntityTypeHelper.GetAllRelationships(entity, Direction.Forward).Select(r => r.Id);
var reverseRelIds = EntityTypeHelper.GetAllRelationships(entity, Direction.Reverse).Select(r => r.Id);
// Prefill cache - note that we are requesting both the toType and fromType for each rel so we only need to do a single trip to the DB
var allRelIds = forwardRelIds.Union(reverseRelIds).Select(r => new EntityRef(r));
BulkPreloader.Preload(new EntityRequest(allRelIds, "toType.id, fromType.id"));
return(GetRelsWithPotentialPolicies(policyCache, forwardRelIds, Direction.Forward).Union(GetRelsWithPotentialPolicies(policyCache, reverseRelIds, Direction.Reverse)));
}
public void ChoiceField_Inherits_IsCached( )
{
EntityType entityType = Entity.Get <EntityType>("test:weekdayEnum");
// Includes relationships, as they inherit type.
const string typePreloaderQuery = "alias, name, isOfType.id, inherits.id, {k:defaultEditForm, defaultPickerReport, defaultDisplayReport}.isOfType.id, allowEveryoneRead, isAbstract, relationships.{id, isOfType.id}, reverseRelationships.{id, isOfType.id}, instanceFlags.id";
BulkPreloader.Preload(new EntityRequest("type", typePreloaderQuery, QueryType.Instances, "Preload types"));
using (CacheManager.ExpectCacheHits( ))
{
entityType.Inherits.ToList();
}
}
/// <summary>
/// Prefetch the workflow run and related workflow an activities.
/// </summary>
/// <param name="workflowRunId"></param>
private void PrecacheWorkflow(long workflowRunId)
{
var stateInfoRequest = @"
{stateInfoArgument, stateInfoActivity}.{isOfType.id, name},
stateInfoValue.isOfType.id";
var request = @"
isOfType.id,
workflowRunStatus.id, workflowHasErrors, errorLogEntry.isOfType.id, runCompletedAt, triggerDepth,
parentRun.isOfType.id,
workflowRunExitPoint.isOfType.id, stateInfo.{" + stateInfoRequest + @"},
workflowBeingRun.id"; // no need to prefetch the workflow as it is already fetched during metadata creation
BulkPreloader.Preload(new EntityRequest(workflowRunId, request, "Preload workflow run " + workflowRunId.ToString()));
}
/// <summary>
/// Preloads the tenant.
/// </summary>
/// <param name="tenant">The tenant.</param>
private static void PreloadTenant(KeyValuePair <long, string> tenant)
{
try
{
EventLog.Application.WriteInformation($"EDC.SoftwarePlatform.WebApi Preload tenant '{tenant.Value}' starting...");
RequestContext.SetTenantAdministratorContext(tenant.Key);
BulkPreloader.TenantWarmup( );
RequestContext.FreeContext( );
EventLog.Application.WriteInformation($"EDC.SoftwarePlatform.WebApi Preload tenant '{tenant.Value}' complete.");
}
catch (Exception exc)
{
EventLog.Application.WriteError($"Failed to preload tenant '{tenant.Value}'. {exc}");
}
}
public void ReportingInterface_RunReport_WithSecurity(string reportName)
{
BulkPreloader.TenantWarmupIfNotWarm();
long reportId = reportLookup[reportName];
using (CacheManager.EnforceCacheHitRules())
//using (Profiler.Measure("Run report test"))
{
ReportingInterface ri = new ReportingInterface();
ri.RunReport(reportId, new ReportSettings
{
InitialRow = 0,
PageSize = 1,
RequireFullMetadata = true,
RequireBasicMetadata = true
});
}
}
public void Reverse_Relationship_IsCached( )
{
// columnRollup is a reverse relationship.
long reportId = CodeNameResolver.GetInstance("AA_Manager", Report.Report_Type).Single( ).Id;
string query = @"
isOfType.id,
reportColumns.isOfType.id,
reportColumns.columnRollup.isOfType.id";
var rq = new EntityRequest(reportId, query);
BulkPreloader.Preload(rq);
using (CacheManager.ExpectCacheHits( ))
{
var report = EDC.ReadiNow.Model.Entity.Get <EDC.ReadiNow.Model.Report>(reportId);
report.ReportColumns.Any(rc => rc.ColumnRollup.Any( ));
}
}
/// <summary>
/// Pre-load just the query portion of a report.
/// </summary>
/// <param name="reportId">The ID of the report to preload.</param>
public static void PreloadQuery(EntityRef reportId)
{
var rq = new EntityRequest(reportId, QueryPreloaderQuery, "Preload query " + reportId.ToString( ));
BulkPreloader.Preload(rq);
}
bool OnBeforeRelsOtherEnds(IEnumerable <IEntity> entities, List <Action> postSaveActions)
{
using (Profiler.Measure("ResourceTriggerFilterEventTarget.OnBeforeDelete OnBeforeRelsOtherEnds"))
{
var policyCache = Factory.ResourceTriggerFilterPolicyCache;
foreach (var entity in entities)
{
//
// Get the filtered list of relationships that could possibly apply to some of the related entities
//
var filteredRels = GetRelsWithPotentialPolicies(policyCache, entity).ToList();
if (!filteredRels.Any())
{
continue;
}
// Prefill the cache
var requestString = string.Join(",", filteredRels.Select(r => (r.Item2 == Direction.Reverse ? "-#" : "#") + r.Item1.Id + ".id"));
BulkPreloader.Preload(new EntityRequest(entity.Id, requestString));
//
// Check each entity on the other end of the filtered rels t see if any policies apply
foreach (var relDir in filteredRels)
{
var rel = relDir.Item1;
var direction = relDir.Item2;
var relInstances = entity.GetRelationships(rel, direction);
foreach (var otherEntity in relInstances)
{
var otherType = otherEntity.TypeIds.First();
var policies = policyCache.TypePolicyMap[otherType].Where(p => p.UpdatedRelationshipsToTriggerOn.Contains(rel, EntityIdEqualityComparer <Relationship> .Instance));
foreach (var policy in policies)
{
var handler = policyCache.PolicyTypeHandlerMap[policy.TypeIds.First()];
bool result = false;
SecurityBypassContext.RunAsUser(() =>
{
if (handler.OnBeforeReverseRemove(policy, rel.Id, direction.Reverse(), otherEntity, entity))
{
result = true;
}
else
{
AddWrappedPostSaveAction(postSaveActions, () => handler.OnAfterReverseRemove(policy, rel.Id, direction.Reverse(), otherEntity, entity));
}
});
if (result)
{
return(true);
}
}
}
}
}
return(false);
}
}
public HttpResponseMessage Prewarm_Get()
{
BulkPreloader.TenantWarmup();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
