/// <summary>
/// Handles the ExecuteCode event of the Prepare CodeActivity.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void Prepare_ExecuteCode(object sender, EventArgs e)
{
Logger.Instance.WriteMethodEntry(EventIdentifier.UpdateResourcesPrepareExecuteCode);
try
{
// If advanced options were not specified,
// clear any supplied advanced settings so they do not impact activity execution
if (!this.Advanced)
{
this.QueryResources = false;
this.ActivityExecutionCondition = null;
this.Iteration = null;
this.ActorType = ActorType.Service;
this.ApplyAuthorizationPolicy = false;
}
// If the activity is configured to query for resources,
// convert the queries hash table to a list of definitions that will feed the activity responsible
// for their execution
if (this.QueryResources && this.QueriesTable != null && this.QueriesTable.Count > 0)
{
DefinitionsConverter queriesConverter = new DefinitionsConverter(this.QueriesTable);
this.Queries = queriesConverter.Definitions;
}
// If the activity is configured for iteration or conditional execution, parse the associated expressions
this.ActivityExpressionEvaluator.ParseIfExpression(this.Iteration);
this.ActivityExpressionEvaluator.ParseIfExpression(this.ActivityExecutionCondition);
// Definitions are supplied to the workflow activity in the form of a hash table
// This is necessary due to deserialization issues with lists and custom classes
// Convert the updates hash table to a list of definitions that is easier to work with
DefinitionsConverter updatesConverter = new DefinitionsConverter(this.UpdatesTable);
this.updates = updatesConverter.Definitions;
// Load each source expression into the evaluator so associated lookups can be loaded into the cache for resolution
// For updates, the left side of the definition represents the source expression
foreach (Definition updateDefinition in this.updates)
{
this.ActivityExpressionEvaluator.ParseExpression(updateDefinition.Left);
}
}
finally
{
Logger.Instance.WriteMethodExit(EventIdentifier.UpdateResourcesPrepareExecuteCode);
}
}
/// <summary>
/// Handles the ExecuteCode event of the ParseConditions CodeActivity.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void ParseConditions_ExecuteCode(object sender, EventArgs e)
{
Logger.Instance.WriteMethodEntry(EventIdentifier.VerifyRequestParseConditionsExecuteCode);
try
{
// Definitions are supplied to the workflow activity in the form of a hash table
// This is necessary due to deserialization issues with lists and custom classes
// Convert the hash table to a list of definitions that is easier to work with
DefinitionsConverter converter = new DefinitionsConverter(this.ConditionsTable);
this.conditions = converter.Definitions;
// Load each condition expression into the evaluator so associated lookups
// can be loaded into the cache for resolution
foreach (Definition conditionDefinition in this.conditions)
{
this.ActivityExpressionEvaluator.ParseExpression(conditionDefinition.Left);
}
}
finally
{
Logger.Instance.WriteMethodExit(EventIdentifier.VerifyRequestParseConditionsExecuteCode);
}
}
/// <summary>
/// Handles the ExecuteCode event of the ParseExpressions CodeActivity.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void ParseExpressions_ExecuteCode(object sender, EventArgs e)
{
Logger.Instance.WriteMethodEntry(EventIdentifier.GenerateUniqueValueParseExpressionsExecuteCode);
try
{
// If the activity is configured for conditional execution, parse the associated expression
this.ActivityExpressionEvaluator.ParseIfExpression(this.ActivityExecutionCondition);
// Load each value expression into the evaluator so associated lookups can be loaded into the cache for resolution
// Before parsing the value expression, be sure to replace any instance of the [//UniquenessKey] lookup with
// a random value to prevent it from being loaded to the cache
// Standard resolution of this lookup would result in an exception
foreach (string valueExpression in this.ValueExpressions)
{
this.ActivityExpressionEvaluator.ParseExpression(this.ResolveUniquenessKey(valueExpression, 0, false));
}
// If the activity is configured to query LDAP for conflicts,
// convert the LDAP queries hash table to a list of definitions and then parse each query
if (!this.QueryLdap || this.LdapQueriesTable == null || this.LdapQueriesTable.Count <= 0)
{
return;
}
DefinitionsConverter queriesConverter = new DefinitionsConverter(this.LdapQueriesTable);
this.LdapQueries = queriesConverter.Definitions;
// Parse the expressions in the LDAP Queries, if any
for (int i = 0; i < this.LdapQueries.Count; ++i)
{
this.ActivityExpressionEvaluator.ParseIfExpression(this.LdapQueries[i].Left);
}
}
finally
{
Logger.Instance.WriteMethodExit(EventIdentifier.GenerateUniqueValueParseExpressionsExecuteCode);
}
}
/// <summary>
/// Handles the ExecuteCode event of the Prepare CodeActivity.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void Prepare_ExecuteCode(object sender, EventArgs e)
{
Logger.Instance.WriteMethodEntry(EventIdentifier.RunPowerShellScriptPrepareExecuteCode);
try
{
// If advanced options were not specified,
// clear any supplied advanced settings so they do not impact activity execution
if (!this.Advanced)
{
this.ActivityExecutionCondition = null;
this.PowerShellUser = null;
this.PowerShellUserPassword = null;
this.ImpersonatePowerShellUser = false;
this.ImpersonatePowerShellUserLoadUserProfile = false;
this.ImpersonatePowerShellUserLogOnType = LogOnType.None;
}
// If the script needs to be resolved, parse the expression via the
// expression evaluator to prepare for lookup resolution
if (this.ScriptLocation == PowerShellScriptLocation.Resource)
{
this.ActivityExpressionEvaluator.ParseExpression(this.Script);
}
// If the activity is configured for conditional execution, parse the associated expression
this.ActivityExpressionEvaluator.ParseIfExpression(this.ActivityExecutionCondition);
if (this.InputType == PowerShellInputType.Arguments &&
this.Arguments != null &&
this.Arguments.Count > 0)
{
// If we're supplying arguments to the PowerShell script,
// parse each argument in the list to facilitate resolution
foreach (string s in this.Arguments)
{
this.ActivityExpressionEvaluator.ParseExpression(s);
}
}
else if (this.InputType == PowerShellInputType.Parameters &&
this.ParametersTable != null &&
this.ParametersTable.Count > 0)
{
// If we're supplying named parameters ot the PowerShell script,
// parse the right side of the parameter listing which represents the value
DefinitionsConverter parametersConverter = new DefinitionsConverter(this.ParametersTable);
this.parameters = parametersConverter.Definitions;
foreach (Definition parameter in this.parameters)
{
this.ActivityExpressionEvaluator.ParseExpression(parameter.Right);
}
}
}
finally
{
Logger.Instance.WriteMethodExit(EventIdentifier.RunPowerShellScriptPrepareExecuteCode);
}
}
/// <summary>
/// Handles the ChildCompleted event of the ForEachIteration ReplicatorActivity.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ReplicatorChildEventArgs"/> instance containing the event data.</param>
private void ForEachIteration_ChildCompleted(object sender, ReplicatorChildEventArgs e)
{
Logger.Instance.WriteMethodEntry(EventIdentifier.UpdateResourcesForEachIterationChildCompleted, "Iteration: '{0}' of '{1}'. ", this.iterations, this.ForEachIteration.InitialChildData.Count);
try
{
var variableCache = this.ActivityExpressionEvaluator.VariableCache;
this.breakIteration = Convert.ToBoolean(variableCache[ExpressionEvaluator.ReservedVariableBreakIteration], CultureInfo.InvariantCulture);
// Reset to the original update definitions as ResolveDynamicGrammar updates the working definitions.
// The If check is really not needed.
if (this.ResolveDynamicGrammar)
{
DefinitionsConverter updatesConverter = new DefinitionsConverter(this.UpdatesTable);
this.updates = updatesConverter.Definitions;
}
}
finally
{
Logger.Instance.WriteMethodExit(EventIdentifier.UpdateResourcesForEachIterationChildCompleted, "Iteration: '{0}' of '{1}'. Break Iteration '{2}'.", this.iterations, this.ForEachIteration.InitialChildData.Count, this.breakIteration);
}
}
