/// <summary>
        /// The object factory for a particular data collection instance.
        /// </summary>
        public virtual void CreateObjectsFromData(TransactionDetails transactiondetails, System.Data.DataSet data)
        {
            // Do nothing if we have nothing
            if (data == null || data.Tables.Count == 0 || data.Tables[0].Rows.Count == 0)
            {
                return;
            }


            // Create a local variable for the new instance.
            TransactionDetail newobj = null;

            // Create a local variable for the data row instance.
            System.Data.DataRow dr = null;


            // Iterate through the table rows
            for (int i = 0; i < data.Tables[0].Rows.Count; i++)
            {
                // Get a reference to the data row
                dr = data.Tables[0].Rows[i];
                // Create a new object instance
                newobj = System.Activator.CreateInstance(transactiondetails.ContainsType[0]) as TransactionDetail;
                // Let the instance set its own members
                newobj.SetMembers(ref dr);
                // Add the new object to the collection instance
                transactiondetails.Add(newobj);
            }
        }
        /// <summary>
        /// Generate aggregate data (total faults, average of percentiles...)
        /// </summary>
        /// <param name="parameters"></param>
        public void GenerateAggregates(ParamInterpreter parameters)
        {
            int cnt = 0;

            Log.WriteLine("generate aggregated data...");
            // scrape and aggregate data from transaction data
            TransactionValueAggregate transactionAggregate = new TransactionValueAggregate();

            // foreach transactionlines (evaluate only successful transactions, leave faulty ones away from aggregation)
            foreach (string transactionName in _transactionNames)
            {
                // only include in agggregation if transactionname matches 'report transacton name pattern'
                if (IsSummarizeTransaction(transactionName) && _transactionDetails.items.ContainsKey(transactionName))
                {
                    TransactionValue trs = new TransactionValue(_transactionDetails.items[transactionName]);
                    transactionAggregate.AddTransaction(trs);
                    cnt++;
                }
            }

            // give up if no summarizable transactions found (try to prevent weird crashes lateron)
            if (0 == cnt)
            {
                string msg = "no transaction names found that meet naming convention (" + REPORTTRANSACTIONNAMEPATTERN + ")";
                Log.WriteLine("SEVERE: " + msg);
                throw new Exception(msg);
            }

            transactionAggregate.Aggregate();

            // write aggregated transaction line
            _transactionDetails.Add(AGGREGATEDTRSNAME, transactionAggregate.ToString());

            // isolate most important values as variable for history graph -> measure format (later to variable category?)
            _variables.Add(AVGOF90PERCENTILES, Utils.ToMeasureFormatString(transactionAggregate.p90));
            _variables.Add(AVGOFMEDIAN, Utils.ToMeasureFormatString(transactionAggregate.median));
            _variables.Add(AVGOF95PERCENTILES, Utils.ToMeasureFormatString(transactionAggregate.p95));
            _variables.Add(AVGOFAVERAGES, Utils.ToMeasureFormatString(transactionAggregate.avg));
            _variables.Add(TRANSACTIONSFAILED, transactionAggregate.fail);

            // old, can be deleted in time (replaced by transactionssuccess)
            // _variables.Add(TRANSACTIONSTOTAL, transactionAggregate.cnt);
            _variables.Add(TRANSACTIONSTOTAL, AddIntStrings(transactionAggregate.cnt, transactionAggregate.fail));
            _variables.Add(TRANSACTIONSSUCCESS, transactionAggregate.cnt); // is new

            Log.WriteLine(string.Format("{0} of {1} transactions aggregated", cnt, _transactionNames.Length));
        }
        /// <summary>
        /// Min, max, avg, cnt transactiondata
        /// </summary>
        /// <param name="lines"></param>
        /// <param name="trsNames"></param>
        private TransactionDetails ReadTransactionDetailsFromCSV(string[] lines, string[] trsNames)
        {
            string             trsName;
            TransactionDetails td = new TransactionDetails();

            foreach (string line in lines)
            {
                trsName = Utils.NormalizeTransactionName(line.Split(',')[0]);

                if (trsNames.Contains(trsName))
                {
                    TransactionValue value = ExtractTrsDetailsCSV(line);
                    td.Add(trsName, value.ToString());
                }
            }
            return(td);
        }
