Пример #1
0
        public static void CheckWcfConnection(object sender, DoWorkEventArgs e)
        {
            try
            {
                if (_heartbeatClient.State != CommunicationState.Opened ||
                    _heartbeatClient.State != CommunicationState.Opening ||
                    _heartbeatClient.State != CommunicationState.Created)
                {
                    _heartbeatClient.Abort();
                    _heartbeatClient = new TicketWcfServerClient("NetTcpBinding_ITicketWcfServer");
                    _heartbeatClient.Open();

                    IsBlockout = _heartbeatClient.IsAttractionInBlockout(ValidatorEnv.LocalFacilityInfo.FacilityId,
                                                                         ValidatorEnv.LocalFacilityInfo.OperationId);

                    if (IsBlockout)
                    {
                        ProgramIdleChecker.StubActivity();
                    }
                }

                //IsOnline = false;
                IsOnline = true;
            }
            catch (Exception ex)
            {
                IsOnline = false;
                // ignore WCF connection exception
            }
        }
Пример #2
0
        private void ParseCommand(string commandText)
        {
            if (DebuggingHook != null)
            {
                DebuggingHook(commandText);
                return;
            }

            //_log.Debug("[Card Command parsing ] step 1");
            commandText = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" + commandText;
            // _log.Debug("[Card command parsing] before load");
            //_log.Debug(commandText);

            var doc = new XmlDocument();

            doc.LoadXml(commandText);

            if (HeartbeatCommand.TryParseNExecute(doc))
            {
                return;
            }

            TappingCardCommand tappingCardCommand;

            if (TappingCardCommand.TryParse(doc, out tappingCardCommand))
            {
                ProgramIdleChecker.StubActivity();
                if (!FrmScanning.SingleInstance.UpdateMsgWorker.Busy())
                {
                    FrmScanning.SingleInstance.UpdateMsgWorker.RunAsync();
                }

                tappingCardCommand.Execute();
                return;
            }

            AfterdebitCommand afterdebitCommand;

            if (AfterdebitCommand.TryParse(doc, out afterdebitCommand))
            {
                ProgramIdleChecker.StubActivity();
                afterdebitCommand.Execute();
                return;
            }

            _log.Error("########Fatal Error#########");
            throw new Exception("Unexpected command received:" + commandText);
        }
Пример #3
0
        private void UpdateMsg(object sender, DoWorkEventArgs e)
        {
            try
            {
                if (ProgramIdleChecker.GetIdleTime() > IDLE_SEC * 1000 &&
                    ProgramIdleChecker.GetUserIdleSeconds() > IDLE_SEC)
                {
                    try
                    {
                        _picboxCollection.ShowVideo();
                    }
                    catch (Exception ex)
                    {
                        _log.Error("[UpdateMsg - Play video] -==>" + ex.Message + "\r\n" + ex.StackTrace);
                    }
                }
                else
                {
                    UIMsg msg = MsgManager.Instance.TryTake();

                    if (msg != null && !string.IsNullOrWhiteSpace(msg.Msg))
                    {
                        _picboxCollection.ShowScan();
                        MsgsUpdatedAt = DateTime.Now;
                        ProcessUIMsg(msg);
                    }
                    else
                    {
                        if ((DateTime.Now - MsgsUpdatedAt).TotalSeconds > ValidatorEnv.MsgShowingTime)
                        {
                            MsgsUpdatedAt = DateTime.Now;
                            Reset();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
            }
        }
Пример #4
0
        public void SerialPortListenAsync()
        {
            if (OnDataReceived == null)
            {
                throw new InvalidOperationException("must set callback [OnDataReceived] first.");
            }

            Net45Task.Run(() =>
            {
                logger.Info("Starting Open Virtual COM");

                var mySerialPort = new SerialPort(ValidatorEnv.COM_PORT);

                mySerialPort.BaudRate  = 115200;
                mySerialPort.Parity    = Parity.None;
                mySerialPort.StopBits  = StopBits.One;
                mySerialPort.DataBits  = 8;
                mySerialPort.Handshake = Handshake.None;
                mySerialPort.RtsEnable = true;
                mySerialPort.DtrEnable = true;

                mySerialPort.ReadTimeout = 500;

                mySerialPort.ErrorReceived += (sender, args) =>
                {
                    logger.Error("######error");
                    logger.Error(args.EventType);
                };

                // keep trying until open the com
                var failOpen = true;
                while (failOpen)
                {
                    try
                    {
                        mySerialPort.Open();
                        Thread.Sleep(1000);
                        failOpen = false;
                    }
                    catch
                    {
                        logger.Error("### COM OPEN FAILED ###  - TRYING AGAIN .");
                    }
                }

                logger.Info("####COM PORT opened...");
                while (true)
                {
                    try
                    {
                        string message = mySerialPort.ReadLine();

                        logger.Debug("################  COM LISTENER START  #############");
                        logger.Debug(message);
                        logger.Debug("################  COM LISTENER END  #############");

                        LastScanned = message;

                        ProgramIdleChecker.StubActivity();
                        if (!FrmScanning.SingleInstance.UpdateMsgWorker.Busy())
                        {
                            FrmScanning.SingleInstance.UpdateMsgWorker.RunAsync();
                        }
                        OnDataReceived(message);


                        Thread.Sleep(500);
                    }
                    catch (TimeoutException ex)
                    {
                        //COM is idle
                    }
                }
            });
        }