Exemple #1
0
        //ChangeTable - Change Order From Table to Table
        void _buttonKeyChangeTable_Clicked(object sender, EventArgs e)
        {
            PosTablesDialog dialog   = new PosTablesDialog(this.SourceWindow, DialogFlags.DestroyWithParent, TableFilterMode.OnlyFreeTables);
            ResponseType    response = (ResponseType)dialog.Run();

            if (response == ResponseType.Ok || response == ResponseType.Cancel || response == ResponseType.DeleteEvent)
            {
                if (response == ResponseType.Ok)
                {
                    OrderMain currentOrderMain            = GlobalFramework.SessionApp.OrdersMain[GlobalFramework.SessionApp.CurrentOrderMainOid];
                    POS_ConfigurationPlaceTable xOldTable = (POS_ConfigurationPlaceTable)FrameworkUtils.GetXPGuidObject(typeof(POS_ConfigurationPlaceTable), currentOrderMain.Table.Oid);
                    POS_ConfigurationPlaceTable xNewTable = (POS_ConfigurationPlaceTable)FrameworkUtils.GetXPGuidObject(typeof(POS_ConfigurationPlaceTable), dialog.CurrentTableOid);
                    //Require to Prevent A first chance exception of type 'DevExpress.Xpo.DB.Exceptions.LockingException' occurred in DevExpress.Xpo.v13.2.dll when it is Changed in Diferent Session ex UnitOfWork
                    //TODO: Confirm working with Reload Commented
                    //xOldTable.Reload();
                    //xNewTable.Reload();

                    if (xNewTable.TableStatus != TableStatus.Free)
                    {
                        Utils.ShowMessageTouch(
                            GlobalApp.WindowPos, DialogFlags.Modal, MessageType.Warning, ButtonsType.Ok, Resx.global_error,
                            Resx.dialog_message_table_is_not_free
                            );
                    }
                    else
                    {
                        //Put Old table Status to Free
                        xOldTable.TableStatus = TableStatus.Free;
                        xOldTable.Save();
                        FrameworkUtils.Audit("TABLE_OPEN", string.Format(Resx.audit_message_table_open, xOldTable.Designation));

                        //Put New table Status to Open
                        xNewTable.TableStatus = TableStatus.Open;
                        xNewTable.Save();
                        FrameworkUtils.Audit("TABLE_CLOSE", string.Format(Resx.audit_message_table_close, xNewTable.Designation));

                        //Change DocumentOrderMain table, If OpenOrder Exists in That table
                        Guid documentOrderMainOid = currentOrderMain.GetOpenTableFieldValueGuid(xOldTable.Oid, "Oid");
                        FIN_DocumentOrderMain xDocumentOrderMain = (FIN_DocumentOrderMain)FrameworkUtils.GetXPGuidObject(typeof(FIN_DocumentOrderMain), documentOrderMainOid);
                        if (xDocumentOrderMain != null)
                        {
                            xDocumentOrderMain.PlaceTable = xNewTable;
                            xDocumentOrderMain.UpdatedAt  = FrameworkUtils.CurrentDateTimeAtomic();
                            xDocumentOrderMain.Save();
                        }
                        //Assign Session Data
                        currentOrderMain.Table.Oid       = xNewTable.Oid;
                        currentOrderMain.Table.Name      = xNewTable.Designation;
                        currentOrderMain.Table.PriceType = (PriceType)xNewTable.Place.PriceType.EnumValue;
                        currentOrderMain.OrderTickets[currentOrderMain.CurrentTicketId].PriceType = (PriceType)xNewTable.Place.PriceType.EnumValue;
                        currentOrderMain.Table.PlaceId = xNewTable.Place.Oid;
                        GlobalFramework.SessionApp.Write();
                        //Finally Update Status Bar, Table Name, Totals Etc
                        UpdateOrderStatusBar();
                    }
                }
                dialog.Destroy();
            }
            ;
        }
