示例#1
0
        public DataTable GetBeginningBalance(CostElement CostElement)
        {
            var query = HCMIS.Repository.Queries.MovingAverageHistory.SelectGetBeginningBalance(CostElement.ItemID, CostElement.ItemUnitID, CostElement.ManufacturerID, CostElement.MovingAverageID);

            this.LoadFromRawSql(query);
            return(this.DataTable);
        }
示例#2
0
        public bool CalculateFinalCost()
        {
            CostElements     = new List <CostElement>();
            _GrandTotalCost  = 0;
            _PriceDifference = 0;
            foreach (DataRowView drv in GRVSoundDetail.DefaultView)
            {
                CostElement costElement = new CostElement(ReceiptID, Convert.ToInt32(drv["ItemID"]), Convert.ToInt32(drv["ItemUnitID"]), Convert.ToInt32(drv["MovingAverageID"]), Convert.ToInt32(drv["ManufacturerID"]));

                costElement.LoadAverageCostCalculator();
                costElement.Qty      = Convert.ToDouble(drv["ReceivedQty"]);
                costElement.UnitCost = Convert.ToDouble(drv["UnitCost"]);
                if (drv["Margin"] != DBNull.Value)
                {
                    costElement.Margin = Convert.ToDouble(drv["Margin"]);
                }
                costElement.PreviousStock = GetPreviousStockDataRowView(costElement.ItemID, costElement.ManufacturerID
                                                                        , costElement.ItemUnitID, costElement.MovingAverageID);

                if (PreviousRowCount > 1)
                {
                    return(false);
                }
                costElement.CalculateAverageCost();

                drv["AverageCost"]  = costElement.AverageCost;
                drv["SellingPrice"] = costElement.SellingPrice;
                _PriceDifference    = _PriceDifference + costElement.AverageCostCalculator.PriceDifference;
                _GrandTotalCost     = _GrandTotalCost + Convert.ToDouble(drv["TotalCost"]);

                CostElements.Add(costElement);
            }
            return(true);
        }
        public DataView getPriceChangeReport(CostElement costElement)
        {
            TheDataSet dataSet = new TheDataSet();
            DataRow dr = dataSet.PriceOveride.NewRow();

            dataSet.PriceOveride.Rows.Add(costElement.priceChangeReport(dr));
            return dataSet.PriceOveride.DefaultView;
        }
 public PreviousCostPricingDetails(CostElement CostElement)
 {
     ReceiptID = CostElement.ReceiptID;
     ItemID = CostElement.ItemID;
     ItemUnitID = CostElement.ItemUnitID;
     ManufacturerID = CostElement.ManufacturerID;
     AccountID = CostElement.MovingAverageID;
     LoadAndBind();
 }
 public PreviousCostPricingDetails(CostElement CostElement)
 {
     ReceiptID      = CostElement.ReceiptID;
     ItemID         = CostElement.ItemID;
     ItemUnitID     = CostElement.ItemUnitID;
     ManufacturerID = CostElement.ManufacturerID;
     AccountID      = CostElement.MovingAverageID;
     LoadAndBind();
 }
        private void btnConfirm_Click(object sender, EventArgs e)
        {
            MyGeneration.dOOdads.TransactionMgr transaction = MyGeneration.dOOdads.TransactionMgr.ThreadTransactionMgr();

            var dt = grdDetailView.DataSource as DataView;
            if ((dt) != null)
            {

                // This is where we set the Price

                foreach (DataRow dr in dt.Table.Rows)
                {
                    var costElement = new CostElement();
                    costElement.LoadFromDataRow(dr, receipt.ID);
                    costElement.AverageCost = Convert.ToDouble(dr["AverageCost"]);
                    costElement.Margin = Convert.ToDouble(dr["Margin"]);

                    costElement.SellingPrice = Convert.ToDouble(dr["SellingPrice"]);
                    try
                    {
                        transaction.BeginTransaction();
                        var journalService = new JournalService();
                        journalService.StartRecordingSession();
                        costElement.ConfirmPrice(CurrentContext.UserId, "", journalService, ChangeMode.PriceOverride);
                        var receiveDoc = new ReceiveDoc();
                        receiveDoc.SavePrice(costElement, CurrentContext.UserId);
                        journalService.CommitRecordingSession();
                        transaction.CommitTransaction();

                    }
                    catch (Exception exception)
                    {
                        transaction.RollbackTransaction();
                        XtraMessageBox.Show("Error : " + exception.Message, "Error...", MessageBoxButtons.OK,
                                            MessageBoxIcon.Error);
                        throw exception;
                    }
                    var report = new PriceOverridePrintout
                                     {
                                         xrCostedBy = {Text = CurrentContext.LoggedInUserName},
                                         lblDate = {Text = DateTimeHelper.ServerDateTime.ToString()},
                                         DataSource = getPriceChangeReport(costElement)
                                     };
                    report.ShowPreviewDialog();

                }
                var recDoc = new ReceiveDoc();
                recDoc.LoadByReceiptID(receipt.ID);
                recDoc.ConfirmGRVPrinted(CurrentContext.UserId);
                receipt.ChangeStatus(ReceiptConfirmationStatus.Constants.GRV_PRINTED, null,
                                     this.GetFormIdentifier(), CurrentContext.UserId, "Price Set");

            }
        }
 public MovingAverage(int itemID,int itemUnitID,int manufacturerID,int MovingAverageID,double Qty,double UnitCost,double margin,string receivedocs)
 {
     InitializeComponent();
     costElement = new CostElement();
     costElement.ItemID = itemID;
     costElement.ItemUnitID = itemUnitID;
     costElement.ManufacturerID = manufacturerID;
     costElement.MovingAverageID = MovingAverageID;
     costElement.UnitCost = UnitCost;
     costElement.Margin = margin;
     costElement.Qty = Qty;
     receiveDocs = receivedocs;
 }
