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