internal static void CreateExecutionSteps(this _ExecutionStepFactory factory)
{
using (ILogMethod method = Log.LogMethod(DYN_MODULE_NAME, "CreateExecutionSteps"))
{
try
{
ExecutionStepDictionary execSteps = factory.ExecutionSteps;
ExecutionStepDeviceTypes deviceType = ExecutionStepFactory.Current.DeviceType;
IDictionary <string, ExecutionStepCollection> messageWiseSteps = factory.MessageWiseSteps;
IDictionary <int, ExecutionStepCollection> groupedSteps = factory.GroupedSteps;
var mappings = (from m in _mappings
from j in m.Attributes
where j.DeviceType == deviceType
select m).ToArray();
foreach (var mapping in mappings)//.AsParallel())
{
Type classType = mapping.Type;
IExecutionStep step = factory.AddOrUpdate(classType, classType.Name);
foreach (var mappingAttribute in mapping.Attributes
.Where(d => d.DeviceType == deviceType))
{
if (mappingAttribute.IsStart && (execSteps.Start == null))
{
execSteps.Start = step;
}
if (mappingAttribute.IsEnd && (execSteps.End == null))
{
execSteps.End = step;
}
step.PostTypeG2H = mappingAttribute.PostTypeG2H;
step.PostTypeH2G = mappingAttribute.PostTypeH2G;
step.MoveToNextStep = mappingAttribute.MoveToNextStep;
//if (mappingAttribute.Dependencies != null)
//{
// foreach (var dependency in mappingAttribute.Dependencies)
// {
// IExecutionStep parentStep = execSteps.AddOrUpdate(dependency, dependency.Name);
// if (!parentStep.NextSteps.Contains(step))
// parentStep.NextSteps.Add(step);
// }
//}
//if (mappingAttribute.NextDependency != null)
//{
// var dependency = mappingAttribute.NextDependency;
// IExecutionStep nextStep = execSteps.AddOrUpdate(dependency, dependency.Name);
// if (!step.NextSteps.Contains(nextStep))
// step.NextSteps.Add(nextStep);
// step.NextStep = nextStep;
// step.SetNextStep = mappingAttribute.SetNextStep;
// nextStep.PrevStep = step;
//}
if (mappingAttribute.NextSteps != null)
{
foreach (var dependency in mappingAttribute.NextSteps)
{
IExecutionStep nextStep = factory.AddOrUpdate(dependency, dependency.Name);
//nextStep.Level = step.Level + 1;
bool resetNextStep = false;
if (!step.NextSteps.Contains(nextStep))
{
step.NextSteps.Add(nextStep);
resetNextStep = (step.NextSteps.Count > 1);
}
step.NextStep = (resetNextStep ? null : nextStep);
if (!nextStep.PrevSteps.Contains(step))
{
nextStep.PrevSteps.Add(step);
}
//step.SetNextStep = mappingAttribute.SetNextStep;
//nextStep.PrevStep = step;
}
}
if (messageWiseSteps != null &&
mappingAttribute.AllowedMessages != null)
{
var direction = mappingAttribute.AllowedMessageDirectionAll;
int length = mappingAttribute.AllowedMessages.Length;
for (int i = 0; i < mappingAttribute.AllowedMessages.Length; i++)
{
if (mappingAttribute.AllowedMessageDirections != null)
{
direction = mappingAttribute.AllowedMessageDirections[i];
}
ExecutionStepKeyValue pair = new ExecutionStepKeyValue(mappingAttribute.AllowedMessages[i].Name, direction);
string pairKey = pair.FullKey;
if (!step.AllowedMessages.ContainsKey(pair))
{
step.AllowedMessages.Add(pair, 1);
}
ExecutionStepCollection execSteps2 = null;
if (messageWiseSteps.ContainsKey(pairKey))
{
execSteps2 = messageWiseSteps[pairKey];
}
else
{
messageWiseSteps.Add(pairKey, (execSteps2 = new ExecutionStepCollection()));
}
execSteps2.Add(step);
}
if (mappingAttribute.AllowedReplyMessages != null &&
mappingAttribute.AllowedReplyMessages.Length == length)
{
for (int j = 0; j < length; j++)
{
Type type1 = mappingAttribute.AllowedMessages[j];
Type type2 = mappingAttribute.AllowedReplyMessages[j];
if (type1 != null && type2 != null)
{
factory.RequestResponseMappings.Add(type1.Name, type2.Name, new RequestResponseMapItem());
}
}
}
}
}
}
// execution step grouping
if (messageWiseSteps != null &&
groupedSteps != null)
{
execSteps.ArrangeExecutionSteps(messageWiseSteps, groupedSteps);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public bool Execute(IFreeformEntity_Msg request)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "Execute"))
{
bool result = default(bool);
string key = string.Empty;
try
{
key = request.IpAddress;
ExecutionStepDictionary steps = _executionSteps;
_isExecuting = true;
//_gmuExecutionStepsExecuting.AddOrUpdate(key, true, (k, b) => { return true; });
//if (!_gmuExecutionSteps.ContainsKey(key))
//{
// steps = new ExecutionStepDictionary();
// steps.Entity.GmuIpAddress = key;
// steps.CreateExecutionSteps(ExecutionStepFactory.Current.DeviceType, _messageWiseSteps, _groupedSteps);
// _gmuExecutionSteps.Add(key, steps);
// _entities.Add(steps.Entity);
//}
//else
//{
// steps = _gmuExecutionSteps[key];
//}
if (steps != null)
{
// has clients
bool hasClients = false;
ExCommsExecutionStepEntity entity = steps.Entity;
IExecutionStep execStepCurrent = null;
IExecutionStep execStepLatest = null;
entity.Steps.Clear();
if (ExCommsServerImpl.Current != null)
{
hasClients = ExCommsServerImpl.Current.HasStepChangedClients;
}
#if !OLD_CODE
// 1. find the execution step by message
string messageKey = request.EntityUniqueKeyDirection;
if (_messageWiseSteps.ContainsKey(messageKey))
{
var stepList = _messageWiseSteps[messageKey];
if (stepList.Count == 1)
{
execStepCurrent = stepList[0];
}
}
// execute the step
if (execStepCurrent != null)
{
// last step
IExecutionStep execStepLast = (steps.Current ?? steps.Start);
if (hasClients && execStepLast != null)
{
entity.Steps.Add(execStepLast.GetType().Name);
}
// execute the current step
execStepLatest = execStepCurrent.Execute(request);
//// move to or set to next step
//if (execStepLatest != null &&
// execStepLatest.ExecutionResult == ExecutionStepResult.Success)
//{
// if (execStepLatest.NextStep != null)
// {
// if (execStepLatest.MoveToNextStep)
// {
// if (hasClients && execStepLatest.NextStep != null)
// entity.Steps.Add(execStepLatest.NextStep.GetType().Name);
// execStepLatest = execStepLatest.NextStep.Execute(request);
// }
// //if (execStepLatest.SetNextStep)
// //{
// // if (hasClients)
// // entity.Steps.Add(execStepLatest.GetType().Name);
// // execStepLatest = execStepLatest.NextStep;
// // execStepLatest.ExecutionResult = ExecutionStepResult.Success;
// //}
// }
//}
if (execStepLatest != null &&
execStepLatest.ExecutionResult == ExecutionStepResult.Success &&
!Object.ReferenceEquals(steps.Current, execStepLatest))
{
steps.Current = execStepLatest;
}
}
#else
// last step
IExecutionStep step = (steps.Current ?? steps.Start);
if (hasClients && step != null)
{
entity.Steps.Add(step.GetType().Name);
}
// previous step
if (step.ExecutionResult == ExecutionStepResult.Failed &&
step.PrevStep != null)
{
step = step.PrevStep;
}
// execute the current step
if (hasClients && step != null)
{
entity.Steps.Add(step.GetType().Name);
}
IExecutionStep step2 = step.Execute(request);
// move to or set to next step
if (step2 != null &&
step2.ExecutionResult == ExecutionStepResult.Success)
{
if (step2.NextStep != null)
{
if (step2.MoveToNextStep)
{
if (hasClients && step2.NextStep != null)
{
entity.Steps.Add(step2.NextStep.GetType().Name);
}
step2 = step2.NextStep.Execute(request);
}
if (step2.SetNextStep)
{
if (hasClients)
{
entity.Steps.Add(step2.GetType().Name);
}
step2 = step2.NextStep;
step2.ExecutionResult = ExecutionStepResult.Success;
}
}
}
if (step2 != null &&
step2.ExecutionResult == ExecutionStepResult.Success &&
!Object.ReferenceEquals(steps.Current, step2))
{
steps.Current = step2;
}
#endif
if (hasClients)
{
if (execStepLatest != null)
{
entity.Steps.Add(execStepLatest.UniqueKey);
}
ExCommsServerImpl.Current.OnNotifyExecutionStepChanged(entity);
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
finally
{
//_gmuExecutionStepsExecuting.AddOrUpdate(key, false, (k, b) => { return false; });
_isExecuting = false;
}
return(result);
}
}