Beispiel #4
0
        public void Add(ModelBase obj)
        {
            if (obj is Account)
            {
                Accounts.Add(obj as Account);
            }
            else if (obj is Transaction)
            {
                Transactions.Add(obj as Transaction);

                foreach (var detail in ((Transaction)obj).Details)
                {
                    Add(detail);
                }
            }
            else if (obj is TransactionDetail)
            {
                TransactionDetails.Add(obj as TransactionDetail);
            }
            else if (obj is Receipt)
            {
                Receipts.Add(obj as Receipt);
            }
            else if (obj is ScheduledTransaction)
            {
                ScheduledTransactions.Add(obj as ScheduledTransaction);

                foreach (var detail in ((ScheduledTransaction)obj).Details)
                {
                    Add(detail);
                }
            }
            else if (obj is ScheduledTransactionDetail)
            {
                ScheduledTransactionDetails.Add(obj as ScheduledTransactionDetail);
            }
            else if (obj is Category)
            {
                Categories.Add(obj as Category);
            }
            else if (obj is Product)
            {
                Products.Add(obj as Product);
            }
        }
        /// <summary>
        /// The object factory for a particular data collection instance.
        /// </summary>
        public virtual void CreateObjectsFromData(TransactionDetails transactiondetails, System.Data.SqlClient.SqlDataReader data)
        {
            // Do nothing if we have nothing
            if (data == null)
            {
                return;
            }


            // Create a local variable for the new instance.
            TransactionDetail newobj = null;

            // Iterate through the data reader
            while (data.Read())
            {
                // Create a new object instance
                newobj = System.Activator.CreateInstance(transactiondetails.ContainsType[0]) as TransactionDetail;
                // Let the instance set its own members
                newobj.SetMembers(ref data);
                // Add the new object to the collection instance
                transactiondetails.Add(newobj);
            }
        }
        public DyeingOrderInvoiceViewModel() : base(PermissionItemName.DyeingOrderInvoice)
        {
            GetItemPermissions(PermissionItemName.DyeingOrderInvoice.ToString());
            //PermissionItemName.dyeing
            DyeingServiceClient.PostDyeingOrderInvoiceCompleted += (s, sv) =>
            {
                if (sv.Result != null)
                {
                    SelectedMainRow.InjectFrom(sv.Result);
                }
                SelectedMainRow.VisPosted = false;
                MessageBox.Show("Posted Completed");
            };
            DyeingServiceClient.DeleteDyeingOrderInvoiceHeaderCompleted += (s, ev) =>
            {
                if (ev.Error != null)
                {
                    MessageBox.Show(ev.Error.Message);
                }
                var oldrow = MainRowList.FirstOrDefault(x => x.Iserial == ev.Result);
                if (oldrow != null)
                {
                    MainRowList.Remove(oldrow);
                }
            };

            MiscValueTypeList = new ObservableCollection <GenericTable>
            {
                new GenericTable {
                    Iserial = 0, Code = "%", Ename = "%", Aname = "%"
                },
                new GenericTable {
                    Iserial = 1, Code = "Value", Ename = "Value", Aname = "Value"
                }
            };

            var currencyClient = new GlService.GlServiceClient();

            currencyClient.GetGenericCompleted += (s, sv) =>
            {
                CurrencyList = new ObservableCollection <CRUDManagerService.GenericTable>();
                foreach (var item in sv.Result)
                {
                    CurrencyList.Add(new CRUDManagerService.GenericTable().InjectFrom(item) as CRUDManagerService.GenericTable);
                }
            };
            currencyClient.GetGenericAsync("TblCurrency", "%%", "%%", "%%", "Iserial", "ASC", LoggedUserInfo.DatabasEname);

            var journalAccountTypeClient = new GlService.GlServiceClient();

            journalAccountTypeClient.GetGenericCompleted += (s, sv) =>
            {
                JournalAccountTypeList = sv.Result;
            };
            journalAccountTypeClient.GetGenericAsync("TblJournalAccountType", "%%", "%%", "%%", "Iserial", "ASC", LoggedUserInfo.DatabasEname);


            PurchasePlanClient.GetTblMarkupProdAsync(0, int.MaxValue, "it.Iserial", null, null, LoggedUserInfo.DatabasEname);

            PurchasePlanClient.GetTblMarkupProdCompleted += (s, sv) =>
            {
                MarkupList = new ObservableCollection <TblMarkupProd>();
                foreach (var item in sv.Result)
                {
                    MarkupList.Add(new TblMarkupProd().InjectFrom(item) as TblMarkupProd);
                }

                // MarkupList = sv.Result;
            };



            SelectedMainRow = new TblDyeingOrderInvoiceHeaderViewModel {
                DocDate = DateTime.Now
            };

            DyeingServiceClient.UpdateOrInsertDyeingOrderInvoiceHeaderCompleted += (s, sv) =>
            {
                if (sv.Error != null)
                {
                    MessageBox.Show(sv.Error.Message);
                }
                try
                {
                    SelectedMainRow.InjectFrom(sv.Result);

                    if (SelectedMainRow.Status == 0)
                    {
                        SelectedMainRow.VisPosted = true;
                    }
                    else
                    {
                        SelectedMainRow.VisPosted = false;
                    }
                }

                catch (Exception)
                {
                }
                Loading = false;
                if (OpenMisc)
                {
                    new MarkupTransProdChildWindow(this).Show();
                    OpenMisc = false;
                }
            };

            PurchasePlanClient.UpdateOrInsertDyeingOrderInvoiceMarkupTransProdsCompleted += (s, x) =>
            {
                var markup = new TblMarkupProd();
                try
                {
                    var row = SelectedMainRow.MarkUpTransList.ElementAt(x.outindex);
                    if (row != null)
                    {
                        markup = row.TblMarkupProd1;
                    }
                    if (x.Result.Iserial == -1)
                    {
                        MessageBox.Show("This Markup Is Not Linked To Account");
                        row.TblMarkupProd1 = null;
                    }
                    else
                    {
                        SelectedMainRow.MarkUpTransList.ElementAt(x.outindex).InjectFrom(x.Result);
                        if (row != null)
                        {
                            row.TblMarkupProd1 = markup;
                        }
                    }
                }
                catch (Exception)
                {
                }

                Loading = false;
            };
            DyeingServiceClient.GetDyeingOrderInvoiceHeaderCompleted += (s, sv) =>
            {
                Loading = false;
                MainRowList.Clear();
                foreach (var variable in sv.Result.ToList())
                {
                    var newvendor = new Vendor();
                    newvendor.InjectFrom(sv.Vendors.FirstOrDefault(w => w.vendor_code == variable.Vendor));

                    var newrow = new TblDyeingOrderInvoiceHeaderViewModel();
                    newrow.InjectFrom(variable);
                    newrow.VendorPerRow = newvendor;
                    if (newrow.Status == 0)
                    {
                        newrow.VisPosted = true;
                    }
                    newrow.CurrencyPerRow = new GenericTable();
                    newrow.CurrencyPerRow.InjectFrom(CurrencyList.FirstOrDefault(w => w.Iserial == variable.TblCurrency));
                    newrow.TblCurrency = variable.TblCurrency;
                    MainRowList.Add(newrow);
                }
            };

            DyeingServiceClient.GetDyeingOrderInvoiceDetailCompleted += (s, sv) =>
            {
                foreach (var variable in sv.Result.ToList())
                {
                    var newrow = new TblDyeingOrderInvoiceDetailViewModel();
                    newrow.InjectFrom(variable);
                    newrow.ServicePerRow       = new TblService();
                    newrow.ColorPerRow         = new TblColor();
                    newrow.ColorPerRow.Code    = variable.TblColor1.Code;
                    newrow.ServicePerRow.Code  = variable.TblService1.Code;
                    newrow.ServicePerRow.Ename = variable.TblService1.Ename;
                    TransactionDetails.Add(newrow);
                }
            };
            DyeingServiceClient.SearchDyeingOrderInvoiceCompleted += (s, sv) =>
            {
                TransactionDetails.Clear();
                foreach (var variable in sv.Result.ToList())
                {
                    var newrow = new TblDyeingOrderInvoiceDetailViewModel();
                    newrow.InjectFrom(variable);
                    newrow.ServicePerRow       = new TblService();
                    newrow.ColorPerRow         = new TblColor();
                    newrow.ColorPerRow.Code    = variable.ColorCode;
                    newrow.ServicePerRow.Code  = variable.ServiceCode;
                    newrow.ServicePerRow.Ename = variable.ServiceName;
                    newrow.SupplierInv         = variable.SupplierInv;
                    TransactionDetails.Add(newrow);
                }
            };

            PurchasePlanClient.DyeingOrderInvoiceMarkupTransProdCompleted += (s, sv) =>
            {
                foreach (var row in sv.Result)
                {
                    var newrow = new TblMarkupTranProdViewModel();
                    newrow.InjectFrom(row);
                    newrow.CurrencyPerRow = new GenericTable();
                    newrow.CurrencyPerRow.InjectFrom(CurrencyList.FirstOrDefault(w => w.Iserial == row.TblCurrency));
                    newrow.TblCurrency    = row.TblCurrency;
                    newrow.TblMarkupProd1 = new TblMarkupProd();
                    newrow.TblMarkupProd1.InjectFrom(MarkupList.FirstOrDefault(w => w.Iserial == row.TblMarkupProd));
                    newrow.TblMarkupProd            = row.TblMarkupProd;
                    newrow.JournalAccountTypePerRow = JournalAccountTypeList.FirstOrDefault(w => w.Iserial == newrow.TblJournalAccountType);
                    newrow.EntityPerRow             = new GlService.Entity().InjectFrom(sv.entityList.FirstOrDefault(w => w.Iserial == row.EntityAccount && w.TblJournalAccountType == row.TblJournalAccountType)) as GlService.Entity;
                    newrow.TblJournalAccountType    = row.TblJournalAccountType;
                    newrow.EntityAccount            = row.EntityAccount;
                    SelectedMainRow.MarkUpTransList.Add(newrow);
                }

                Loading = false;

                if (SelectedMainRow.MarkUpTransList.Count == 0)
                {
                    AddNewMarkUpRow(false, true);
                }
            };
        }
        public async void LoadTransactions()
        {
            Rezervacija = await _serviceRezervacija.GetById <Models.DetaljiRezervacija.Rezervacija>(rezervacijaId);

            Rezervacija.RezervacijaProdajaBicikla
            .GroupBy(x => x.BiciklStanje.BiciklId)
            .Select(t => new Transactions
            {
                Product           = t.First(),
                ProductName       = t.First().BiciklStanje.Bicikl.PuniNaziv,
                UnitPrice         = "- " + t.First().BiciklStanje.Bicikl.Cijena.Value.ToString("0.00") + " KM",
                Amount            = t.Count(),
                TransactionAmount = "- " + (t.First().BiciklStanje.Bicikl.Cijena.Value *t.Count()).ToString("0.00") + " KM",
                IsCredited        = Rezervacija.DatumUplate != null,
                Date   = Rezervacija.DatumRezervacije,
                Image  = t.First().BiciklStanje.Bicikl.Slika,
                Ocjena = t.First().OcjenaKorisnika ?? 0
            })
            .ForEach(x => { UpdateRatingStars(x);  TransactionDetails.Add(x); });

            Rezervacija.RezervacijaProdajaDio
            .GroupBy(x => x.DioStanje.DioId)
            .Select(t => new Transactions
            {
                Product           = t.First(),
                ProductName       = t.First().DioStanje.Dio.Naziv,
                UnitPrice         = "- " + t.First().DioStanje.Dio.Cijena.ToString("0.00") + " KM",
                Amount            = t.Count(),
                TransactionAmount = "- " + (t.First().DioStanje.Dio.Cijena *t.Count()).ToString("0.00") + " KM",
                IsCredited        = Rezervacija.DatumUplate != null,
                Date   = Rezervacija.DatumRezervacije,
                Image  = t.First().DioStanje.Dio.Slika,
                Ocjena = t.First().OcjenaKorisnika ?? 0
            })
            .ForEach(x => { UpdateRatingStars(x); TransactionDetails.Add(x); });

            Rezervacija.RezervacijaProdajaOprema
            .GroupBy(x => x.OpremaStanje.OpremaId)
            .Select(t => new Transactions
            {
                Product           = t.First(),
                ProductName       = t.First().OpremaStanje.Oprema.Naziv,
                UnitPrice         = "- " + t.First().OpremaStanje.Oprema.Cijena.ToString("0.00") + " KM",
                Amount            = t.Count(),
                TransactionAmount = "- " + (t.First().OpremaStanje.Oprema.Cijena *t.Count()).ToString("0.00") + " KM",
                IsCredited        = Rezervacija.DatumUplate != null,
                Date   = Rezervacija.DatumRezervacije,
                Image  = t.First().OpremaStanje.Oprema.Slika,
                Ocjena = t.First().OcjenaKorisnika ?? 0
            })
            .ForEach(x => { UpdateRatingStars(x); TransactionDetails.Add(x); });

            Rezervacija.RezervacijaServis
            .GroupBy(x => x.ServisId)
            .Select(t => new Transactions
            {
                ProductName       = t.First().Servis.Naziv,
                UnitPrice         = "- " + t.First().Servis.Cijena.ToString("0.00") + " KM",
                Amount            = t.Count(),
                TransactionAmount = "- " + (t.First().Servis.Cijena *t.Count()).ToString("0.00") + " KM",
                IsCredited        = Rezervacija.DatumUplate != null,
                Date = Rezervacija.DatumRezervacije
            })
            .ForEach(x => TransactionDetails.Add(x));


            Rezervacija.RezervacijaIznajmljenaBicikla
            .GroupBy(x => x.BiciklStanje.BiciklId)
            .Select(t => new Transactions
            {
                Product           = t.First(),
                ProductName       = t.First().BiciklStanje.Bicikl.PuniNaziv,
                UnitPrice         = "- " + t.First().BiciklStanje.Bicikl.CijenaPoDanu.Value.ToString("0.00") + " KM",
                Amount            = t.Count(),
                TransactionAmount = "- " + (t.First().BiciklStanje.Bicikl.CijenaPoDanu.Value *t.Count()).ToString("0.00") + " KM",
                IsCredited        = Rezervacija.DatumUplate != null,
                Date   = Rezervacija.DatumRezervacije,
                Image  = t.First().BiciklStanje.Bicikl.Slika,
                Ocjena = t.First().OcjenaKorisnika ?? 0
            })
            .ForEach(x => { UpdateRatingStars(x); TransactionDetails.Add(x); });
        }