示例#8
0
        public void RecordAverageCostAndSellingPrice(int userID)
        {
            MyGeneration.dOOdads.TransactionMgr transaction = MyGeneration.dOOdads.TransactionMgr.ThreadTransactionMgr();

            try
            {
                transaction.BeginTransaction();
                DataTable           ReceiveDocDetails;
                IList <CostElement> costElements = new List <CostElement>();

                foreach (DataRowView drv in GRVSoundDetail.DefaultView as DataView)
                {
                    double NewUnitCost, NewSellingPrice;
                    if (drv["AverageCost"] != DBNull.Value && drv["SellingPrice"] != DBNull.Value)
                    {
                        CostElement costElement = new CostElement();
                        costElement.ItemID          = Convert.ToInt32(drv["ItemID"]);
                        costElement.ItemUnitID      = Convert.ToInt32(drv["ItemUnitID"]);
                        costElement.MovingAverageID = Convert.ToInt32(drv["MovingAverageID"]);
                        costElement.ManufacturerID  = Convert.ToInt32(drv["ManufacturerID"]);
                        costElement.AverageCost     = costElement.SellingPrice = Math.Round(Convert.ToDouble(drv["SellingPrice"]), Settings.NoOfDigitsAfterTheDecimalPoint);
                        costElement.Margin          = drv["Margin"] != DBNull.Value ? Convert.ToDouble(drv["Margin"]) : 0;
                        ReceiveDocDetails           =
                            ReceiveDoc.GetRelatedReceiveForUnitCostAndSellingPrice(ReceiptID, costElement);


                        foreach (DataRowView Cursor in ReceiveDocDetails.AsDataView())
                        {
                            int ID = Convert.ToInt32(Cursor["ID"]);
                            ReceiveDoc.SetAverageCostByReceiveDoc(ID, costElement.AverageCost, userID);
                            ReceiveDoc.SetSellingPriceByReceiveDoc(ID, costElement.SellingPrice, userID);
                        }
                        costElements.Add(costElement);
                    }
                }
                try
                {
                    CostingService.SavePriceChange(costElements.AsEnumerable(), userID, ChangeMode.Recieve, ReceiptID.ToString());
                }
                catch (Exception)
                {
                    //Until Cost Tier Implementation
                }
                transaction.CommitTransaction();
            }
            catch (Exception ex)
            {
                transaction.RollbackTransaction();
                throw ex;
            }
        }
 //This is a fix It
 //It will fix the Cost if it is set on the ReceiveDoc but if not set on the picklistdetail
 //But if the receiveDoc is not set or GRV is not printed it will return false
 private static bool ValidateAndFixDeliveryNoteHasBeenProperlyPrice(DataView dv)
 {
     foreach (DataRowView drv in dv)
     {
             int issueDocId, pickListDetailId;
             CostElement costElement = new CostElement();
             try
             {
                 issueDocId = Convert.ToInt32(drv["IssueDocID"]);
                 pickListDetailId = Convert.ToInt32(drv["PickListDetailID"]);
                 PickListDetail pickListDetail = costElement.FixDeliveryNoteCostReceiveDoc(issueDocId, pickListDetailId);
                 drv["Cost"] = pickListDetail.Cost;
                 drv["UnitPrice"] = pickListDetail.UnitPrice;
             }
             catch (Exception ex)
             {
                 XtraMessageBox.Show(string.Format("You cannot print this STV:{0}", ex.Message), "Warning",
                                     MessageBoxButtons.OK, MessageBoxIcon.Error);
                 throw ex;
             }
     }
     return true;
 }
        private void btnApprove_Click(object sender, EventArgs e)
        {
            //dxCostingValidation.RemoveControlError(lkPeriod);
            if (!dxCostingValidation.Validate()) return;
             if (lkWarehouse.EditValue != null && lkAccount.EditValue != null && XtraMessageBox.Show(String.Format("Are you sure you want to Approve All Items, Once Approved the item will be available for release"), "Are you sure...", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
             {
             try
             {

             ReceiveDocConfirmation receiveDocConfirmation = new ReceiveDocConfirmation();
             string receiveDocs = "";
             string rdPendingAverages = "";
             var ledgerService = new LedgerService();
             DataView dataView = (gridMain.DataSource as DataView);
             dataView.RowFilter = "PricePerPack <>0 and isConfirmed = 1";
             foreach (DataRowView drv in dataView)
             {
                 var costElement = new CostElement
                                       {
                                           ItemID = Convert.ToInt32(drv["ItemID"]),
                                           ItemUnitID = Convert.ToInt32(drv["UnitID"]),
                                           ManufacturerID = Convert.ToInt32(drv["ManufacturerID"]),
                                           MovingAverageID = Convert.ToInt32(drv["MovingAverageID"])
                                       };

                 var ledgerObject = ledgerService.GetLedger(costElement.ItemID, costElement.ItemUnitID,
                                                            costElement.ManufacturerID, costElement.MovingAverageID);

                 costElement.UnitCost = Math.Round(Convert.ToDouble(ledgerObject.UnitCost),
                                                   BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                   MidpointRounding.AwayFromZero);
                 costElement.AverageCost = Math.Round(Convert.ToDouble(drv["PricePerPack"]),
                                                      BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                      MidpointRounding.AwayFromZero);
                 costElement.Margin = Convert.ToDouble(drv["Margin"])/100;
                 costElement.SellingPrice = costElement.AverageCost*(1 + costElement.Margin);
                 var isSound = drv["Remark"].Equals("Sound");
                 if ((Math.Abs(costElement.UnitCost - costElement.AverageCost) == 0) || !isSound)
                 {

                     receiveDocs = receiveDocs != ""
                                       ? receiveDocs + ',' + drv["ReceiveDocIDs"].ToString()
                                       : receiveDocs + drv["ReceiveDocIDs"].ToString();
                 }
                 else if (ReceiveDoc.GetSoundStock(costElement) > 0)
                 {
                     rdPendingAverages = rdPendingAverages != ""
                                             ? rdPendingAverages + ',' + drv["ReceiveDocIDs"].ToString()
                                             : rdPendingAverages + drv["ReceiveDocIDs"].ToString();

                 }
                 else
                 {

                     IJournalService journal = new JournalService();
                     journal.StartRecordingSession();
                     costElement.SavePrice(CurrentContext.UserId, "", journal, ChangeMode.BeginningBalance);
                     journal.CommitRecordingSession();

                     journal.StartRecordingSession();
                     costElement.ConfirmPrice(CurrentContext.UserId, "", journal, ChangeMode.BeginningBalance);
                     journal.CommitRecordingSession();

                     receiveDocs = receiveDocs != ""
                                       ? receiveDocs + ',' + drv["ReceiveDocIDs"].ToString()
                                       : receiveDocs + drv["ReceiveDocIDs"].ToString();
                 }

             }

             receiveDocConfirmation.ChangeStatusByAccountReceiveDocs(receiveDocs,
                                                                     ReceiptConfirmationStatus.Constants.GRV_PRINTED,
                                                                     ReceiptConfirmationStatus.Constants.GRNF_PRINTED);
             receiveDocConfirmation.ChangeStatusByAccountReceiveDocs(rdPendingAverages,
                                                                     ReceiptConfirmationStatus.Constants.
                                                                         PRICE_CALCULATED,
                                                                     ReceiptConfirmationStatus.Constants.GRNF_PRINTED);
             XtraMessageBox.Show("Price has been successfully confirmed", "Success...", MessageBoxButtons.OK,
                                 MessageBoxIcon.Information);
             }
             catch (Exception exception)
             {
                 XtraMessageBox.Show(exception.Message, "Success...", MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
                 throw;
             }
                      lkWarehouse_EditValueChanged(null, null);
             }
        }
        private void gridMasterView_DoubleClick(object sender, EventArgs e)
        {
            if (gridMasterView.GetFocusedRow() != null)
            {
                DataRow drv = gridMasterView.GetFocusedDataRow();
                if (Convert.ToBoolean(drv["pendingAverage"]))
                {
                    CostElement costElement = new CostElement (Convert.ToInt32(drv["ItemID"]),Convert.ToInt32(drv["MovingAverageID"]),Convert.ToInt32(drv["ManufacturerID"]),Convert.ToInt32(drv["UnitID"]));
                    costElement.Qty = Convert.ToDouble(drv["NoOfPack"]);
                    costElement.UnitCost = Math.Round(Convert.ToDouble(drv["PricePerPack"]),
                                                      BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                      MidpointRounding.AwayFromZero);

                    costElement.Margin = Convert.ToDouble(drv["Margin"])/100;
                    MovingAverage movingAverage = new MovingAverage(costElement, drv["ReceiveDocIDs"].ToString());
                    movingAverage.ShowDialog(this);
                    lkWarehouse_EditValueChanged(null, null);
                }
            }
        }
 public WeightedAverageHistory(CostElement costElement)
 {
     this.costElement = costElement;
     InitializeComponent();
 }
 public WeightedAverageHistory(int ItemID, int AccountID, int ManufacturerID, int ItemUnitID)
 {
     costElement = new CostElement(ItemID, AccountID, ManufacturerID, ItemUnitID);
     InitializeComponent();
 }
        public void RecordAverageCostAndSellingPrice(int userID)
        {
            MyGeneration.dOOdads.TransactionMgr transaction = MyGeneration.dOOdads.TransactionMgr.ThreadTransactionMgr();

               try
               {
               transaction.BeginTransaction();
               DataTable ReceiveDocDetails;
               IList<CostElement> costElements = new List<CostElement>();

               foreach (DataRowView drv in GRVSoundDetail.DefaultView as DataView)
               {
                   CostElement costElement = new CostElement();
                   costElement.ItemID = Convert.ToInt32(drv["ItemID"]);
                   costElement.ItemUnitID = Convert.ToInt32(drv["ItemUnitID"]);
                   costElement.MovingAverageID = Convert.ToInt32(drv["MovingAverageID"]);
                   costElement.ManufacturerID = Convert.ToInt32(drv["ManufacturerID"]);
                   costElement.AverageCost = Math.Round(Convert.ToDouble(drv["AverageCost"]), Settings.NoOfDigitsAfterTheDecimalPoint);
                   costElement.SellingPrice = Math.Round(Convert.ToDouble(drv["SellingPrice"]), Settings.NoOfDigitsAfterTheDecimalPoint);
                   costElement.Margin = drv["Margin"] != DBNull.Value ? Convert.ToDouble(drv["Margin"]) : 0;

                   ReceiveDocDetails =
                            ReceiveDoc.GetRelatedReceiveForUnitCostAndSellingPrice(ReceiptID,costElement);

                   foreach (DataRowView Cursor in ReceiveDocDetails.AsDataView())
                   {
                       int ID = Convert.ToInt32(Cursor["ID"]);
                       ReceiveDoc.SetAverageCostByReceiveDoc(ID, costElement.AverageCost, userID);
                       ReceiveDoc.SetSellingPriceByReceiveDoc(ID, costElement.SellingPrice, userID);
                   }
                   costElements.Add(costElement);
               }
               try
               {
                   CostingService.SavePriceChange(costElements.AsEnumerable(), userID, ChangeMode.Recieve, ReceiptID.ToString());

               }
               catch (Exception)
               {
                   //Until Cost Tier Implementation
               }
                transaction.CommitTransaction();
               }
               catch (Exception ex)
               {
               transaction.RollbackTransaction();
               throw ex;
               }
        }
        private void btnSave_Click(object sender, EventArgs e)
        {
            MyGeneration.dOOdads.TransactionMgr transaction = MyGeneration.dOOdads.TransactionMgr.ThreadTransactionMgr();

            if (gridPriceList.DataSource != null && (gridPriceList.DataSource as DataTable).GetChanges() != null)
            {
                DataTable dtChangedPricelist = (gridPriceList.DataSource as DataTable).GetChanges();
                if (dtChangedPricelist != null)
                {
                    foreach (DataRowView drw in dtChangedPricelist.DefaultView)
                    {
                        var dialogResult =
                            XtraMessageBox.Show(
                                String.Format("Are you Sure you want to Change Price for {0}", drw["ItemName"]),
                                "Are you sure", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                        if (dialogResult == DialogResult.Cancel)
                        {
                            return;
                        }

                        if (dialogResult == DialogResult.Yes)
                        {
                            try
                            {
                                transaction.BeginTransaction();
                                // This is where we set the Price
                                JournalService journalService = new JournalService();
                                journalService.StartRecordingSession();
                                CostElement costElement = new CostElement(Convert.ToInt32(drw["ItemID"])
                                                                          , Convert.ToInt32(drw["MovingAverageGroupID"])
                                                                          , Convert.ToInt32(drw["ManufacturerID"])
                                                                          , Convert.ToInt32(drw["UnitID"]));

                                costElement.AverageCost = Math.Round(Convert.ToDouble(drw["UnitCost"]),
                                                                     BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                                     MidpointRounding.AwayFromZero);
                                costElement.Margin = Math.Round(Convert.ToDouble(drw["Margin"]),
                                                                BLL.Settings.NoOfDigitsAfterTheDecimalPoint+2,
                                                                MidpointRounding.AwayFromZero);
                                if(BLL.Settings.IsCenter)
                                {
                                    costElement.SellingPrice = costElement.AverageCost;
                                }
                                else
                                {
                                    costElement.SellingPrice = Math.Round(Convert.ToDouble(drw["SellingPrice"]),
                                                                      BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                                      MidpointRounding.AwayFromZero);
                                }

                                costElement.SavePrice(CurrentContext.UserId, "", journalService, ChangeMode.PriceOverride);

                                PriceOverridePrintout report = new PriceOverridePrintout();
                                report.xrCostedBy.Text = CurrentContext.LoggedInUserName;
                                report.lblDate.Text = DateTimeHelper.ServerDateTime.ToString();
                                report.DataSource = getPriceChangeReport(costElement);

                                journalService.CommitRecordingSession();
                                transaction.CommitTransaction();

                                report.ShowPreviewDialog();
                            }
                            catch (Exception exception)
                            {
                                transaction.RollbackTransaction();
                                XtraMessageBox.Show("Error : " + exception.Message, "Error...", MessageBoxButtons.OK,
                                                    MessageBoxIcon.Error);
                                throw exception;
                            }
                        }

                    }
                    BindDataSet();
                    XtraMessageBox.Show("Change was Successfull", "Success...", MessageBoxButtons.OK,
                                        MessageBoxIcon.Information);
                    return;
                }
            }

            XtraMessageBox.Show("No Changes have been made", "No Changes...", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
        public void SavePrice(CostElement costElement, int userID)
        {
            ReceivedSummary receivedSummary = new ReceivedSummary();
            receivedSummary.ItemID = costElement.ItemID;
            receivedSummary.UnitID = costElement.ItemUnitID;
            receivedSummary.ManufacturerID = costElement.ManufacturerID;
            receivedSummary.StoreID = costElement.MovingAverageID;
            receivedSummary.NewUnitCost = costElement.AverageCost;
            receivedSummary.Margin = costElement.Margin;
            receivedSummary.NewSellingPrice = costElement.SellingPrice;
            receivedSummary.NewPrice = costElement.AverageCost;
            receivedSummary.Remark = "Price override";
            FlushData();
            if (BLL.Settings.SkipBeginningBalancePricing)
            {
                SetPricePerPackCostAndSellingPrice(receivedSummary);
                SendToFinanceManagerConfirmation(receivedSummary, userID);
            }
            else

                SetCostAndSellingPriceAndSendToConfirmation(receivedSummary, userID);

            if (!BLL.Settings.IsCenter)
            {
                PricePicklistforHub(receivedSummary);

            }
            else
            {
                PricePicklistforCenter(receivedSummary);
            }
            receivedSummary.SaveWeightedAverageLog(userID);
        }
示例#17
0
 public void LoadbyParameter(int?ReceiptID, int ItemID, int ManufacturerID, int ItemUnitID, int AccountID, int ActivityID)
 {
     CostElements = new CostElement((int)ReceiptID, ItemID, ItemUnitID, AccountID, ManufacturerID);
 }
 public static DataTable GetRelatedReceiveForUnitCostAndSellingPrice(int ReceiptID,CostElement costElement)
 {
     var query = HCMIS.Repository.Queries.ReceiveDoc.SelectGetRelatedReceiveForUnitCostAndSellingPriceRd(ReceiptID, costElement.ItemID, costElement.ItemUnitID, costElement.ManufacturerID, costElement.MovingAverageID, costElement.AverageCost, costElement.SellingPrice);
     ReceiveDoc receivedoc = new ReceiveDoc();
     receivedoc.LoadFromRawSql(query);
     return receivedoc.DataTable;
 }
 public AverageCostCalculator(CostElement CostElements)
 {
     this.CostElements = CostElements;
 }
 public void LoadbyParameter(int? ReceiptID,int ItemID,int ManufacturerID,int ItemUnitID,int AccountID,int ActivityID)
 {
     CostElements = new CostElement((int)ReceiptID, ItemID, ItemUnitID, AccountID, ManufacturerID);
 }
 /// <summary>
 /// Gets the history.
 /// </summary>
 /// <param name="itemID">The item ID.</param>
 /// <param name="activityID">The activity ID.</param>
 /// <param name="unitID">The unit ID.</param>
 /// <returns></returns>
 public DataTable GetHistory(CostElement CostElement)
 {
     var query = HCMIS.Repository.Queries.MovingAverageHistory.SelectGetHistory(CostElement.ItemID, CostElement.ItemUnitID, CostElement.ManufacturerID, CostElement.MovingAverageID);
     this.LoadFromRawSql(query);
     return this.DataTable;
 }
 public MovingAverage(CostElement costElement,string receivedocs)
 {
     InitializeComponent();
     this.costElement = costElement;
     receiveDocs = receivedocs;
 }
示例#23
0
 public AverageCostCalculator(CostElement CostElements)
 {
     this.CostElements = CostElements;
 }
 public static decimal GetSoundStock(CostElement costElement)
 {
     ReceiveDoc receipt = new ReceiveDoc();
     var query = HCMIS.Repository.Queries.ReceiveDoc.SelectGetSoundStock(costElement.ItemID, costElement.ItemUnitID, costElement.ManufacturerID, costElement.MovingAverageID, ReceiptConfirmationStatus.Constants.GRV_PRINTED);
     receipt.LoadFromRawSql(query);
     return Convert.ToDecimal(receipt.GetColumn("Quantity"));
 }
        public bool CalculateFinalCost()
        {
            CostElements = new List<CostElement>();
               _GrandTotalCost = 0;
               _PriceDifference = 0;
               foreach (DataRowView drv in GRVSoundDetail.DefaultView)
               {
               CostElement costElement = new CostElement(ReceiptID, Convert.ToInt32(drv["ItemID"]), Convert.ToInt32(drv["ItemUnitID"]), Convert.ToInt32(drv["MovingAverageID"]), Convert.ToInt32(drv["ManufacturerID"]));

               costElement.LoadAverageCostCalculator();
               costElement.Qty = Convert.ToDouble(drv["ReceivedQty"]);
               costElement.UnitCost = Convert.ToDouble(drv["UnitCost"]);
               if (drv["Margin"] != DBNull.Value) costElement.Margin = Convert.ToDouble(drv["Margin"]);
               costElement.PreviousStock = GetPreviousStockDataRowView(costElement.ItemID, costElement.ManufacturerID
                                                                    , costElement.ItemUnitID, costElement.MovingAverageID);

               if (PreviousRowCount > 1)
                   return false;
               costElement.CalculateAverageCost();

               drv["AverageCost"] = costElement.AverageCost;
               drv["SellingPrice"] = costElement.SellingPrice;
               _PriceDifference = _PriceDifference + costElement.AverageCostCalculator.PriceDifference;
               _GrandTotalCost = _GrandTotalCost + Convert.ToDouble(drv["TotalCost"]);

               CostElements.Add(costElement);
               }
               return true;
        }
        /// <summary>
        /// Load All Neccessary Data and Bind To DataSource
        /// </summary>
        void LoadAndBind()
        {
            //Bind

            //Load Detail Table To Grid
            Item item = new Item();
            gridReceiveDoc.DataSource = item.GetReceiveDocDetailForDiagnostics(ItemId, ManufacturerId, UnitId,
                                                                               MovingAverageId);

            gridJournalEntries.DataSource = item.GetJournalEntriesForDiagnostics(AffectedLedgerID);

            MovingAverageHistory history = new MovingAverageHistory();
            CostElement costElement = new CostElement(ItemId, MovingAverageId, ManufacturerId, UnitId, ManufacturerId);
            gridAllSimilarItems.DataSource = history.GetHistory(costElement);

            //Load Header Information From first row to be displayed

                txtItemName.EditValue = Item;
                txtItemUnit.EditValue = Unit;
                txtManufacturerName.EditValue = Manufacturer;
                txtActivityName.EditValue = MovingAverage;
                txtUnitCost.EditValue = UnitCost;
                txtMargin.EditValue = Margin;
                txtSellingPrice.EditValue = SellingPrice;
        }
        private void BindDetails(DataRow dr)
        {
            // txtAdditionalCost.EditValue = 0;
            //txtMargin.EditValue = 100;

            try
            {
                Convert.ToInt16(dr["ItemID"]);
            }
            catch
            {
                ResetForm();
                return;
            }

            if (dr != null)
            {
                rs = new ReceivedSummary();
                ReceiveDoc rd = new ReceiveDoc();
                rs.ItemID = Convert.ToInt32(dr["ItemID"]);
                rs.SupplierID = Convert.ToInt32(dr["SupplierID"]);
                rs.ManufacturerID = Convert.ToInt32(dr["ManufacturerID"]);

                if (dr["UnitID"] != DBNull.Value)
                    rs.UnitID = Convert.ToInt32(dr["UnitID"]);
                else
                    rs.UnitID = null;

                rs.StoreID = Convert.ToInt32(lkAccount.EditValue);

                // TODO: fix this ( Remove ) try cache
                try
                {
                    txtUnit.Text = dr["Unit"].ToString();
                }
                catch
                {

                }

                txtItemName.Text = dr["FullItemName"].ToString();
                txtManufacturer.Text = dr["Manufacturer"].ToString();

                rd.LoadForPricing(rs.ItemID, rs.SupplierID,rs.StoreID, rs.ManufacturerID, rs.UnitID);
                gridAllSimilarItems.DataSource = rd.DefaultView;

                LoadDecimalFormatings();

                rs.MovingAverageTable(rs.ItemID, rs.StoreID,rs.SupplierID, rs.ManufacturerID, rs.UnitID);
                txtAverageCost.EditValue = rs.NewUnitCost;
                txtMargin.EditValue = rs.Margin;
                txtSellingPrice.EditValue = rs.NewSellingPrice;
                txtAdditional.EditValue = 0;
                costElement = new CostElement(rs.ItemID, rs.StoreID, rs.ManufacturerID, (int)rs.UnitID);
            }
        }
        private void btnSave_Click(object sender, EventArgs e)
        {
            MyGeneration.dOOdads.TransactionMgr transaction = MyGeneration.dOOdads.TransactionMgr.ThreadTransactionMgr();

            DataView dtChangedPricelist = gridViewPriceList.DataSource as DataView;
            if (dtChangedPricelist != null)
            {

                dtChangedPricelist.RowFilter = "IsConfirmed = 1";

                foreach (DataRowView drw in dtChangedPricelist)
                {
                    var dialogResult =
                        XtraMessageBox.Show(
                            String.Format("Are you Sure you want to Change Price for {0}", drw["ItemName"]),
                            "Are you sure", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                    if (dialogResult == DialogResult.Cancel)
                    {
                        return;
                    }

                    if (dialogResult == DialogResult.Yes)
                    {
                        try
                        {
                            transaction.BeginTransaction();
                            // This is where we set the Price
                            JournalService journalService = new JournalService();
                            journalService.StartRecordingSession();
                            CostElement costElement = new CostElement(Convert.ToInt32(drw["ItemID"])
                                                                      , Convert.ToInt32(drw["MovingAverageGroupID"])
                                                                      , Convert.ToInt32(drw["ManufacturerID"])
                                                                      , Convert.ToInt32(drw["UnitID"]));

                            costElement.AverageCost = Math.Round(Convert.ToDouble(drw["UnitCost"]),
                                                                 BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                                 MidpointRounding.AwayFromZero);
                            costElement.Margin = Math.Round(Convert.ToDouble(drw["Margin"]),
                                                            BLL.Settings.NoOfDigitsAfterTheDecimalPoint+2,
                                                            MidpointRounding.AwayFromZero);
                            costElement.SellingPrice = Math.Round(Convert.ToDouble(drw["SellingPrice"]),
                                                                  BLL.Settings.NoOfDigitsAfterTheDecimalPoint,
                                                                  MidpointRounding.AwayFromZero);

                            costElement.ConfirmPrice(CurrentContext.UserId,"", journalService,ChangeMode.PriceOverride);
                            ReceiveDoc receiveDoc = new ReceiveDoc();
                            receiveDoc.SavePrice(costElement, CurrentContext.UserId);
                            journalService.CommitRecordingSession();
                            transaction.CommitTransaction();
                        }
                        catch (Exception exception)
                        {
                            transaction.RollbackTransaction();
                            XtraMessageBox.Show("Error : " + exception.Message, "Error...", MessageBoxButtons.OK,
                                                MessageBoxIcon.Error);
                            throw exception;
                        }
                    }

                }
                BindDataSet();
                XtraMessageBox.Show("Change was Successfull", "Success...", MessageBoxButtons.OK,
                                    MessageBoxIcon.Information);
                return;
            }

            XtraMessageBox.Show("No Changes have been made", "No Changes...", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }