Пример #1
0
        public async Task <IActionResult> Edit(int id, [Bind("PayProductId,ProductIdFrom,ProductIdTo,Description,Amount,Tax,PayProductDate,CreatedDate,StatusPayProduct")] PayProduct payProduct)
        {
            if (id != payProduct.PayProductId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    PayProduct payProductOld = await _context.PayProduct.SingleOrDefaultAsync(p => p.PayProductId == payProduct.PayProductId);

                    if (payProduct.Amount != payProductOld.Amount)
                    {
                        FunctionsConvert functionsConvert = new FunctionsConvert(_context);

                        var _amount = payProduct.Amount - payProductOld.Amount;
                        var _tax    = payProduct.Tax - payProductOld.Tax;

                        payProduct.ProductFrom = await _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdFrom);

                        payProduct.ProductTo = await _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdTo);

                        var _payProduct = functionsConvert.ConvertCurrency(payProduct, _amount, _tax);

                        if (payProduct.ProductFrom.Balance < (_payProduct.Amount + _payProduct.Tax))
                        {
                            CreateInitial(payProduct.ProductIdFrom, payProduct.ProductIdTo);
                            ModelState.AddModelError("", "Balance de Producto origen insuficiente.");
                            return(View(payProduct));
                        }

                        //restar el balance del producto origen
                        payProduct.ProductFrom.Balance = payProduct.ProductFrom.Balance - _payProduct.Amount - _payProduct.Tax;

                        //sumar al balance del prestamo destino
                        payProduct.ProductTo.Balance = payProduct.ProductTo.Balance - _amount;
                    }
                    _context.Entry(payProductOld).State = EntityState.Detached; //detach old to update the new
                    _context.Update(payProduct);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!PayProductExists(payProduct.PayProductId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            CreateInitial(payProduct.ProductIdFrom, payProduct.ProductIdTo);
            return(View(payProduct));
        }
Пример #2
0
        // GET: PayProducts/Create
        public IActionResult Create()
        {
            CreateInitial(0, 0);
            PayProduct payProduct = new PayProduct();

            payProduct.PayProductDate = DateTime.Today;
            return(View(payProduct));
        }
Пример #3
0
        public PayProduct ConvertCurrency(PayProduct payProduct, decimal _amount, decimal _tax)
        {
            PayProduct _payProduct = new PayProduct();

            if (_amount > 0)
            {
                _payProduct.Amount = _amount;
                _payProduct.Tax    = _tax;
            }
            else
            {
                _payProduct.Amount = payProduct.Amount;
                _payProduct.Tax    = payProduct.Tax;
            }


            var productFrom = _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdFrom);
            var productTo   = _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdTo);

            if (productFrom.Result.currency.CurrencyId != productTo.Result.currency.CurrencyId)
            {
                var currencyConvert = _context.CurrencyConvert.SingleOrDefaultAsync(p => p.CurrencyFromCurrencyId == productTo.Result.CurrencyId &&
                                                                                    p.CurrencyToCurrencyId == productFrom.Result.CurrencyId && p.StatusCurrency == Models.Enum.StatusCurrency.Activa &&
                                                                                    (p.DateValidFrom <= payProduct.PayProductDate && p.DateValidTo >= payProduct.PayProductDate));

                if (currencyConvert != null)
                {
                    if (_amount > 0)
                    {
                        _payProduct.Amount = _amount * currencyConvert.Result.Multiple;
                        _payProduct.Tax    = _tax * currencyConvert.Result.Multiple;
                    }
                    else
                    {
                        _payProduct.Amount = payProduct.Amount * currencyConvert.Result.Multiple;
                        _payProduct.Tax    = payProduct.Tax * currencyConvert.Result.Multiple;
                    }
                }
            }

            return(_payProduct);
        }