Beispiel #8
0
        public SalesOrderRequestInvoiceViewModel() : base(PermissionItemName.SalesOrderRequestInvoice)
        {
            //         WarehouseClient.PostSalesOrderRequestInvoiceCompleted += (s, sv) =>
            //{
            //	if (sv.Result != null) TransactionHeader.InjectFrom(sv.Result);
            //	TransactionHeader.VisPosted = false;
            //	MessageBox.Show("Posted Completed");
            //};


            GetItemPermissions(PermissionItemName.SalesOrderRequestInvoice.ToString());
            var journalAccountTypeClient = new GlService.GlServiceClient();

            journalAccountTypeClient.GetGenericCompleted += (s, sv) =>
            {
                JournalAccountTypeList = sv.Result;
            };
            journalAccountTypeClient.GetGenericAsync("TblJournalAccountType", "%%", "%%", "%%", "Iserial", "ASC", LoggedUserInfo.DatabasEname);

            MiscValueTypeList = new ObservableCollection <CRUDManagerService.GenericTable>
            {
                new CRUDManagerService.GenericTable {
                    Iserial = 0, Code = "%", Ename = "%", Aname = "%"
                },
                new CRUDManagerService.GenericTable {
                    Iserial = 1, Code = "Value", Ename = "Value", Aname = "Value"
                }
            };

            var currencyClient = new GlService.GlServiceClient();

            currencyClient.GetGenericCompleted += (s, sv) =>
            {
                CurrencyList = new ObservableCollection <CRUDManagerService.GenericTable>();
                foreach (var item in sv.Result)
                {
                    CurrencyList.Add(new CRUDManagerService.GenericTable().InjectFrom(item) as CRUDManagerService.GenericTable);
                }
            };
            currencyClient.GetGenericAsync("TblCurrency", "%%", "%%", "%%", "Iserial", "ASC", LoggedUserInfo.DatabasEname);

            PurchasePlanClient.GetTblMarkupProdAsync(0, int.MaxValue, "it.Iserial", null, null, LoggedUserInfo.DatabasEname);

            PurchasePlanClient.GetTblMarkupProdCompleted += (s, sv) =>
            {
                MarkupList = new ObservableCollection <CRUDManagerService.TblMarkupProd>();
                foreach (var item in sv.Result)
                {
                    MarkupList.Add(new CRUDManagerService.TblMarkupProd().InjectFrom(item) as CRUDManagerService.TblMarkupProd);
                }
            };


            TransactionHeader = new TblSalesOrderRequestInvoiceHeaderModel {
                DocDate = DateTime.Now
            };



            WarehouseClient.UpdateOrInsertTblSalesOrderRequestInvoiceHeaderCompleted += (s, sv) =>
            {
                if (sv.Error != null)
                {
                    MessageBox.Show(sv.Error.Message);
                }
                try
                {
                    TransactionHeader.InjectFrom(sv.Result);

                    if (TransactionHeader.Status == 0)
                    {
                        TransactionHeader.VisPosted = true;
                    }
                    else
                    {
                        TransactionHeader.VisPosted = false;
                    }
                }
                // ReSharper disable once EmptyGeneralCatchClause
                catch (Exception)
                {
                }
                Loading = false;
                Loading = false;
                MessageBox.Show("Saved");
            };

            WarehouseClient.UpdateOrInsertTblSalesOrderRequestInvoiceMarkupTransProdsCompleted += (s, x) =>
            {
                var markup = new CRUDManagerService.TblMarkupProd();
                try
                {
                    var row = TransactionHeader.MarkUpTransList.ElementAt(x.outindex);
                    if (row != null)
                    {
                        markup = row.TblMarkupProd1;
                    }
                    TransactionHeader.MarkUpTransList.ElementAt(x.outindex).InjectFrom(x.Result);

                    if (row != null)
                    {
                        row.TblMarkupProd1 = markup;
                    }
                }
                // ReSharper disable once EmptyGeneralCatchClause
                catch (Exception)
                {
                }

                Loading = false;
            };
            WarehouseClient.GetTblSalesOrderRequestInvoiceHeaderCompleted += (s, sv) =>
            {
                Loading = false;
                TransactionHeaderList.Clear();
                foreach (var variable in sv.Result.ToList())
                {
                    var newrow = new TblSalesOrderRequestInvoiceHeaderModel();
                    newrow.InjectFrom(variable);
                    if (newrow.Status == 0)
                    {
                        newrow.VisPosted = true;
                    }
                    newrow.JournalAccountTypePerRow = new GlService.GenericTable();
                    newrow.JournalAccountTypePerRow = JournalAccountTypeList.FirstOrDefault(w => w.Iserial == newrow.TblJournalAccountType);
                    newrow.EntityPerRow             = new GlService.Entity().InjectFrom(sv.entityList.FirstOrDefault(w => w.Iserial == variable.EntityAccount && w.TblJournalAccountType == variable.TblJournalAccountType)) as GlService.Entity;
                    newrow.CurrencyPerRow           = new GlService.GenericTable().InjectFrom(CurrencyList.FirstOrDefault(w => w.Iserial == newrow.TblCurrency)) as GlService.GenericTable;
                    TransactionHeaderList.Add(newrow);
                }
            };
            WarehouseClient.GetTblSalesIssueHeaderCompleted += (s, sv) =>
            {
                if (sv.Result != null)
                {
                    foreach (var row in sv.Result)
                    {
                        if (!RecieveHeaderList.Select(x => x.DocCode).Contains(row.DocCode))
                        {
                            RecieveHeaderList.Add(new TblSalesIssueHeaderModel().InjectFrom(row) as TblSalesIssueHeaderModel);
                        }
                    }
                }
            };
            WarehouseClient.GetSalesIssueHeaderPendingCompleted += (s, sv) =>
            {
                if (sv.Result != null)
                {
                    foreach (var row in sv.Result)
                    {
                        if (!RecieveHeaderChoosedList.Select(x => x.DocCode).Contains(row.DocCode))
                        {
                            RecieveHeaderChoosedList.Add(
                                new TblSalesIssueHeaderModel().InjectFrom(row) as TblSalesIssueHeaderModel);
                        }
                    }
                }
            };

            WarehouseClient.GetTblSalesOrderRequestInvoiceDetailCompleted += (s, sv) =>
            {
                foreach (var variable in sv.Result.ToList())
                {
                    var newrow = new TblSalesOrderRequestInvoiceDetailModel();
                    newrow.InjectFrom(variable);
                    newrow.ItemPerRow = new CRUDManagerService.ItemsDto().InjectFrom(sv.itemsList.FirstOrDefault(w => w.ItemGroup == variable.TblItemDim1.ItemType && w.Iserial == variable.TblItemDim1.ItemIserial)) as CRUDManagerService.ItemsDto;
                    TransactionDetails.Add(newrow);
                }
            };
            WarehouseClient.SearchSalesOrderRequestInvoiceCompleted += (s, sv) =>
            {
                if (sv.Result != null)
                {
                    TransactionHeader.InjectFrom(sv.Result);
                }
                TransactionHeader.VisPosted = true;
                GetDetailData();
            };
            WarehouseClient.PostTblSalesOrderRequestInvoiceHeaderCompleted += (s, sv) =>
            {
                if (sv.Result != null)
                {
                    TransactionHeader.InjectFrom(sv.Result);
                }
                //   TransactionHeader.VisPosted = true;
                // GetDetailData();
            };
        }