/// <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())); }
/// <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 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())); }
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); } }