Exemple #2
0
        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
        //OrderMain/Document Conferences

        //Works in Dual Mode based on pGenerateNewIfDiferentFromArticleBag, sometimes passes 2 times, on for get last document and other to create new one
        //Mode1 : GenerateNewIfDiferentFromArticleBag = false : Returns Last Conference Document for Current Working Order Main
        //Mode2 : GenerateNewIfDiferentFromArticleBag = true : Returns Last or New Conference Document if Current Working Order Main is Diferent from working currente Working OrderMain ArticleBag
        //Returns Last|New DocumentConference, for table current OrderMain
        //GenerateNewIfDiferentFromArticleBag : Used to generate a new Document if latest Document has been changed (Compare it to current ArticleBag),
        //else if false use the latest on Database ignoring Diferences, Used to Get latest DocumentConference to use in Generate DocumentConference PosOrdersDialog.buttonTableConsult_Clicked
        public static FIN_DocumentFinanceMaster GetOrderMainLastDocumentConference(bool pGenerateNewIfDiferentFromArticleBag = false)
        {
            //Declare local Variables
            FIN_DocumentFinanceMaster lastDocument = null;
            FIN_DocumentFinanceMaster newDocument  = null;
            FIN_DocumentFinanceMaster result       = null;
            FIN_DocumentOrderMain     orderMain    = null;
            Guid      currentOrderMainOid          = GlobalFramework.SessionApp.CurrentOrderMainOid;
            OrderMain currentOrderMain             = GlobalFramework.SessionApp.OrdersMain[currentOrderMainOid];

            try
            {
                string sql = string.Format(@"
                    SELECT 
	                    Oid
                    FROM 
	                    FIN_documentfinancemaster 
                    WHERE 
	                    DocumentType = '{0}' AND 
	                    SourceOrderMain = '{1}'
                    ORDER BY 
	                    CreatedAt DESC;
                    "
                                           , SettingsApp.XpoOidDocumentFinanceTypeConferenceDocument
                                           , currentOrderMain.PersistentOid
                                           );

                var sqlResult = GlobalFramework.SessionXpo.ExecuteScalar(sql);

                //Get LastDocument Object
                if (sqlResult != null)
                {
                    lastDocument = (FIN_DocumentFinanceMaster)GlobalFramework.SessionXpo.GetObjectByKey(typeof(FIN_DocumentFinanceMaster), new Guid(Convert.ToString(sqlResult)));
                }

                //If GenerateNewIfDiferentFromArticleBag Enabled compare ArticleBag with Document and If is diferent Generate a New One
                if (pGenerateNewIfDiferentFromArticleBag)
                {
                    //Initialize ArticleBag to Compare with Order Detail and use in ProcessFinanceDocuments
                    ArticleBag articleBag = ArticleBag.TicketOrderToArticleBag(currentOrderMain);
                    //Check if Total is Not Equal and Generate New DocumentConference, This way it will be Equal to Invoice
                    if (
                        lastDocument == null ||
                        (!lastDocument.TotalFinal.Equals(articleBag.TotalFinal) || !lastDocument.DocumentDetail.Count.Equals(articleBag.Count))
                        )
                    {
                        //Prepare ProcessFinanceDocumentParameter
                        ProcessFinanceDocumentParameter processFinanceDocumentParameter = new ProcessFinanceDocumentParameter(SettingsApp.XpoOidDocumentFinanceTypeConferenceDocument, articleBag)
                        {
                            Customer = SettingsApp.XpoOidDocumentFinanceMasterFinalConsumerEntity
                        };

                        orderMain = (FIN_DocumentOrderMain)GlobalFramework.SessionXpo.GetObjectByKey(typeof(FIN_DocumentOrderMain), currentOrderMain.PersistentOid);
                        processFinanceDocumentParameter.SourceOrderMain = orderMain;
                        if (lastDocument != null)
                        {
                            processFinanceDocumentParameter.DocumentParent  = lastDocument.Oid;
                            processFinanceDocumentParameter.OrderReferences = new List <FIN_DocumentFinanceMaster>();
                            processFinanceDocumentParameter.OrderReferences.Add(lastDocument);
                        }

                        //Generate New Document
                        newDocument = ProcessFinanceDocument.PersistFinanceDocument(processFinanceDocumentParameter, false);

                        //Assign DocumentStatus and OrderReferences
                        if (newDocument != null)
                        {
                            //Assign Result Document to New Document
                            //Get Object outside UOW else we have a problem with "A first chance exception of type 'System.ObjectDisposedException'"
                            result = (FIN_DocumentFinanceMaster)GlobalFramework.SessionXpo.GetObjectByKey(typeof(FIN_DocumentFinanceMaster), newDocument.Oid);

                            ////Old Code that changes last Conference Document to Status "A", it is not Required, Confirmed with Carlos Bento, we must Leave it without status changes
                            //if (lastDocument != null)
                            //{
                            //    lastDocument.DocumentStatusStatus = "A";
                            //    lastDocument.DocumentStatusDate = newDocument.DocumentStatusDate;
                            //    lastDocument.DocumentStatusUser = newDocument.DocumentStatusUser;
                            //    lastDocument.SystemEntryDate = newDocument.SystemEntryDate;
                            //    lastDocument.Save();
                            //}
                        }
                    }
                }
                else
                {
                    result = lastDocument;
                }
            }
            catch (Exception ex)
            {
                // Send Exception to logicpos, must treat exception in ui, to Show Alert to User
                throw ex;
            }

            return(result);
        }
