public static QueryExpression ExtractQueryInputFromContext(ICDSExecutionContext executionContext)
{
_ = executionContext ?? throw new ArgumentNullException(nameof(executionContext));
var inputParameters = executionContext.InputParameters;
if (!inputParameters.Contains("Query") || inputParameters["Query"] == null)
{
throw new ArgumentException("Context does not contain a valid query input argument.");
}
if (inputParameters["Query"] is QueryExpression)
{
return(inputParameters["Query"] as QueryExpression);
}
if (inputParameters["Query"] is FetchExpression)
{
var fetchExpression = inputParameters["Query"] as FetchExpression;
var conversionRequest = new FetchXmlToQueryExpressionRequest
{
FetchXml = fetchExpression.Query
};
var conversionResponse = (FetchXmlToQueryExpressionResponse)executionContext.OrganizationService.Execute(conversionRequest);
return(conversionResponse.Query);
}
throw new Exception("Could not extract a valid query expression from the execution context input parameters.");
}
private IServiceConfiguration LoadConfiguration(ICDSExecutionContext executionContext, bool disableCache)
{
var settings = SettingsFactory.Create(executionContext);
if (!disableCache && executionContext.Cache.Exists(CACHE_KEY))
{
return(executionContext.Cache.Get <IServiceConfiguration>(CACHE_KEY));
}
IServiceConfiguration config = new ServiceConfiguration();
//get all XML data configuration files located in the virtual configuration path.
var qry = new QueryExpression
{
EntityName = "webresource",
ColumnSet = new ColumnSet("name"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "name",
Operator = ConditionOperator.BeginsWith,
Values = { settings.ConfigurationDataPath }
}
}
}
};
var xmlDataResources = executionContext.OrganizationService.RetrieveMultiple(qry).Entities;
executionContext.Trace(string.Format("Retrieved {0} XML Data resource records.", xmlDataResources.Count));
// Process each named XML configuration resource to build out the field level configuration service configuration.
foreach (var resource in xmlDataResources)
{
var name = resource.GetAttributeValue <string>("name");
try
{
var xmlConfigData = executionContext.XmlConfigurationResources.Get(name, false);
config.AddConfiguration(xmlConfigData);
}
catch (Exception ex)
{
executionContext.Trace(Core.eSeverityLevel.Error, "Error processing entity file {0} - {1}", name, ex.Message);
}
}
if (!disableCache && executionContext.Cache != null && settings.CacheTimeout != null)
{
executionContext.Cache.Add <IServiceConfiguration>(CACHE_KEY, config, settings.CacheTimeout.Value);
}
return(config);
}
/// <summary>
/// Builder to enhance the passed in search filter by simulating a union with the results of additional
/// queries defined in the builder.
/// </summary>
/// <param name="executionContext"></param>
/// <param name="sourceQueryExpression">The source query</param>
/// <param name="useElevatedAccess">Will execute the additional defined queries as system user.</param>
public QuickFindQueryBuilder(ICDSExecutionContext executionContext, QueryExpression sourceQueryExpression, bool useElevatedAccess = false)
{
this.executionContext = executionContext ?? throw new ArgumentNullException(nameof(executionContext));
this.sourceQueryExpresion = sourceQueryExpression ?? throw new ArgumentNullException(nameof(sourceQueryExpression));
this.targetEntityLogicalName = new TEntity().LogicalName;
this.targetEntityIdField = this.targetEntityLogicalName + "id";
this.linkedEntities = new List <IQuickFindLinkedEntity>();
this.searchSignatures = new List <ISearchQuerySignature>();
this.useElevatedAccess = useElevatedAccess;
this.searchInFilter = false;
}
/// <summary>
/// Supports the Aliased Search Pattern. Examines query supplied in the plugin context query input.
/// If query runs against an entity of type <typeparamref name="TParent"/> the generator will
/// modify the query to include any matching records found in the related alias table
/// defined by <typeparamref name="TAlias"/>.
/// </summary>
public AliasedSearchQueryBuilder(ICDSExecutionContext executionContext)
{
ExecutionContext = executionContext;
TParent parent = new TParent();
parentEntityName = parent.LogicalName;
parentIdAttributeName = parent.LogicalName + "id";
TAlias alias = new TAlias();
aliasEntityName = alias.LogicalName;
linkingAttributeName = parentIdAttributeName;
}
public Guid[] GetLinkedIds(ICDSExecutionContext executionContext, string searchTerm, bool useElevatedAccess)
{
var processName = $"{nameof(QuickFindQueryExpressionBuilder<TTarget>)}.{nameof(GetLinkedIds)}";
executionContext.Trace($"Entered {processName}");
var qry = QueryExpressionBuilder
.WithSearchValue(searchTerm)
.Build();
// execute the query and return a list of target ids found.
var orgService = useElevatedAccess ? executionContext.ElevatedOrganizationService : executionContext.OrganizationService;
var ids = orgService.RetrieveMultiple(qry).Entities.Select(e => e.Id).ToArray();
executionContext.Trace($"Exiting {processName} - Returning {ids.Length} record ids.");
return(ids);
}
private void workingWithSerialization(ICDSExecutionContext executionContext, Entity target)
{
//Get upto 50 account records.
var records = executionContext.OrganizationService.Query <Account>().SelectAll().With.RecordLimit(50).RetrieveAll();
Model.Registrations registrations = new Model.Registrations();
foreach (var record in records)
{
registrations.Add(new Model.RegistrationData {
Id = record.Id, CreatedOn = record.CreatedOn.Value
});
}
var serializer = Container.Resolve <IJSONContractSerializer>();
var serializedData = registrations.ToString(serializer);
}
public Guid[] GetLinkedIds(ICDSExecutionContext executionContext, string searchTerm, bool useElevatedAccess)
{
var processName = $"{nameof(QuickFindParentEntity<TTarget, TParent>)}.{nameof(GetLinkedIds)}";
executionContext.Trace($"Entered {processName}");
if (linkingAttribute.Length == 0 || searchFields.Count == 0)
{
executionContext.Trace($"Exiting {processName} - No search fields or linking attribute.");
return(Array.Empty <Guid>());
}
var targetLogicalName = new TTarget().LogicalName;
var targetIdField = targetLogicalName + "id";
var parentLogicalName = new TParent().LogicalName;
var parentIdField = parentLogicalName + "id";
// create a query that returns ids for the target entity that are joined to
// the parent entity via the identified linking attribute where the parent entity
// matches any of the search fields.
var qry = new QueryExpression
{
EntityName = targetLogicalName,
ColumnSet = new ColumnSet(targetIdField),
Distinct = true,
NoLock = true,
TopCount = topCount,
LinkEntities =
{
new LinkEntity
{
JoinOperator = JoinOperator.Inner,
LinkFromEntityName = targetLogicalName,
LinkFromAttributeName = linkingAttribute,
LinkToEntityName = parentLogicalName,
LinkToAttributeName = parentIdField,
LinkCriteria = new FilterExpression
{
FilterOperator = LogicalOperator.And,
Conditions = { },
Filters =
{
new FilterExpression
{
FilterOperator = LogicalOperator.Or,
Conditions = { }
}
}
}
}
}
};
// unless inactive parents are excluded then add a condition to the linked entity criteria to only
// join active records.
if (!includeInactiveRecords)
{
executionContext.Trace($"{processName}: Filtering on active records.");
qry.LinkEntities[0].LinkCriteria.Conditions.Add(new ConditionExpression("statecode", ConditionOperator.Equal, 0));
}
// add one condition for each search field to the linked entity search filter.
foreach (var field in searchFields)
{
qry.LinkEntities[0].LinkCriteria.Filters[0].Conditions.Add(new ConditionExpression(field, ConditionOperator.Like, searchTerm + "%"));
}
// execute the query and return a list of target ids found.
var orgService = useElevatedAccess ? executionContext.ElevatedOrganizationService : executionContext.OrganizationService;
var ids = orgService.RetrieveMultiple(qry).Entities.Select(e => e.Id).ToArray();
executionContext.Trace($"Exiting {processName} - Returning {ids.Length} record ids.");
return(ids);
}
