public TreeListObjects Select(int maximumRows, int startRowIndex)
        {
            // int page = startRowIndex / maximumRows;

            TreeListObjects data = new TreeListObjects(false); // do not bind exchange row if not exist
            RepairListHeader header = new RepairListHeader();
            RepairSpare rSpare;
            ExchangeSpare exSpare;

            Exchangepartheader exchH;
            ArrayList listED;
            ArrayList listSD;
            ArrayList listSH = GetServiceHeaders(branchCode);

            ItemCount = (listSH == null) ? 0 : listSH.Count;
            PageSize = maximumRows;
            FirstItemIndex = startRowIndex;

            int lastItem = FirstItemIndex + PageSize;
            if (lastItem > ItemCount) lastItem = ItemCount;

            if ((listSH == null) || (listSH.Count == 0)) return null;
            for (int i = 0; i < ItemCount; i++)
            {
                Serviceheader serH = (Serviceheader)listSH[i];
                // header section
                header = new RepairListHeader();
                header.No = i + 1;
                header.CustomerName = serH.Customer.Fullname;
                header.EngineNumber = serH.Enginenumber;
                header.RepairDate = serH.Servicedate;

                // repair section
                header.ServiceRecordSheet.BindOrder = 1;
                header.ServiceRecordSheet.ServiceSheetNumber = serH.Servicesheetnumber;
                header.ServiceRecordSheet.RepairFeeAmount = serH.Feeamount;
                listSD = GetServiceDetails(serH.Id);
                foreach (Servicedetail serD in listSD)
                {
                    rSpare = new RepairSpare(serD.Partcode, serD.Partqty, serD.Unitprice);
                    header.ServiceRecordSheet.Items.Add(rSpare);
                }

                // exchange section
                header.ExchangeSpares.BindOrder = 2;
                exchH = GetExchangeHeader(serH.Id);
                if (exchH != null)
                {
                    header.ExchangeSpares.ExchangeVoucherNumber = exchH.Vouchernumber;
                    listED = GetExchangeDetails(exchH.Id);
                    foreach (Exchangepartdetail exchD in listED)
                    {
                        exSpare = new ExchangeSpare(exchD.Partcodem, exchD.Partqtym, exchD.Unitpricem, exchD.Totalfeem);
                        header.ExchangeSpares.Items.Add(exSpare);
                    }
                }

                CalculateSummary(header);
                // add to top list
                if ((i >= FirstItemIndex) && (i < lastItem)) data.Items.Add(header);
            }

            return data;
        }
        // chua phan trang
        public TreeListObjects Select(int maximumRows, int startRowIndex)
        {
            // int page = startRowIndex / maximumRows;

            TreeListObjects data = new TreeListObjects();
            RepairListHeader header;
            SpareInfo spare;

            Exchangepartheader exchH;
            ArrayList listED;
            IList listSD;
            ArrayList listSH = GetServiceHeaders(startRowIndex, maximumRows);

            for (int i = 0; i < listSH.Count; i++)
            {
                Serviceheader serH = (Serviceheader)listSH[i];
                // header section
                header = new RepairListHeader();
                header.No = startRowIndex + i + 1;
                header.Repair = serH.Repairresult;
                header.Damaged = serH.Damaged;
                header.RepairDate = serH.Servicedate;
                header.Dealer = serH.Dealercode;
                header.DealerName = DealerHelper.GetName(serH.Dealercode);
                header.RepairFee = serH.Feeamount;
                header.ServiceHeaderId = serH.Id;

                // repair section
                listSD = GetServiceDetails(serH.Id);
                foreach (Servicedetail serD in listSD)
                {
                    spare = new SpareInfo(serD.Partcode, serH.Servicesheetnumber);
                    spare.IsWarranty = false;
                    header.Spares.Items.Add(spare);
                }

                // exchange section
                exchH = GetExchangeHeader(serH.Id);
                if (exchH != null)
                {
                    listED = GetExchangeDetails(exchH.Id);
                    foreach (Exchangepartdetail exchD in listED)
                    {
                        spare = new SpareInfo(exchD.Partcodem, exchH.Vouchernumber);
                        spare.IsWarranty = true; ;
                        header.Spares.Items.Add(spare);
                    }
                }

                // add to top list
                data.Items.Add(header);
            }
            return data;
        }
        public TreeListObjects Select(int maximumRows, int startRowIndex)
        {
            TreeListObjects data = new TreeListObjects();
            int items;
            //IList<Exchangepartheader> listEH = GetExchangeHeaders();
            IList<Exchangepartheader> listEH = GetExchangeHeaders(maximumRows, startRowIndex, out items);

            // dealer info when verify Proposal exchanges
            if (ForVerify)
            {
                if (!string.IsNullOrEmpty(VoucherNo))
                {
                    Exchangevoucherheader exchH = GetExchVoucherHeader(VoucherNo);
                    if (exchH != null)
                    {
                        DealerCode = exchH.Dealercode;
                        DealerName = DealerHelper.GetName(DealerCode);
                    }
                }
                else if ((this.ExchageNoFrom == this.ExchageNoTo) && (listEH.Count > 0))
                {
                    DealerCode = listEH[0].Dealercode;
                    DealerName = DealerHelper.GetName(DealerCode);
                }
            }

            //ItemCount = (listEH == null) ? 0 : listEH.Count;  // paging roi thi thoi
            ItemCount = items;

            PageSize = maximumRows;
            FirstItemIndex = startRowIndex;
            int lastItem = FirstItemIndex + PageSize;
            if (lastItem > ItemCount) lastItem = ItemCount;

            if ((listEH == null) || (listEH.Count == 0)) return null;
            for (int i = 0; i < listEH.Count; i++)
            {
                Exchangepartheader exch = listEH[i];

                #region header section
                ExchangeListHeader header = new ExchangeListHeader();
                header.No = i + 1;
                header.CustomerName = exch.Customer.Fullname;
                header.EngineNumber = exch.Enginenumber;
                header.RepairDate = exch.Exchangeddate;
                header.BuyDate = exch.Purchasedate;
                header.ConfirmedDate = (exch.Status == (int)ExchangeVoucherStatus.Approved) ? exch.Lastprocesseddate : DateTime.MinValue;
                header.ServiceSheetNumber = exch.Serviceheader.Servicesheetnumber;
                header.ExchangeVoucherNumber = exch.Vouchernumber;
                header.Status = exch.Status;
                header.StatusString = ServiceTools.GetNativeVMEPExchangeStatusName(exch.Status);
                header.Km = exch.Kmcount;
                header.Model = exch.Serviceheader.Itemtype;
                header.ProposeFee = (long)exch.Proposefeeamount;
                header.feeO = (long)exch.Proposefeeamount;
                header.feeM = exch.Feeamount;

                #endregion

                #region exchange section
                ArrayList listED = GetExchangeDetails(exch.Id);
                foreach (Exchangepartdetail exchD in listED)
                {
                    Warrantycondition warr;
                    ExchangeSpare exSpare = new ExchangeSpare();

                    warr = WarrantyContent.GetWarrantyCondition(exchD.Partcodeo);
                    if (warr != null) exSpare.LabourO = (long)warr.Labour;
                    warr = WarrantyContent.GetWarrantyCondition(exchD.Partcodem);
                    if (warr != null) exSpare.LabourM = (long)warr.Labour;

                    exSpare.SpareNumberO = exchD.Partcodeo;
                    exSpare.SpareNumberM = exchD.Partcodem;
                    exSpare.UnitPriceO = exchD.Unitpriceo;
                    exSpare.UnitPriceM = exchD.Unitpricem;
                    exSpare.QuantityO = exchD.Partqtyo;
                    exSpare.QuantityM = exchD.Partqtym;
                    exSpare.Comments = exchD.Vmepcomment;
                    exSpare.WarrantyFeeAmountO = exchD.Totalfeeo;
                    exSpare.WarrantyFeeAmountM = exchD.Totalfeem;

                    exSpare.ManPowerM = (exSpare.LabourM == 0) ? 0 : (double)((double)exSpare.WarrantyFeeAmountM / (double)exSpare.LabourM);
                    exSpare.ManPowerO = (exSpare.LabourO == 0) ? 0 : (double)((double)exSpare.WarrantyFeeAmountO / (double)exSpare.LabourO);

                    header.ExchangeSpares.Items.Add(exSpare);
                }
                #endregion

                CalculateSummary(header);

                // add to top list
                //if ((i >= FirstItemIndex) && (i < lastItem))   // paging roi thi thoi
                {
                    data.Items.Add(header);
                }
            }

            if (CalculateAllPageSummary) CalculateTotalSummary();
            return data;
        }