private void ProcessToEmployeeCardSync(ActiveMachine Machine)
        {
            MachineManagerLazyInitializer manager = null;
            ActiveMachine _activeMachine          = null;


            List <Employeecarddata> getEmpcards = oCommonUtilities.CreateInstance().GetEmployeeCardPollingData();


            try
            {
                _activeMachine = Machine as ActiveMachine;
                List <Employeecarddata> cards = getEmpcards.Where(emp => emp.Installation_No == _activeMachine.Installation_No).ToList();

                EmployeeMasterCard      empcard       = new EmployeeMasterCard();
                List <Employeecarddata> lstEmpPolling = empcard._emppollingCollection;


                foreach (Employeecarddata data in lstEmpPolling)
                {
                    if (data.Installation_No == _activeMachine.Installation_No)
                    {
                        if (data.PollingStatus)
                        {
                            _activeMachine.Status = "Success";
                            oCommonUtilities.CreateInstance().UpdateEmployeecardPolling(cards[0].EmployeeCard, _activeMachine.Installation_No);
                        }
                        else
                        {
                            _activeMachine.Status = "Failed";
                        }
                    }
                }

                if (lstEmpPolling.Count == 0)
                {
                    _activeMachine.Status = "Failed";
                }
            }
            catch (Exception Ex)
            {
                LogManager.WriteLog("ProcessToEmployeeCardSync: " + Ex.Message, LogManager.enumLogLevel.Info);
                ExceptionManager.Publish(Ex);
            }
            finally
            {
                if (manager != null)
                {
                    try
                    {
                        manager.ReleaseMachineManager();
                        manager = null;
                    }
                    catch (Exception Ex)
                    {
                        LogManager.WriteLog("ProcessToEmployeeCardSync:ReleaseMachineManager " + Ex.Message, LogManager.enumLogLevel.Info);;
                    }
                }
            }
        }
        public bool EmployeecardSend(string EmpCardNo, string EmployeeFlags, int InstallationNo)
        {
            try
            {
                string      EmpFlags = EmployeeFlags.Substring(2);
                List <byte> enumver  = Enumerable.Range(0, EmpFlags.Length)
                                       .Where(x => x % 2 == 0)
                                       .Select(x => Convert.ToByte(EmpFlags.Substring(x, 2), 16)).ToList();

                List <byte> cardno = Enumerable.Range(0, EmpCardNo.PadLeft(10, '0').Length)
                                     .Where(x => x % 2 == 0)
                                     .Select(x => Convert.ToByte(EmpCardNo.PadLeft(10, '0').Substring(x, 2), 16)).ToList();

                enumver.Insert(0, Convert.ToByte(EmployeeFlags.Substring(0, 1)));
                enumver.Insert(1, Convert.ToByte(EmployeeFlags.Substring(1, 1)));
                enumver.InsertRange(0, cardno);

                byte[] bData = enumver.ToArray();

                bool status = new MachineManagerLazyInitializer().GetMachineManager().SendEmpCard(InstallationNo, 84, bData);
                return(status);
            }
            catch (Exception ex)
            {
                ExceptionManager.Publish(ex);
                return(false);
            }
        }
Esempio n. 3
0
        private void ProcessToSyncTicket(ActiveMachine Machine)
        {
            MachineManagerLazyInitializer manager = null;
            ActiveMachine _activeMachine          = null;


            try
            {
                _activeMachine = Machine as ActiveMachine;
                oCommonUtilities.CreateInstance().UpdateTicketExpire(Settings.Ticket_Expire);
                //MachineManagerInterface machineManagerInterface = new MachineManagerInterface();
                manager = new MachineManagerLazyInitializer();

                int nSuccess = manager.GetMachineManager().UpdateTicketConfig(_activeMachine.Installation_No, Settings.Ticket_Expire);
                if (nSuccess == 0)
                {
                    _activeMachine.Status = "Success";
                    oCommonUtilities.CreateInstance().UpdateGMUSiteCodeStatus(_activeMachine.Installation_No, 1);
                }
                else
                {
                    _activeMachine.Status = "Failed";
                }
            }
            catch (Exception Ex)
            {
                LogManager.WriteLog("ProcessToSyncTicket: " + Ex.Message, LogManager.enumLogLevel.Info);
                ExceptionManager.Publish(Ex);
            }
            finally
            {
                if (manager != null)
                {
                    try
                    {
                        manager.ReleaseMachineManager();
                        manager = null;
                    }
                    catch (Exception Ex)
                    {
                        LogManager.WriteLog("ProcessToSyncTicket:ReleaseMachineManager " + Ex.Message, LogManager.enumLogLevel.Info);;
                    }
                }
            }
        }