Пример #4
0
        public async Task <IActionResult> Create([Bind("PayProductId,ProductIdFrom,ProductIdTo,CreditCardCutId,Description,Amount,Tax,PayProductDate")] PayProduct payProduct)
        {
            if (ModelState.IsValid)
            {
                payProduct.ProductFrom = await _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdFrom);

                payProduct.ProductTo = await _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdTo);

                payProduct.CreditCardCut = await _context.CreditCardCut.SingleOrDefaultAsync(p => p.CreditCardCutId == payProduct.CreditCardCutId);

                if (payProduct.ProductFrom.Balance < (payProduct.Amount + payProduct.Tax))
                {
                    CreateInitial(payProduct.ProductIdFrom, payProduct.ProductIdTo, payProduct.CreditCardCutId);
                    ModelState.AddModelError("", "Balance de Producto origen insuficiente.");
                    return(View(payProduct));
                }
                FunctionsConvert functionsConvert = new FunctionsConvert(_context);
                var _payProduct = functionsConvert.ConvertCurrency(payProduct, 0, 0);

                //restar el balance del producto origen
                payProduct.ProductFrom.Balance = payProduct.ProductFrom.Balance - payProduct.Amount - payProduct.Tax;

                //sumar al balance a la tc destino
                payProduct.ProductTo.Balance = payProduct.ProductTo.Balance + payProduct.Amount;

                //actualizar corte de tarjeta
                payProduct.CreditCardCut.AmountPayment = payProduct.CreditCardCut.AmountPayment + payProduct.Amount;
                payProduct.CreditCardCut.AmountPending = payProduct.CreditCardCut.AmountPending - payProduct.Amount;

                payProduct.CreatedDate      = DateTime.Today;
                payProduct.StatusPayProduct = Models.Enum.StatusPayment.Activo;
                _context.Add(payProduct);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            CreateInitial(payProduct.ProductIdFrom, payProduct.ProductIdTo, payProduct.CreditCardCutId);
            return(View(payProduct));
        }
Пример #5
0
        public async Task <IActionResult> Create([Bind("PayProductId,ProductIdFrom,ProductIdTo,Description,Amount,Tax,PayProductDate")] PayProduct payProduct)
        {
            if (ModelState.IsValid)
            {
                payProduct.ProductFrom = await _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdFrom);

                payProduct.ProductTo = await _context.Product.SingleOrDefaultAsync(p => p.ProductId == payProduct.ProductIdTo);

                if (payProduct.ProductFrom.Balance < (payProduct.Amount + payProduct.Tax))
                {
                    CreateInitial(payProduct.ProductIdFrom, payProduct.ProductIdTo);
                    ModelState.AddModelError("", "Balance de Producto origen insuficiente.");
                    return(View(payProduct));
                }

                FunctionsConvert functionsConvert = new FunctionsConvert(_context);
                var _payProduct = functionsConvert.ConvertCurrency(payProduct, 0, 0);

                //restar el balance del producto origen
                payProduct.ProductFrom.Balance = payProduct.ProductFrom.Balance - _payProduct.Amount - _payProduct.Tax;

                //sumar al balance del prestamo destino, pero convertir antes si hay diferencia de monedas
                payProduct.ProductTo.Balance = payProduct.ProductTo.Balance - payProduct.Amount;

                //ver como trabajar con los intereses y capital del prestamo

                payProduct.StatusPayProduct = Models.Enum.StatusPayment.Activo;
                payProduct.CreatedDate      = DateTime.Today;
                _context.Add(payProduct);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            CreateInitial(payProduct.ProductIdFrom, payProduct.ProductIdTo);
            return(View(payProduct));
        }
Пример #6
0
        public void Recalc(decimal qty, PayProduct p)
        {
            var q = qty > 0;

            p = q ? GridProducts.SelectedItem as PayProduct : GridReturnedProducts.SelectedItem as PayProduct;

            if (p != null)
            {
                qty   = Math.Abs(qty);
                p.Qty = p.Qty - qty;

                if (p.Qty < 1)
                {
                    if (q)
                    {
                        _check.PayProducts.Remove(p);
                    }
                    else
                    {
                        _returnedProducts.Remove(p);
                    }
                }

                var g = (q) ? _returnedProducts.Find(l => l.ProductId == p.ProductId) : _check.PayProducts.ToList().Find(l => l.ProductId == p.ProductId);

                if (g != null)
                {
                    g.Qty   = g.Qty + qty;
                    g.Total = (g.PriceHt * g.Qty);
                    p.Total = (p.PriceHt * p.Qty);
                }
                else
                {
                    var n = new PayProduct(
                        p.IdCheckTicket,
                        p.ProductId,
                        p.Name,
                        p.Barcode,
                        qty,
                        p.Tva,
                        p.PriceHt,
                        (p.PriceHt * qty),
                        p.ChecksTicketCustomerId,
                        p.ChecksTicketCloseTicketCustomerId,
                        0,
                        0);

                    p.Total = (p.PriceHt * p.Qty);
                    if (q)
                    {
                        _returnedProducts.Add(n);
                    }
                    else
                    {
                        _check.PayProducts.Add(n);
                    }
                }
                CollectionViewSource.GetDefaultView(GridProducts.ItemsSource).Refresh();
                CollectionViewSource.GetDefaultView(GridReturnedProducts.ItemsSource).Refresh();
            }
            else
            {
                FunctionsService.ShowMessageTime(Properties.Resources.LabelNofFound);
            }
        }