async void CreateProductionOrder(DebtorOfferLineClient offerLine)
        {
            var t = saveGridLocal();

            if (t != null && offerLine.RowId == 0)
            {
                await t;
            }

            object[] arr = new object[3] {
                api, offerLine, dgDebtorOfferLineGrid.masterRecord
            };
            AddDockItem(TabControls.ProductionOrdersPage2, arr, Uniconta.ClientTools.Localization.lookup("Production"), "Add_16x16.png");
        }
 async void setLocation(InvWarehouse master, DebtorOfferLineClient rec)
 {
     if (api.CompanyEntity.Location)
     {
         if (master != null)
         {
             rec.locationSource = master.Locations ?? await master.LoadLocations(api);
         }
         else
         {
             rec.locationSource = null;
             rec.Location       = null;
         }
         rec.NotifyPropertyChanged("LocationSource");
     }
 }
        private void DataControl_CurrentItemChanged(object sender, DevExpress.Xpf.Grid.CurrentItemChangedEventArgs e)
        {
            DebtorOfferLineClient oldselectedItem = e.OldItem as DebtorOfferLineClient;

            if (oldselectedItem != null)
            {
                oldselectedItem.PropertyChanged -= DebtorOfferLineClient_PropertyChanged;
            }

            DebtorOfferLineClient selectedItem = e.NewItem as DebtorOfferLineClient;

            if (selectedItem != null)
            {
                selectedItem.PropertyChanged += DebtorOfferLineClient_PropertyChanged;
            }
            ;
        }
        async void setSerieBatchSource(DebtorOfferLineClient row)
        {
            var cache         = api.CompanyEntity.GetCache(typeof(InvItem));
            var invItemMaster = cache.Get(row._Item) as InvItem;

            if (invItemMaster == null)
            {
                return;
            }
            if (row.SerieBatches != null && row.SerieBatches.First()._Item == row._Item)/*Bind if Item changed*/
            {
                return;
            }
            List <UnicontaBaseEntity> masters = null;

            if (row._Qty < 0)
            {
                masters = new List <UnicontaBaseEntity>()
                {
                    invItemMaster
                };
            }
            else
            {
                // We only select opens
                var mast = new InvSerieBatchOpen();
                mast.SetMaster(invItemMaster);
                masters = new List <UnicontaBaseEntity>()
                {
                    mast
                };
            }
            var res = await api.Query <SerialToOrderLineClient>(masters, null);

            if (res != null && res.Length > 0)
            {
                row.SerieBatches = res;
                row.NotifyPropertyChanged("SerieBatches");
            }
        }
        async void setVariant(DebtorOfferLineClient rec, bool SetVariant2)
        {
            if (items == null || variants1 == null || variants2 == null)
            {
                return;
            }

            //Check for Variant2 Exist
            if (string.IsNullOrEmpty(api.CompanyEntity?._Variant2))
            {
                SetVariant2 = false;
            }

            var item = (InvItem)items.Get(rec._Item);

            if (item != null && item._StandardVariant != null)
            {
                rec.standardVariant = item._StandardVariant;
                var master = (InvStandardVariant)standardVariants?.Get(item._StandardVariant);
                if (master == null)
                {
                    return;
                }
                if (master._AllowAllCombinations)
                {
                    rec.Variant1Source = (IEnumerable <InvVariant1>) this.variants1?.GetKeyStrRecords;
                    rec.Variant2Source = (IEnumerable <InvVariant2>) this.variants2?.GetKeyStrRecords;
                }
                else
                {
                    var Combinations = master.Combinations ?? await master.LoadCombinations(api);

                    if (Combinations == null)
                    {
                        return;
                    }
                    List <InvVariant1> invs1 = null;
                    List <InvVariant2> invs2 = null;
                    string             vr1   = null;
                    if (SetVariant2)
                    {
                        vr1   = rec._Variant1;
                        invs2 = new List <InvVariant2>();
                    }
                    else
                    {
                        invs1 = new List <InvVariant1>();
                    }

                    string LastVariant     = null;
                    var    var2Value       = rec._Variant2;
                    bool   hasVariantValue = (var2Value == null);
                    foreach (var cmb in Combinations)
                    {
                        if (SetVariant2)
                        {
                            if (cmb._Variant1 == vr1 && cmb._Variant2 != null)
                            {
                                var v2 = (InvVariant2)variants2.Get(cmb._Variant2);
                                invs2.Add(v2);
                                if (var2Value == v2._Variant)
                                {
                                    hasVariantValue = true;
                                }
                            }
                        }
                        else if (LastVariant != cmb._Variant1)
                        {
                            LastVariant = cmb._Variant1;
                            var v1 = (InvVariant1)variants1.Get(cmb._Variant1);
                            invs1.Add(v1);
                        }
                    }
                    if (SetVariant2)
                    {
                        rec.variant2Source = invs2;
                        if (!hasVariantValue)
                        {
                            rec.Variant2 = null;
                        }
                    }
                    else
                    {
                        rec.variant1Source = invs1;
                    }
                }
            }
            else
            {
                rec.variant1Source = null;
                rec.variant2Source = null;
            }
            if (SetVariant2)
            {
                rec.NotifyPropertyChanged("Variant2Source");
            }
            else
            {
                rec.NotifyPropertyChanged("Variant1Source");
            }
        }
        async void UnfoldBOM(DebtorOfferLineClient selectedItem, bool usePriceFromBOM)
        {
            var items = this.items;
            var item  = (InvItem)items.Get(selectedItem._Item);

            if (item == null || item._ItemType < (byte)ItemType.BOM)
            {
                return;
            }

            busyIndicator.IsBusy      = true;
            busyIndicator.BusyContent = Uniconta.ClientTools.Localization.lookup("LoadingMsg");
            var list = await api.Query <InvBOM>(selectedItem);

            if (list != null && list.Length > 0)
            {
                var pl = this.PriceLookup;
                if (!usePriceFromBOM)
                {
                    this.PriceLookup = null;
                }

                var type = dgDebtorOfferLineGrid.TableTypeUser;
                var Qty  = selectedItem._Qty;
                var lst  = new List <UnicontaBaseEntity>(list.Length);
                foreach (var bom in list)
                {
                    var invJournalLine = Activator.CreateInstance(type) as DebtorOfferLineClient;
                    invJournalLine._Date     = selectedItem._Date;
                    invJournalLine._Week     = selectedItem._Week;
                    invJournalLine._Dim1     = selectedItem._Dim1;
                    invJournalLine._Dim2     = selectedItem._Dim2;
                    invJournalLine._Dim3     = selectedItem._Dim3;
                    invJournalLine._Dim4     = selectedItem._Dim4;
                    invJournalLine._Dim5     = selectedItem._Dim5;
                    invJournalLine._Item     = bom._ItemPart;
                    invJournalLine._Variant1 = bom._Variant1;
                    invJournalLine._Variant2 = bom._Variant2;
                    invJournalLine._Variant3 = bom._Variant3;
                    invJournalLine._Variant4 = bom._Variant4;
                    invJournalLine._Variant5 = bom._Variant5;
                    item = (InvItem)items.Get(bom._ItemPart);
                    if (item != null)
                    {
                        invJournalLine._Warehouse     = bom._Warehouse ?? item._Warehouse ?? selectedItem._Warehouse;
                        invJournalLine._Location      = bom._Location ?? item._Location ?? selectedItem._Location;
                        invJournalLine._CostPriceLine = item._CostPrice;
                        invJournalLine.SetItemValues(item, selectedItem._Storage);
                        invJournalLine._Qty = Math.Round(bom.GetBOMQty(Qty), item._Decimals);
                        TableField.SetUserFieldsFromRecord(item, invJournalLine);
                    }
                    else
                    {
                        invJournalLine._Qty = Math.Round(bom.GetBOMQty(Qty), 2);
                    }
                    invJournalLine._Price = 0d;
                    TableField.SetUserFieldsFromRecord(bom, invJournalLine);
                    lst.Add(invJournalLine);
                }
                dgDebtorOfferLineGrid.PasteRows(lst);
                DataChaged       = true;
                this.PriceLookup = pl;

                dgDebtorOfferLineGrid.SetLoadedRow(selectedItem);

                double _AmountEntered = 0d;
                if (!usePriceFromBOM)
                {
                    _AmountEntered = selectedItem._Amount;
                }
                selectedItem.Price = 0; // will clear amountEntered
                if (!usePriceFromBOM)
                {
                    selectedItem._AmountEntered = _AmountEntered;
                }
                selectedItem.Qty         = 0;
                selectedItem.DiscountPct = 0;
                selectedItem.Discount    = 0;
                selectedItem.CostPrice   = 0;
                dgDebtorOfferLineGrid.SetModifiedRow(selectedItem);
            }
            busyIndicator.IsBusy = false;
        }
        async Task CreateOfferLinesFromInvoice(DebtorOfferClient order, DebtorInvoiceClient invoice, bool checkIfCreditNote)
        {
            var offerlines = new List <DebtorOfferLineClient>();

            order.OfferLines = offerlines;
            var invoiceLines = await api.Query <DebtorInvoiceLines>(invoice);

            if (invoiceLines == null || invoiceLines.Length == 0)
            {
                return;
            }

            Array.Sort(invoiceLines, new InvLineSort());

            offerlines.Capacity = invoiceLines.Length;
            int    lineNo = 0;
            double sign   = checkIfCreditNote ? -1d : 1d;

            foreach (var invoiceline in invoiceLines)
            {
                var line = new DebtorOfferLineClient();
                line.SetMaster(order);

                line._LineNumber  = ++lineNo;
                line._Item        = invoiceline._Item;
                line._DiscountPct = invoiceline._DiscountPct;
                line._Discount    = invoiceline._Discount;
                line._Qty         = invoiceline.InvoiceQty * sign;
                line._Price       = (invoiceline.CurrencyEnum != null ? invoiceline._PriceCur : invoiceline._Price);
                if (line._Price != 0)
                {
                    line._Price += invoiceline._PriceVatPart;
                }

                if (line._Qty * line._Price == 0)
                {
                    line._AmountEntered = ((invoiceline.CurrencyEnum != null ? invoiceline._AmountCur : invoiceline._Amount) + invoiceline._PriceVatPart) * sign;
                }
                line._Dim1      = invoiceline._Dim1;
                line._Dim2      = invoiceline._Dim2;
                line._Dim3      = invoiceline._Dim3;
                line._Dim4      = invoiceline._Dim4;
                line._Dim5      = invoiceline._Dim5;
                line._Employee  = invoiceline._Employee;
                line._Note      = invoiceline._Note;
                line._Text      = invoiceline._Text;
                line._Unit      = invoiceline._Unit;
                line._Variant1  = invoiceline._Variant1;
                line._Variant2  = invoiceline._Variant2;
                line._Variant3  = invoiceline._Variant3;
                line._Variant4  = invoiceline._Variant4;
                line._Variant5  = invoiceline._Variant5;
                line._Warehouse = invoiceline._Warehouse;
                line._Location  = invoiceline._Location;
                var selectedItem = (InvItem)items?.Get(invoiceline._Item);
                if (selectedItem != null)
                {
                    line._Item          = selectedItem._Item;
                    line._CostPriceLine = selectedItem._CostPrice;
                    if (selectedItem._Unit != 0)
                    {
                        line._Unit = selectedItem._Unit;
                    }
                }

                offerlines.Add(line);
            }
            dcOrderlineGrid.ItemsSource = debtorOfferLines = null;
            dcOrderlineGrid.ItemsSource = debtorOfferLines = offerlines;
            dcOrderlineGrid.Visibility  = Visibility.Visible;
        }