Exemplo n.º 1
0
        public void Initialize(string sStationNumber, BusinessProps bp)
        {
            lock (locker)
            {
                Log.InfoFormat("Initializing '{0}' {1}", sStationNumber, BusinessPropsToString(bp));

                m_sStationNumber = sStationNumber;

                ExcpHelper.ThrowIf(string.IsNullOrEmpty(m_sStationNumber), "Station Number is invalid");
                List <TransactionQueueSr> lObjects = TransactionQueueSr.GetByQuery("SELECT * FROM TransactionQueue WHERE Type = {0} OR Type = {1} OR Type = {2} ORDER BY TransactionQueueID DESC", (int)eTransactionQueueType.Ticket, (int)eTransactionQueueType.DepositByCreditNote, (int)eTransactionQueueType.Deposit);

                foreach (TransactionQueueSr tq in lObjects)
                {
                    eTransactionQueueType eType = (eTransactionQueueType)tq.Type;

                    if (eType == eTransactionQueueType.Ticket && m_lLastTicketNumber == 0)
                    {
                        m_lastTicket        = SerializeHelper.StringToDataContractObject <TicketWS>(tq.Object1);
                        m_lLastTicketNumber = ParseNumberId(m_lastTicket.ticketNbr);
                    }
                    else if (eType == eTransactionQueueType.DepositByCreditNote && m_lLastCreditNoteNumber == 0)
                    {
                        string sNoteNumber = tq.Object2;

                        m_lLastCreditNoteNumber = ParseNumberId(sNoteNumber);
                    }

                    if (m_lLastTicketNumber > 0 && m_lLastCreditNoteNumber > 0)
                    {
                        break;
                    }
                }


                m_lLastTransactionID    = bp.LastTransactionId;
                m_lLastTicketNumber     = Math.Max(m_lLastTicketNumber, bp.LastTicketNumber);
                m_lLastCreditNoteNumber = Math.Max(m_lLastCreditNoteNumber, bp.LastCreditNoteNumber);
            }
        }
Exemplo n.º 2
0
        private void CreateAndSaveTransactionQueue(eTransactionQueueType eType, string sDescription, string sTransactionId, uid User, string sObject1, string sObject2, string sObject3, string sTag1, string sTag2)
        {
            Debug.Assert(sDescription != null);

            TransactionQueueSr tq = null;


            tq = new TransactionQueueSr();

            tq.Type          = (short)eType;
            tq.Description   = sDescription;
            tq.TransactionId = sTransactionId;
            tq.UidState      = SerializeHelper.SerializableObjectToString <uid>(User);
            tq.Object1       = sObject1;
            tq.Object2       = sObject2;
            tq.Object3       = sObject3;
            tq.Tag1          = sTag1;
            tq.Tag2          = sTag2;

            tq.Created = DateTime.Now;

            tq.Save();
        }