Exemple #3
0
        //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
        //Used to Remove Articles from DocumentOrder ex when we Delete Article From TicketList.OrderMain Details

        public decimal DeleteFromDocumentOrder(ArticleBagKey pKey, decimal pRemoveQuantity)
        {
            bool    isDone = false;
            decimal resultRemainQuantity = 0;

            string where = string.Empty;
            //Store Reference to Future delete Object (After foreach Loop)
            FIN_DocumentOrderMain   deleteOrderMain   = null;
            FIN_DocumentOrderTicket deleteOrderTicket = null;
            FIN_DocumentOrderDetail deleteOrderDetail = null;
            string articleDesignation = string.Empty;

            //Start UnitOfWork
            using (UnitOfWork uowSession = new UnitOfWork())
            {
                OrderMain             orderMain          = GlobalFramework.SessionApp.OrdersMain[GlobalFramework.SessionApp.CurrentOrderMainOid];
                FIN_DocumentOrderMain xDocumentOrderMain = (FIN_DocumentOrderMain)FrameworkUtils.GetXPGuidObject(uowSession, typeof(FIN_DocumentOrderMain), orderMain.PersistentOid);

                if (xDocumentOrderMain != null && xDocumentOrderMain.OrderTicket != null)
                {
                    foreach (FIN_DocumentOrderTicket ticket in xDocumentOrderMain.OrderTicket)
                    {
                        foreach (FIN_DocumentOrderDetail detail in ticket.OrderDetail)
                        {
                            try
                            {
                                //Check Equal Key
                                if (pKey.ArticleOid == detail.Article.Oid && pKey.Price == detail.Price && pKey.Discount == detail.Discount && pKey.Vat == detail.Vat)
                                {
                                    articleDesignation    = pKey.Designation;
                                    resultRemainQuantity += detail.Quantity;
                                    if (!isDone)
                                    {
                                        detail.Quantity -= pRemoveQuantity;
                                        //Assign references to Future Deletes
                                        if (detail.Quantity <= 0)
                                        {
                                            deleteOrderDetail = detail;
                                        }
                                        isDone = true;
                                    }
                                    else
                                    {
                                        where += string.Format(" OR Oid = '{0}'", detail.Oid);
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.Error(ex.Message, ex);
                            }
                        }
                    }
                }

                //Debug
                //string sql = @"SELECT * FROM fin_documentorderdetail WHERE 1=0{0};";
                //_log.Debug(string.Format("Delete(): sql [{0}]", string.Format(sql, where)));

                //Audit
                FrameworkUtils.Audit("ORDER_ARTICLE_REMOVED", string.Format(
                                         Resx.audit_message_order_article_removed,
                                         articleDesignation,
                                         1,
                                         resultRemainQuantity - 1,
                                         GlobalFramework.LoggedUser.Name
                                         )
                                     );

                if (isDone)
                {
                    //Update xDocumentOrderMain UpdatedAt, Required for RealTime Update
                    xDocumentOrderMain.UpdatedAt = FrameworkUtils.CurrentDateTimeAtomic();

                    //Remove Quantity
                    resultRemainQuantity -= pRemoveQuantity;

                    //Delete Records, OrderMain, OrderTicket and OrderDetails
                    if (deleteOrderDetail != null)
                    {
                        deleteOrderTicket = deleteOrderDetail.OrderTicket;
                        deleteOrderMain   = deleteOrderTicket.OrderMain;

                        //Delete Details
                        deleteOrderDetail.Delete();

                        //Check if OrderTicket in Empty, If so Delete it, its not required anymore
                        if (deleteOrderTicket.OrderDetail.Count <= 0)
                        {
                            deleteOrderTicket.Delete();
                        }
                        ;

                        //Check if OrderMain in Empty, If so Delete it, its not required anymore
                        if (deleteOrderMain.OrderTicket.Count <= 0)
                        {
                            //Before Delete OrderMain, we must UnAssign DocumentMaster SourceOrderMain else we have a CONSTRAINT ERROR on FK_DocumentFinanceMaster_SourceOrderMain trying to delete used OrderMain
                            string sql = string.Format(@"UPDATE fin_documentfinancemaster SET SourceOrderMain = NULL WHERE SourceOrderMain = '{0}';", deleteOrderMain.Oid);
                            uowSession.ExecuteScalar(sql);
                            //Open Table
                            deleteOrderMain.PlaceTable.TableStatus = TableStatus.Free;
                            //Audit
                            FrameworkUtils.Audit("TABLE_OPEN", string.Format(Resx.audit_message_table_open, deleteOrderMain.PlaceTable.Designation));
                            //Delete OrderMain
                            deleteOrderMain.Delete();
                        }
                        ;
                    }
                    ;
                }
                ;

                try
                {
                    //Commit UOW Changes
                    uowSession.CommitChanges();
                    //Update OrderMain UpdatedAt, Required to Sync Terminals
                    orderMain.UpdatedAt = FrameworkUtils.CurrentDateTimeAtomic();

                    //Update ArticleBag Price Properties
                    this[pKey].Quantity = resultRemainQuantity;
                    UpdateKeyProperties(pKey);

                    //SEARCH#001
                    //Require to Remove PartialPayed Items Quantity
                    return(resultRemainQuantity - FrameworkUtils.GetPartialPaymentPayedItems(uowSession, xDocumentOrderMain.Oid, pKey.ArticleOid));
                }
                catch (Exception ex)
                {
                    _log.Error(ex.Message, ex);
                    uowSession.RollbackTransaction();
                    return(-1);
                }
            }
        }
Exemple #4
0
        public FIN_DocumentOrderTicket FinishOrder(Session pSession, bool pPrintTicket)
        {
            //Local Vars
            DateTime currentDateTime = DateTime.Now;
            FIN_DocumentOrderMain xOrderMain;
            Session _sessionXpo = pSession;
            bool    isInUOW     = (_sessionXpo.GetType() == typeof(UnitOfWork));
            //Result
            FIN_DocumentOrderTicket xOrderTicket = null;

            //Get current Working Order from SessionApp
            OrderMain   currentOrderMain   = GlobalFramework.SessionApp.OrdersMain[GlobalFramework.SessionApp.CurrentOrderMainOid];
            OrderTicket currentOrderTicket = currentOrderMain.OrderTickets[currentOrderMain.CurrentTicketId];

            //Get Place Object to extract TaxSellType Normal|TakeWay
            POS_ConfigurationPlace configurationPlace = (POS_ConfigurationPlace)GlobalFramework.SessionXpo.GetObjectByKey(typeof(POS_ConfigurationPlace), currentOrderMain.Table.PlaceId);
            //Use VatDirectSelling if in Retail or in TakeWay mode
            TaxSellType taxSellType = (configurationPlace.MovementType.VatDirectSelling || SettingsApp.AppMode == AppOperationMode.Retail) ? TaxSellType.TakeAway : TaxSellType.Normal;

            //Open Table on First Finish OrderTicket
            POS_ConfigurationPlaceTable xTable = (POS_ConfigurationPlaceTable)FrameworkUtils.GetXPGuidObject(_sessionXpo, typeof(POS_ConfigurationPlaceTable), _table.Oid);

            xTable.Reload();
            if (xTable.TableStatus != TableStatus.Open)
            {
                xTable.TableStatus = TableStatus.Open;
                FrameworkUtils.Audit("TABLE_OPEN", string.Format(Resx.audit_message_table_open, xTable.Designation));
                xTable.DateTableOpen = FrameworkUtils.CurrentDateTimeAtomic();
                if (!isInUOW)
                {
                    xTable.Save();
                }
            }

            //Get Current _persistentOid and _from Database
            _persistentOid = GetOpenTableFieldValueGuid(_table.Oid, "Oid");
            _orderStatus   = (OrderStatus)GetOpenTableFieldValue(_table.Oid, "OrderStatus");
            _UpdatedAt     = FrameworkUtils.CurrentDateTimeAtomic();

            //Insert
            if (_persistentOid == Guid.Empty)
            {
                //OrderMain
                xOrderMain = new FIN_DocumentOrderMain(_sessionXpo)
                {
                    //Always assign New date to Persistent Date
                    DateStart   = currentDateTime,//currentOrderMain.DateStart,
                    OrderStatus = OrderStatus.Open,
                    PlaceTable  = xTable,
                    UpdatedAt   = FrameworkUtils.CurrentDateTimeAtomic()
                };
                if (!isInUOW)
                {
                    xOrderMain.Save();
                }
                //After Save, Get Oid
                _persistentOid = xOrderMain.Oid;
                //Change to Open Status
                _orderStatus = OrderStatus.Open;
            }
            //Update
            else
            {
                xOrderMain = (FIN_DocumentOrderMain)FrameworkUtils.GetXPGuidObject(_sessionXpo, typeof(FIN_DocumentOrderMain), _persistentOid);
                if (xOrderMain.PlaceTable != xTable)
                {
                    xOrderMain.PlaceTable = xTable;
                }
                //Force Changes in Record, else UpdatedAt dont Update
                xOrderMain.UpdatedAt = FrameworkUtils.CurrentDateTimeAtomic();
                //TODO: Check if User was Automatically Updated
                //if (xOrderMain.UpdatedBy != GlobalFramework.LoggedUser) xOrderMain.UpdatedBy = GlobalFramework.LoggedUser;
                if (!isInUOW)
                {
                    xOrderMain.Save();
                }
            }

            //Create OrderTicket
            xOrderTicket = new FIN_DocumentOrderTicket(_sessionXpo)
            {
                TicketId   = currentOrderMain.CurrentTicketId,
                DateStart  = currentOrderTicket.DateStart,
                PriceType  = currentOrderTicket.PriceType,
                Discount   = xTable.Discount,
                OrderMain  = xOrderMain,
                PlaceTable = xTable
            };
            if (!isInUOW)
            {
                xOrderTicket.Save();
            }

            //Create OrderDetail
            FIN_DocumentOrderDetail xOrderDetailLine;
            FIN_Article             xArticle;
            uint    itemOrd  = 0;
            decimal priceTax = 0;

            foreach (OrderDetailLine line in currentOrderTicket.OrderDetails.Lines)
            {
                //Use Order in print tickets etc
                itemOrd++;
                xArticle = (FIN_Article)FrameworkUtils.GetXPGuidObject(_sessionXpo, typeof(FIN_Article), line.ArticleOid);
                //Get PriceTax from TaxSellType
                priceTax = (taxSellType == TaxSellType.Normal) ? xArticle.VatOnTable.Value : xArticle.VatDirectSelling.Value;

                xOrderDetailLine = new FIN_DocumentOrderDetail(_sessionXpo)
                {
                    //Values
                    Ord           = itemOrd,
                    Code          = xArticle.Code,
                    Designation   = line.Designation,
                    Quantity      = line.Properties.Quantity,
                    UnitMeasure   = xArticle.UnitMeasure.Acronym,
                    Price         = line.Properties.PriceNet,
                    Discount      = (xArticle.Discount > 0) ? xArticle.Discount : 0.0m,
                    TotalGross    = line.Properties.TotalGross,
                    TotalDiscount = line.Properties.TotalDiscount,
                    TotalTax      = line.Properties.TotalTax,
                    TotalFinal    = line.Properties.TotalFinal,
                    //Use PriceTax Normal|TakeAway
                    Vat = priceTax,
                    //XPGuidObjects
                    Article     = xArticle,
                    OrderTicket = xOrderTicket
                };

                //Detect VatExemptionReason
                if (line.Properties.VatExemptionReason != Guid.Empty)
                {
                    xOrderDetailLine.VatExemptionReason = line.Properties.VatExemptionReason;
                }

                if (!isInUOW)
                {
                    xOrderDetailLine.Save();
                }
            }
            ;

            //Clean Details and Open a New Blank Ticket in Session
            //Increment Terminal SessionApp CurrentTicketId
            _currentTicketId += 1;
            currentOrderMain.OrderTickets = new Dictionary <int, OrderTicket>();
            currentOrderMain.OrderTickets.Add(currentOrderMain.CurrentTicketId, new OrderTicket(this, _table.PriceType));

            //Finish Writing Session
            GlobalFramework.SessionApp.Write();

            return(xOrderTicket);

            //Debug
            //_log.Debug(string.Format("FinishOrder(): xOrderMain.Oid [{0}]", xOrderMain.Oid));
            //_log.Debug(string.Format("FinishOrder(): _table.OrderMainId [{0}], _currentTicketId [{1}], _table.Name [{2}]", _table.OrderMainId, _currentTicketId, _table.Name));
        }