protected override IMonitorEntity_MsgTgt CreateMonitorTarget(IMonitorEntity parent, IFreeformEntity_MsgTgt request)
{
using (ILogMethod method = Log.LogMethod("MonTgtParser_PC_EnrollmentParameterRequest_G2H", "CreateMonitorTarget"))
{
try
{
FFTgt_G2H_PC_EnrollmentParameterRequest ffTgt = request as FFTgt_G2H_PC_EnrollmentParameterRequest;
if (ffTgt == null)
{
return(null);
}
MonTgt_G2H_PC_EnrollmentParameterRequest monTgt = new MonTgt_G2H_PC_EnrollmentParameterRequest()
{
PlayerAccNoLen = ffTgt.PlayerAccNoLen,
PlayerAccNo = ffTgt.PlayerAccNo,
PlayerPIN = ffTgt.PlayerPIN,
};
return(monTgt);
}
catch (Exception ex)
{
method.Exception(ex);
return(null);
}
}
}
public virtual string ToStringDetail()
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "ToStringDetail"))
{
StringBuilder sb = new StringBuilder();
try
{
if (this.RawData != null)
{
string prefix = string.Empty;
sb.AppendLine();
FreeformHelper.WriteLogStringLine(sb, prefix);
sb.AppendLine(prefix + string.Format("Length : {0:D}", this.RawData.Length));
sb.AppendLine("Data : ");
FreeformHelper.ConvertBytesToHexString(this.RawData, sb, prefix);
sb.AppendLine();
FreeformHelper.WriteLogStringLine(sb, prefix);
if (this.EntityData != null)
{
this.EntityData.ToStringDetail(sb, "\t");
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(sb.ToString());
}
}
protected override bool OnExecuteInternal(MonitorExecutionContext context, MonitorEntity_MsgTgt target)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "OnExecuteInternal"))
{
bool result = default(bool);
MonMsg_G2H request = context.G2HMessage;
MonTgt_G2H_Status_NovoTicketCreate tgtSrc = target as MonTgt_G2H_Status_NovoTicketCreate;
try
{
InstallationDetailsForMSMQ dbData = request.Extra as InstallationDetailsForMSMQ;
int installationNo = request.InstallationNo;
method.InfoV("Creating novo ticket for {0:D} Ticket value {1:D} Ticket Number {2:D}", installationNo, tgtSrc.TicketAmount, tgtSrc.TicketNumber);
result = ExCommsDataContext.Current.InsertTicket(installationNo, dbData.Machine_No,
installationNo, tgtSrc.TicketAmount, tgtSrc.TicketNumber, tgtSrc.PrintDate);
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
private void Initialize()
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "Initialize"))
{
try
{
// transceiver socket for sending and receiving freeform messages
IUdpSocketTransceiver socket = UdpSocketTransceiverFactory.Create(this.ExecutorService, new UdpSocketTransceiverParameter()
{
IPAddress = !_arg.LocalIpAddress.IsEmpty() ? _arg.LocalIpAddress : IPAddress.Any.ToString(),
ListenWaitTime = 100,
InterfaceIP = _arg.InterfaceIpAddress,
MulticastIP = _arg.MulticastIpAddress,
PortNo = _arg.ReceivePortNo,
UseInternalQueue = false,
});
_sockReceiver = socket;
_sockTransmitter = socket;
_sockReceiver.DataReceived += new UdpSocketReceivedDataHandler(OnReceiveUdpEntityFromSocket);
_sockReceiver.Start();
method.Info("Initialize (Success)");
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public virtual IFFParser GetParserFromAppId(int appId, out int gmuId)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "GetParserFromEntityId"))
{
gmuId = 0;
IFFParser result = default(IFFParser);
try
{
FFParserItem parserItem = null;
if (_parserMappings.ContainsKey(appId))
{
parserItem = _subParsers[_parserMappings[appId]];
}
else
{
parserItem = _subParsers[-1];
}
gmuId = parserItem.GmuId;
result = parserItem[this.FlowInitiation].Parser;
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
/// <summary>
/// Initializes the freeform transceiver.
/// </summary>
/// <returns>True if succeeded; otherwise false.</returns>
private bool Initialize_FreeformTransceiver()
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "Initialize_FreeformTransceiver"))
{
bool result = false;
try
{
_ffTranceiver = FFTransceiverFactory.Create(new FFTransceiverArgs
{
LocalIpAddress = string.Empty,
InterfaceIpAddress = _storeComm.InterfaceIp,
MulticastIpAddress = _storeComm.MulticastIp,
ReceivePortNo = _storeComm.ReceivePortNo,
SendPortNo = _storeComm.TransmitPortNo,
}, this.Executor);
_ffTranceiver.Receive += OnTransceiver_Receive;
result = true;
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
public static IExCommsServiceInfo Run(IExecutorService executorService, string[] args)
{
using (ILogMethod method = Log.LogMethod("CommsServicesFactrory", "Run"))
{
IExCommsServiceInfo result = null;
try
{
var activators = MEFHelper.GetExportedValues <IExCommsServerHostFactoryActivator>();
string key = args.Length == 0 ? "/all" :
((args[0] == "/debug") ?
((args.Length == 1) ? "/all" : args[1]) : args[0]);
if (_servicesInfo.ContainsKey(key))
{
result = _servicesInfo[key](executorService, activators);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
protected virtual void Initialize()
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "FFParser_EnumCollection_Generic_B2B"))
{
try
{
_parsers = new DoubleKeyDictionary <string, IFFEnumParser>(StringComparer.InvariantCultureIgnoreCase);
var enumItems = (from i in typeof(FFEnumParserFactory).Assembly.GetTypes()
where i.IsEnum
from c in i.GetCustomAttributes(typeof(FFGmuIdAppIdMappingAttribute), true).OfType <FFGmuIdAppIdMappingAttribute>()
select new
{
Attr = c,
EnumType = i
}).ToArray();
foreach (var enumItem in enumItems)
{
FFGmuIdAppIdMappingAttribute mapAttr = enumItem.Attr;
mapAttr.GmuIdType = enumItem.EnumType;
IFFEnumParser parser = new FFEnumParser();
parser.AddBufferEntityParser(mapAttr.GmuIdType, mapAttr.AppIdType, parser);
_parsers.Add(mapAttr.GmuIdType.FullName, mapAttr.AppIdType.FullName, parser);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public InstallationDetailsForMSMQ GetInstallationFromCache(string key, int installationNo)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "GetInstallationFromCache"))
{
InstallationDetailsForMSMQ data = null;
try
{
var cache = this.InstallationDetailsCache;
bool force = (key.IsEmpty() ||
!cache.ContainsKey(key) ||
_configStore.ForceInstallations.ContainsKey(key));
data = (force ?
cache.AddOrUpdate2(key, ExCommsDataContext.Current.GetInstallationDetailsByDatapak(installationNo)) :
cache.GetIfExists(key));
}
catch (Exception ex)
{
method.Exception(ex);
}
return(data);
}
}
public V GetValueFromKey2(K2 key)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "GetValueFromKey2"))
{
V result = default(V);
try
{
if (_keyMappings.ContainsKey(key))
{
return(_keyMappings[key].Value);
}
else
{
return(default(V));
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
public virtual void AddParserItem(FF_FlowInitiation flowInitiation, int gmuId, int appId, IFFParser parser, FFTgtParseBufferHandler action)
{
using (ILogMethod method = Log.LogMethod("FFParserDictionary", "AddTargetParser"))
{
try
{
FFParserItem item = null;
if (!this.ContainsKey(gmuId))
{
this.Add(gmuId, (item = new FFParserItem()));
}
else
{
item = this[gmuId];
}
item.GmuId = gmuId;
item.AppId = appId;
FFParserItemInfo itemInfo = item[flowInitiation];
itemInfo.Parser = parser;
itemInfo.Action = action;
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public void Add(K1 key1, K2 key2, V value)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "Add"))
{
try
{
if (_collection.ContainsKey(key1))
{
_collection[key1] = value;
}
else
{
_collection.Add(key1, value);
}
if (_keyMappings.ContainsKey(key2))
{
_keyMappings[key2] = new KeyValuePair2 <K1, V>(key1, value);
}
else
{
_keyMappings.Add(key2, new KeyValuePair2 <K1, V>(key1, value));
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public V GetValueFromKey1(K1 key)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "GetValueFromKey1"))
{
V result = default(V);
try
{
if (_collection.ContainsKey(key))
{
return(_collection[key]);
}
else
{
return(default(V));
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
public bool Remove(K1 key)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "Remove"))
{
bool result = default(bool);
try
{
if (this.ContainsKey(key))
{
V value = this[key];
K2 key2 = _getKey2(value);
if (!key.Equals(default(K2)) &&
_keyMappings.ContainsKey(key2))
{
_keyMappings.Remove(key2);
}
result = _collection.Remove(key);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
private void RemoveCallback(int index, object state, bool clientDisconnected)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "RemoveCallback"))
{
try
{
try
{
T callback = _callbacks[index];
Log.Info(":::=> " + callback.ToString() + " is successfully removed.");
if (_supportsState)
{
if (clientDisconnected)
{
state = _callbackStates[index];
}
}
this.OnAfterUnsubscribed(callback, state);
}
finally
{
_callbacks.RemoveAt(index);
if (_supportsState)
{
_callbackStates.RemoveAt(index);
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public bool Send(IFreeformEntity_Msg request)
{
using (ILogMethod method = Log.LogMethod(LOGGER, this.DYN_MODULE_NAME, "Send"))
{
bool result = default(bool);
try
{
if (request == null)
{
method.Info("Unable to send message. request is empty");
return(false);
}
using (UdpFreeformEntity entity = new UdpFreeformEntity())
{
entity.Address = request.IpAddress2;
entity.EntityData = request;
result = this.Send(entity);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
public virtual void AddBufferEntityParser(int gmuId, int appId, IFFParser parser, FFTgtParseBufferHandler action)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "AddBufferEntityParser"))
{
try
{
FF_FlowInitiation flowDirection = this.FlowInitiation;
if (_subParsers == null)
{
_subParsers = new FFParserDictionary();
}
if (_parserMappings == null)
{
_parserMappings = new IntDictionary <int>();
}
if (parser != null && parser.FlowInitiation != FF_FlowInitiation.Any)
{
flowDirection = parser.FlowInitiation;
}
_subParsers.AddParserItem(flowDirection, gmuId, appId, parser, action);
if (appId != -1 &&
!_parserMappings.ContainsKey(appId))
{
_parserMappings.Add(appId, gmuId);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
protected override bool StartInternal()
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "StartInternal"))
{
bool result = default(bool);
try
{
_socket = new TcpSocketServer(_parameter.PortNo, _parameter.ClientThreads);
string boundAddress = _socket.LocalEndPoint.ToString();
method.InfoV("Socket bind address : {0}", boundAddress);
// bind the socket
result = _socket.Bind();
if (result)
{
method.InfoV("Socket was successfully bounded to : {0}", boundAddress);
_socket.ReceivedBytes += OnSocket_ReceivedBytes;
}
else
{
method.InfoV("!!! Unable to bind the socket on : {0}", boundAddress);
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result);
}
}
public byte[] ParseTarget(IFreeformEntity entity)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "ParseTarget"))
{
List <byte> result = new List <byte>();
try
{
if (entity.Targets != null &&
entity.Targets.Count > 0)
{
foreach (var target in entity.Targets)
{
byte[] data = this.ParseEntity(target);
if (data != null)
{
result.AddRange(data);
}
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(result.ToArray());
}
}
protected override IFreeformEntity_MsgTgt CreateFreeformTarget(IMonitorEntity parent, IMonitorEntity_MsgTgt request)
{
using (ILogMethod method = Log.LogMethod("MonTgtParser_PC_PlayerEnrollmentResponse_H2G", "CreateMonitorTarget"))
{
try
{
MonTgt_H2G_PC_PlayerEnrollmentResponse monTgt = request as MonTgt_H2G_PC_PlayerEnrollmentResponse;
if (monTgt == null)
{
return(null);
}
FFTgt_H2G_PC_PlayerEnrollmentResponse ffTgt = new FFTgt_H2G_PC_PlayerEnrollmentResponse()
{
ErrorCode = monTgt.ErrorCode,
DisplayMessageLength = monTgt.DisplayMessageLength,
DisplayMessage = monTgt.DisplayMessage,
};
return(ffTgt);
}
catch (Exception ex)
{
method.Exception(ex);
return(null);
}
}
}
private void RegisterMessageParsers()
{
using (ILogMethod method = Log.LogMethod("", ".cctor()"))
{
try
{
IFFParser parser1 = new FFParser_Msg_MC300_G2H_1(this)
{
TargetParser = this.TargetParser
};
IFFParser parser2 = new FFParser_Msg_MC300_G2H_2(this)
{
TargetParser = this.TargetParser
};
IFFParser parser3 = new FFParser_Msg_MC300_G2H_3(this)
{
TargetParser = this.TargetParser
};
this.AddBufferEntityParser((int)-1, -1, parser1);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.ACK, (int)FF_AppId_G2H_Commands.ACK, parser1);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.Freeform2, (int)FF_AppId_G2H_Commands.Freeform2, parser2);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.Freeform3NoResponse, (int)FF_AppId_G2H_Commands.Freeform3NoResponse, parser3);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.Freeform3Response, (int)FF_AppId_G2H_Commands.Freeform3Response, parser3);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.GMUInitA0, (int)FF_AppId_G2H_Commands.GMUInitA0, parser1);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.NACK, (int)FF_AppId_G2H_Commands.NACK, parser1);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.None, (int)FF_AppId_G2H_Commands.None, parser1);
this.AddBufferEntityParser((int)FF_GmuId_G2H_Commands.ResponseRequest, (int)FF_AppId_G2H_Commands.ResponseRequest, parser1);
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public virtual FFParserItem GetParserItemFromAppId(int appId, out int gmuId)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "GetParserFromEntityId"))
{
gmuId = 0;
FFParserItem parserItem = default(FFParserItem);
try
{
if (_parserMappings.ContainsKey(appId))
{
parserItem = _subParsers[_parserMappings[appId]];
}
else
{
parserItem = _subParsers[-1];
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(parserItem);
}
}
protected override bool ProcessG2HMessageInternal(MonMsg_G2H request)
{
using (ILogMethod method = Log.LogMethod("MonitorHandler_EPI_23_3", "ProcessG2HMessageInternal"))
{
try
{
MonTgt_G2H_EFT_DepositRequest monDepositRequest = request.Targets[0] as MonTgt_G2H_EFT_DepositRequest;
if (monDepositRequest == null)
{
return(false);
}
//DeleteEPIMessage(request.InstallationNo);
if (DoDepositRequest(request, monDepositRequest))
{
method.Info("Deposit Request Transfer done");
}
else
{
method.Info("Deposit Request Could not complete your transaction");
}
return(true);
}
catch (Exception ex)
{
//EPIMsgProcessor.Current.SendEPIMessage(monBalanceResponse);
//EPIMsgProcessor.Current.DisplayBallyWelcomeMsg(request.InstallationNo, );
method.Exception(ex);
}
return(false);
}
}
private static IPlayerGateway InitPlayerGateway()
{
using (ILogMethod method = Log.LogMethod("HandlerHelper", "InitPlayerGateway"))
{
IPlayerGateway gateway = default(IPlayerGateway);
try
{
gateway = GatewayFactory.GetGateway(GatewayType.SDT);
gateway.Initialize();
gateway.SocketSenderPT2.ReceiveTimeout = GatewaySettings.PTAsyncReceiveTimeout;
gateway.SocketSenderPT.ReceiveTimeout = GatewaySettings.PTAsyncReceiveTimeout;
gateway.SocketSenderCA2.ReceiveTimeout = GatewaySettings.CAAsyncReceiveTimeout;
gateway.SocketSenderCA.ReceiveTimeout = GatewaySettings.CAAsyncReceiveTimeout;
gateway.SocketSenderPT.Initialize(_configStore.PT_GATEWAY_IP, _configStore.SDT_SendPTPortNo);
gateway.SocketSenderPT2.Initialize(_configStore.PT_GATEWAY_IP, _configStore.SDT_ReceivePTPortNo);
gateway.SocketSenderCA.Initialize(_configStore.PT_GATEWAY_IP, _configStore.SDT_SendCAPortNo);
gateway.SocketSenderCA2.Initialize(_configStore.PT_GATEWAY_IP, _configStore.SDT_ReceiveCAPortNo);
if (GatewaySettings.SocketSendWithoutReconnect)
{
gateway.SocketSenderPT.SendTimeout = GatewaySettings.PTAsyncSendTimeout;
gateway.SocketSenderCA.SendTimeout = GatewaySettings.CAAsyncSendTimeout;
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(gateway);
}
}
protected override IFreeformEntity_MsgTgt CreateFreeformTarget(IMonitorEntity parent, IMonitorEntity_MsgTgt request)
{
using (ILogMethod method = Log.LogMethod("MonTgtParser_PC_LimitReachedNotificationMessage_H2G", "CreateMonitorTarget"))
{
try
{
MonTgt_H2G_PC_LimitReachedNotificationMessage monTgt = request as MonTgt_H2G_PC_LimitReachedNotificationMessage;
if (monTgt == null)
{
return(null);
}
FFTgt_H2G_PC_LimitReachedNotificationMessage ffTgt = new FFTgt_H2G_PC_LimitReachedNotificationMessage()
{
LockType = monTgt.LockType,
DisplayTime = monTgt.DisplayTime,
DisplayInterval = monTgt.DisplayInterval,
DisplayMessageLength = monTgt.DisplayMessageLength,
DisplayMessage = monTgt.DisplayMessage
};
return(ffTgt);
}
catch (Exception ex)
{
method.Exception(ex);
return(null);
}
}
}
protected override IMonitorEntity_MsgTgt CreateMonitorTarget(IMonitorEntity parent, IFreeformEntity_MsgTgt request)
{
using (ILogMethod method = Log.LogMethod("MonTgtParser_PC_NotificationResponse_G2H", "CreateMonitorTarget"))
{
try
{
FFTgt_G2H_PC_NotificationResponse ffTgt = request as FFTgt_G2H_PC_NotificationResponse;
if (ffTgt == null)
{
return(null);
}
MonTgt_G2H_PC_NotificationResponse monTgt = new MonTgt_G2H_PC_NotificationResponse()
{
AcknowledgementType = ffTgt.AcknowledgementType,
PlayerAccNoLen = ffTgt.PlayerAccNoLen,
PlayerAccNo = ffTgt.PlayerAccNo
};
return(monTgt);
}
catch (Exception ex)
{
method.Exception(ex);
return(null);
}
}
}
protected override IFreeformEntity_MsgTgt CreateFreeformTarget(IMonitorEntity parent, IMonitorEntity_MsgTgt request)
{
using (ILogMethod method = Log.LogMethod("MonTgtParser_PC_RelaxedLimitEffectiveNotificationMsg_H2G", "CreateMonitorTarget"))
{
try
{
MonTgt_H2G_PC_RelaxedLimitEffectiveNotificationMsg monTgt = request as MonTgt_H2G_PC_RelaxedLimitEffectiveNotificationMsg;
if (monTgt == null)
{
return(null);
}
FFTgt_H2G_PC_RelaxedLimitEffectiveNotificationMsg ffTgt = new FFTgt_H2G_PC_RelaxedLimitEffectiveNotificationMsg()
{
IsDayTimeBasisChanged = monTgt.IsDayTimeBasisChanged,
DayNewTargetTime = monTgt.DayNewTargetTime,
DayOldTargetTime = monTgt.DayOldTargetTime,
IsWeekTimeBasisChanged = monTgt.IsWeekTimeBasisChanged,
WeekNewTargetTime = monTgt.WeekNewTargetTime,
WeekOldTargetTime = monTgt.WeekOldTargetTime,
IsMonthTimeBasisChanged = monTgt.IsMonthTimeBasisChanged,
MonthNewTargetTime = monTgt.MonthNewTargetTime,
MonthOldTargetTime = monTgt.MonthOldTargetTime,
IsDayLossBasisChanged = monTgt.IsDayLossBasisChanged,
DayNewTargetLoss = monTgt.DayNewTargetLoss,
DayOldTargetLoss = monTgt.DayOldTargetLoss,
IsWeekLossBasisChanged = monTgt.IsWeekLossBasisChanged,
WeekNewTargetLoss = monTgt.WeekNewTargetLoss,
WeekOldTargetLoss = monTgt.WeekOldTargetLoss,
IsMonthLossBasisChanged = monTgt.IsMonthLossBasisChanged,
MonthNewTargetLoss = monTgt.MonthNewTargetLoss,
MonthOldTargetLoss = monTgt.MonthOldTargetLoss,
IsDayWagerBasisChanged = monTgt.IsDayWagerBasisChanged,
DayNewTargetWager = monTgt.DayNewTargetWager,
DayOldTargetWager = monTgt.DayOldTargetWager,
IsWeekWagerBasisChanged = monTgt.IsWeekWagerBasisChanged,
WeekNewTargetWager = monTgt.WeekNewTargetWager,
WeekOldTargetWager = monTgt.WeekOldTargetWager,
IsMonthWagerBasisChanged = monTgt.IsMonthWagerBasisChanged,
MonthNewTargetWager = monTgt.MonthNewTargetWager,
MonthOldTargetWager = monTgt.MonthOldTargetWager,
};
return(ffTgt);
}
catch (Exception ex)
{
method.Exception(ex);
return(null);
}
}
}
protected override IFreeformEntity_MsgTgt CreateFreeformTarget(IMonitorEntity parent, IMonitorEntity_MsgTgt request)
{
using (ILogMethod method = Log.LogMethod("MonTgtParser_PC_EnrollmentParameterResponse_H2G", "CreateMonitorTarget"))
{
try
{
MonTgt_H2G_PC_EnrollmentParameterResponse monTgt = request as MonTgt_H2G_PC_EnrollmentParameterResponse;
if (monTgt == null)
{
return(null);
}
FFTgt_H2G_PC_EnrollmentParameterResponse ffTgt = new FFTgt_H2G_PC_EnrollmentParameterResponse()
{
Status = monTgt.Status,
IsDayTimeBasis = monTgt.IsDayTimeBasis,
DayDefaultTime = monTgt.DayDefaultTime,
IsDayTimeBasisMandatory = monTgt.IsDayTimeBasisMandatory,
IsWeekTimeBasis = monTgt.IsWeekTimeBasis,
WeekDefaultTime = monTgt.WeekDefaultTime,
IsWeekTimeBasisMandatory = monTgt.IsWeekTimeBasisMandatory,
IsMonthTimeBasis = monTgt.IsMonthTimeBasis,
MonthDefaultTime = monTgt.MonthDefaultTime,
IsMonthTimeBasisMandatory = monTgt.IsMonthTimeBasisMandatory,
IsDayLossBasis = monTgt.IsDayLossBasis,
DayDefaultLossValue = monTgt.DayDefaultLossValue,
IsDayLossBasisMandatory = monTgt.IsMonthLossBasisMandatory,
IsWeekLossBasis = monTgt.IsWeekLossBasis,
WeekDefaultLossValue = monTgt.WeekDefaultLossValue,
IsWeekLossBasisMandatory = monTgt.IsWeekLossBasisMandatory,
IsDayWagerBasis = monTgt.IsDayWagerBasis,
DayDefaultWager = monTgt.DayDefaultWager,
IsDayWagerBasisMandatory = monTgt.IsDayWagerBasisMandatory,
IsWeekWagerBasis = monTgt.IsWeekWagerBasis,
WeekDefaultWager = monTgt.WeekDefaultWager,
IsWeekWagerBasisMandatory = monTgt.IsWeekWagerBasisMandatory,
IsMonthWagerBasis = monTgt.IsMonthWagerBasis,
MonthDefaultWager = monTgt.MonthDefaultWager,
IsMonthWagerBasisMandatory = monTgt.IsWeekWagerBasisMandatory,
DisplayMessageLength = monTgt.DisplayMessageLength,
DisplayMessage = monTgt.DisplayMessage,
};
return(ffTgt);
}
catch (Exception ex)
{
method.Exception(ex);
return(null);
}
}
}
private static void ArrangeExecutionSteps(this ExecutionStepDictionary execSteps,
IDictionary <string, ExecutionStepCollection> messageWiseSteps,
IDictionary <int, ExecutionStepCollection> groupedSteps)
{
using (ILogMethod method = Log.LogMethod(DYN_MODULE_NAME, "ArrangeExecutionSteps"))
{
try
{
Stack <IExecutionStep> st = new Stack <IExecutionStep>();
st.Push(execSteps.Start);
IDictionary <string, IExecutionStep> steps = new StringDictionary <IExecutionStep>();
while (st.Count != 0)
{
IExecutionStep step = st.Pop();
int level = Math.Max(0, (from p in step.PrevSteps
select p.Level).DefaultIfEmpty().Max()) + 1;
if (!steps.ContainsKey(step.UniqueKey))
{
step.Level = level;
steps.Add(step.UniqueKey, step);
}
foreach (var step2 in step.NextSteps)
{
if (!steps.ContainsKey(step2.UniqueKey))
{
st.Push(step2);
}
}
}
// last step
execSteps.End.Level = Math.Max(0, (from p in steps.Values
select p.Level).DefaultIfEmpty().Max()) + 1;
// Ordered projects
groupedSteps.Clear();
var orderedSteps = (from p in execSteps.Values
orderby p.Level
group p by p.Level);
foreach (var orderedStep in orderedSteps)
{
ExecutionStepCollection stepsList = new ExecutionStepCollection();
groupedSteps.Add(orderedStep.Key, stepsList);
foreach (var step in orderedStep)
{
stepsList.Add(step);
}
}
}
catch (Exception ex)
{
method.Exception(ex);
}
}
}
public IExecutionStep Execute(IFreeformEntity_Msg request)
{
using (ILogMethod method = Log.LogMethod(this.DYN_MODULE_NAME, "ProcessMessage"))
{
try
{
ExecutionStep step = null;
this.ExecutionResult = ExecutionStepResult.None;
ExecutionStepKeyValue pair =
new ExecutionStepKeyValue(request.EntityUniqueKeyString, request.FlowDirection);
string uniqueKey = pair.FullKey;
// current execution step
if (this.CanExecute(pair, request))
{
step = this;
}
// next step is responsible
else if (_nextStep != null &&
_nextStep.CanExecute(pair, request))
{
step = _nextStep as ExecutionStep;
}
// any of the next steps is responsible
else if (_hasNextSteps)
{
if (_nextStepsCached.ContainsKey(uniqueKey))
{
step = _nextStepsCached[uniqueKey];
}
else
{
foreach (var nextStep in this.NextSteps)
{
if (nextStep.CanExecute(pair, request))
{
step = nextStep as ExecutionStep;
_nextStepsCached.Add(uniqueKey, step);
break;
}
}
}
}
// any thing is responsible?
if (step != null)
{
return(step.ExecuteInternal(method, request));
}
}
catch (Exception ex)
{
method.Exception(ex);
}
return(null);
}
}