Exemplo n.º 3
0
        public void TryToSaveTransactionObjectsOnHub()
        {
            lock (m_oLocker)
            {
                try
                {
                    List <TransactionQueueSr> lTransactionObjects = GetAllFromQueue();

                    if (lTransactionObjects != null && lTransactionObjects.Count > 0)
                    {
                        Logger.InfoFormat("Trying to save {0} Transaction Objects on HUB ...", lTransactionObjects.Count);

                        var lObjectsToDelete = new List <TransactionQueueSr>();


                        foreach (TransactionQueueSr tq in lTransactionObjects)
                        {
                            try
                            {
                                Logger.InfoFormat("Trying to save {0}", TraceTransactionQueue(tq));

                                eTransactionQueueType eType = ShortToType(tq.Type);
                                var uId = SerializeHelper.StringToSerializableObject <uid>(tq.UidState);

                                if (uId == null)
                                {
                                    Logger.ErrorFormat("uid is null, there is something wrong!!! tq.id = {0}", new Exception(), tq.ORMID);
                                }


                                string sErrors = string.Empty;

                                switch (eType)
                                {
                                case eTransactionQueueType.None:

                                    Logger.Error("Unknown Type. Skipping...", new Exception());
                                    break;

                                case eTransactionQueueType.Ticket:

                                    var ticket = SerializeHelper.StringToDataContractObject <TicketWS>(tq.Object1);
                                    var td     = SerializeHelper.StringToSerializableObject <TicketData>(tq.Tag1);
                                    uId.session_id = "";

                                    try
                                    {
                                        int iResult = SaveTicketOnHub(tq.TransactionId, uId, ticket, td.StationNumber, td.IsOffLineTicket, ref sErrors);

                                        if (iResult == Ticket.TICKET_SAVE_SUCCESSFUL)
                                        {
                                            PrinterHandler.CreateXmlAndSaveFile(ticket, false);
                                            Logger.InfoFormat("{0} successfully saved", ticket);
                                            lObjectsToDelete.Add(tq);
                                        }
                                        else if (iResult == Ticket.TICKET_ALREADY_SAVED)
                                        {
                                            PrinterHandler.CreateXmlAndSaveFile(ticket, false);
                                            Logger.InfoFormat("{0} already saved", ticket);
                                            lObjectsToDelete.Add(tq);
                                        }
                                        else if (iResult != 0)
                                        {
                                            Logger.InfoFormat("{0} have invalid data", ticket);
                                            lObjectsToDelete.Add(tq);
                                        }
                                        else
                                        {
                                            Logger.ErrorFormat("{0} was not saved:\r\n{1}\r\nResult {2}. Continue trying to save next time...", new Exception(), ticket, sErrors, iResult);
                                        }
                                    }
                                    catch (FaultException <HubServiceException> ex)
                                    {
                                        Logger.InfoFormat("{0} have invalid data", ticket);
                                        Logger.Error(ex.Message, ex);
                                        lObjectsToDelete.Add(tq);
                                    }


                                    break;

                                case eTransactionQueueType.Deposit:

                                    decimal          amount    = decimal.Parse(tq.Object1);
                                    bool             realMoney = bool.Parse(tq.Object3);
                                    CashAcceptorType?type      = null;
                                    CashAcceptorType typeTmp;
                                    Enum.TryParse(tq.Object2, out typeTmp);
                                    if (!String.IsNullOrEmpty(tq.Object2))
                                    {
                                        type = typeTmp;
                                    }
                                    uId.session_id = "";

                                    Exception error = null;
                                    try
                                    {
                                        accountBalance bResult = SaveDepositOnHub(tq.TransactionId, uId, amount, realMoney, ref error, type);

                                        if (bResult != null)
                                        {
                                            Logger.InfoFormat("Deposit {0} for {1} successfully saved", amount, uId);
                                            lObjectsToDelete.Add(tq);
                                        }
                                        else
                                        {
                                            if (error == null)
                                            {
                                                Logger.ErrorFormat("Deposit {0} for {1} was not saved. Errors:\r\n{2}\r\nContinue trying to save next time...", new Exception(), amount, uId, "empty responce");
                                                break;
                                            }
                                            Logger.ErrorFormat("Deposit {0} for {1} was not saved. Errors:\r\n{2}\r\nContinue trying to save next time...", new Exception(), amount, uId, error.Message);
                                        }
                                    }
                                    catch (FaultException <HubServiceException> ex)
                                    {
                                        Logger.ErrorFormat("Deposit {0} for {1} was not saved. Errors:\r\n{2}\r\nContinue trying to save next time...", new Exception(), amount, uId, error.Message);
                                        lObjectsToDelete.Add(tq);
                                    }

                                    break;

                                case eTransactionQueueType.DepositByTicket:

                                    string ticketNumber = tq.Object1;
                                    string creditNumber = tq.Object2;
                                    uId.session_id = "";
                                    try
                                    {
                                        var tnumber  = "";
                                        var tcode    = "";
                                        var crnumber = "";
                                        var crcode   = "";
                                        if (ticketNumber.Length > 4)
                                        {
                                            tnumber = ticketNumber.Substring(0, ticketNumber.Length - 4);
                                        }
                                        if (ticketNumber.Length > 4)
                                        {
                                            tcode = ticketNumber.Substring(ticketNumber.Length - 4);
                                        }
                                        if (creditNumber.Length > 4)
                                        {
                                            crnumber = creditNumber.Substring(0, creditNumber.Length - 4);
                                        }
                                        if (creditNumber.Length > 4)
                                        {
                                            crcode = creditNumber.Substring(creditNumber.Length - 4);
                                        }

                                        bool bResultDeposit = DepositByTicketOnHub(tq.TransactionId, uId, tnumber, tcode, crnumber, crcode, ref sErrors);

                                        if (bResultDeposit)
                                        {
                                            Logger.InfoFormat("DepositByTicket {0} for {1} successfully saved", ticketNumber, uId);
                                            lObjectsToDelete.Add(tq);
                                        }
                                        else
                                        {
                                            Logger.ErrorFormat("DepositByTicket {0} for {1} was not saved. TicketNumber {2}  Errors:\r\n{2}\r\nContinue trying to save next time...", new Exception(), ticketNumber, uId, sErrors);
                                        }
                                    }
                                    catch (FaultException <HubServiceException> ex)
                                    {
                                        Logger.ErrorFormat("DepositByTicket {0} for {1} was not saved. TicketNumber {2}  Errors:\r\n{2}\r\nContinue trying to save next time...", ex, ticketNumber, uId, sErrors);
                                        lObjectsToDelete.Add(tq);
                                    }
                                    break;

                                case eTransactionQueueType.DepositByCreditNote:

                                    string checksum   = tq.Object1;
                                    string noteNumber = tq.Object2;
                                    uId.session_id = "";

                                    try
                                    {
                                        bool bResultCredit = DepositByCreditNoteOnHub(tq.TransactionId, uId, noteNumber, checksum, ref sErrors);

                                        if (bResultCredit)
                                        {
                                            Logger.InfoFormat("DepositByCreditNote {0} for {1} successfully saved", checksum, uId);
                                            lObjectsToDelete.Add(tq);
                                        }
                                        else
                                        {
                                            Logger.ErrorFormat("DepositByCreditNote {0} for {1} was not saved. NoteNumber {2}  Errors:\r\n{2}\r\nContinue trying to save next time...", new Exception(), checksum, uId, sErrors, noteNumber);
                                        }
                                    }
                                    catch (FaultException <HubServiceException> ex)
                                    {
                                        Logger.ErrorFormat("DepositByCreditNote {0} for {1} was not saved. NoteNumber {2}  Errors:\r\n{2}\r\nContinue trying to save next time...", new Exception(), checksum, uId, sErrors, noteNumber);
                                        lObjectsToDelete.Add(tq);
                                    }
                                    break;

                                case eTransactionQueueType.Cash:
                                    bool moneyIn = bool.Parse(tq.Object3);
                                    uid  userUID = SerializeHelper.StringToSerializableObject <uid>(tq.UidState);

                                    try
                                    {
                                        DateTime startdate;
                                        DateTime enddate;
                                        var      bResultCash = RegisterMoney(userUID, moneyIn, ref sErrors, out startdate, out enddate);
                                        Logger.InfoFormat("RegisterMoney {0} successfully saved", moneyIn, uId);
                                        lObjectsToDelete.Add(tq);
                                    }
                                    catch (FaultException <HubServiceException> ex)
                                    {
                                        Logger.InfoFormat("{0}{1} have invalid data", moneyIn, uId);
                                        Logger.Error(ex.Message, ex);
                                        lObjectsToDelete.Add(tq);
                                    }
                                    break;

                                default:

                                    Debug.Assert(false);
                                    break;
                                }
                            }
                            catch (Exception excp)
                            {
                                Logger.InfoFormat("Cannot save on HUB {0}", TraceTransactionQueue(tq));
                            }
                        }

                        DeleteTransactionObjects(lObjectsToDelete);
                    }
                }
                catch (Exception excp)
                {
                    Logger.Error("General Error", excp);
                }
            }
        }