public CajaMovimiento Create(TipoComprobanteEnum tipoComprobante, TipoMovimientoCajaEnum tipoMovimiento, Guid comprobanteId, decimal importe)
        {
            CajaMovimiento cajaMovimiento = new CajaMovimiento();

            cajaMovimiento.Id = Guid.NewGuid();
            cajaMovimiento.CajaId = _context.CajaActual.Id;
            cajaMovimiento.TipoComprobante = tipoComprobante;
            cajaMovimiento.TipoMovimientoCajaId = tipoMovimiento;
            cajaMovimiento.ComprobanteId = comprobanteId;
            cajaMovimiento.Importe = importe;
            cajaMovimiento.ImpFac = importe;
            cajaMovimiento.FechaAlta = _clock.Now;
            cajaMovimiento.FechaModificacion = _clock.Now;
            cajaMovimiento.PcAlta = System.Environment.MachineName;
            cajaMovimiento.OperadorAltaId = _context.OperadorActual.Id;
            cajaMovimiento.SucursalAltaId = _context.SucursalActual.Id;
            cajaMovimiento.OperadorModificacionId = _context.OperadorActual.Id;
            cajaMovimiento.SucursalModificacionId = _context.SucursalActual.Id;

            return cajaMovimiento;
        }
        private void AgregarMovimientos(OrdenesPagoDetalle pago, DetalleFormaPago vPago)
        {
            var movimiento = new CajaMovimiento();
            movimiento.Id = Guid.NewGuid();
            movimiento.Importe = pago.ImportePagado;
            movimiento.ComprobanteId = _ordenPago.Id;
            movimiento.TipoComprobante = TipoComprobanteEnum.OrdenPago;
            movimiento.TipoMovimientoCajaId = vPago.IsDeleted ? TipoMovimientoCajaEnum.AnulaciónOrdenPago : TipoMovimientoCajaEnum.PagoGastos;
            movimiento.PcAlta = Environment.MachineName;

            movimiento.CajaId = _cajaActual.Id;

            if (pago.Efectivo.HasValue && pago.Efectivo != 0)
            {
                //Si ImportePagado <> 0 => Pago Normal en Efectivo
                //Si ImportePagado = 0 => Pago Programado
                if (pago.ImportePagado.HasValue && pago.ImportePagado != 0)
                {
                    movimiento.Efectivo = pago.Efectivo;

                    var pagoEfec = vPago as PagoEfectivo;

                    if (pagoEfec.CajaAnterior)
                    {
                        ActualizarCajaAnterior(pagoEfec, _cajaActual, movimiento);
                    }
                    else
                    {
                        ActualizarCajaActual(pago, _cajaActual);
                    }

                    Uow.Cajas.Modificar(_cajaActual);
                }
            }

            if (pago.Cheques.HasValue && pago.Cheques != 0)
            {
                movimiento.Cheque = pago.ImportePagado;
            }

            if (pago.DepositoEfectivo.HasValue && pago.DepositoEfectivo != 0)
            {
                movimiento.Deposito = pago.ImportePagado;
            }

            if (pago.Transferencia.HasValue && pago.Transferencia != 0)
            {
                movimiento.Transferencia = pago.ImportePagado;
            }

            movimiento.FechaAlta = pago.Id == default(Guid) ? _clock.Now : pago.FechaAlta;
            movimiento.SucursalAltaId = Context.SucursalActual.Id;
            movimiento.OperadorAltaId = Context.OperadorActual.Id;

            Uow.CajaMovimientos.Agregar(movimiento);
        }
        private void AgregarMovimientos()
        {
            var movimiento = new CajaMovimiento();
            movimiento.Id = Guid.NewGuid();
            movimiento.Importe = _ordenPagoDetalle.ImportePagado;
            movimiento.ComprobanteId = _ordenPagoId;
            movimiento.TipoComprobante = TipoComprobanteEnum.OrdenPago;
            movimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.AnulaciónOrdenPago;
            Caja caja = this.Context.CajaActual;
            movimiento.CajaId = caja.Id;
            if (_esEfectivo)
            {
                movimiento.Efectivo = _ordenPagoDetalle.ImportePagado;
                caja.Egresos -= (float)(_ordenPagoDetalle.ImportePagado ?? 0);
                caja.Saldo += (float)(_ordenPagoDetalle.ImportePagado ?? 0);
                caja.FechaModificacion = _pagoId == default(Guid) ? (DateTime?)null : _clock.Now;
                caja.SucursalModificacionId = _pagoId == default(Guid)
               ? null
               : caja.SucursalModificacionId;
                caja.OperadorModificacionId = _pagoId == default(Guid)
                ? null
                : caja.OperadorModificacionId;
                Uow.Cajas.Modificar(caja);
            }
            else
            {
                movimiento.Cheque = _ordenPagoDetalle.ImportePagado;
            }

            movimiento.FechaAlta = _pagoId == default(Guid) ? _clock.Now : _ordenPagoDetalle.FechaAlta;
            movimiento.FechaModificacion = _pagoId == default(Guid) ? (DateTime?)null : _clock.Now;

            movimiento.SucursalAltaId = _pagoId == default(Guid)
                ? Context.SucursalActual.Id
                : movimiento.SucursalAltaId;

            movimiento.SucursalModificacionId = _pagoId == default(Guid)
                ? null
                : movimiento.SucursalModificacionId;

            movimiento.OperadorAltaId = _pagoId == default(Guid)
                ? Context.OperadorActual.Id
                : movimiento.OperadorAltaId;

            movimiento.OperadorModificacionId = _pagoId == default(Guid)
                ? null
                : movimiento.OperadorModificacionId;
            Uow.CajaMovimientos.Agregar(movimiento);
        }
        private void GuardarPagosConsignacion()
        {
            if (!ValidarPagoConsignacion())
                return;

            //Acumulamos los pagos
            decimal? efectivo = 0;
            decimal? efectivoCajaAnterior = 0;
            decimal? tarjeta = 0;
            decimal? cheque = 0;
            decimal? deposito = 0;
            decimal? transferencia = 0;

            foreach (var pago in ucTotalesCompraSeña1.Pagos)
            {
                switch (pago.TipoPago)
                {
                    case FormaPago.Efectivo:
                        efectivo += pago.Importe;
                        break;

                    case FormaPago.EfectivoCajaAnterior:
                        efectivoCajaAnterior += pago.Importe;
                        break;

                    case FormaPago.Tarjeta:
                        tarjeta += pago.Importe;
                        break;

                    case FormaPago.Cheque:
                        cheque += pago.Importe;
                        break;

                    case FormaPago.Deposito:
                        deposito += pago.Importe;
                        break;

                    case FormaPago.Transferencia:
                        transferencia += pago.Importe;
                        break;
                }
            }



            #region Guardamos caja en contado

            //Guardamos la caja
            Caja caja = new Caja();
            if (DtpFechaPago.Value != _clock.Now)
            {
                caja = Uow.Cajas.Obtener(c => DbFunctions.TruncateTime(c.FechaAlta) == DtpFechaPago.Value.Date);
                if (caja == null)
                {
                    MessageBox.Show("No se encontro una caja válida para esa fecha");
                    return;
                }
            }
            else
            {
                caja = this.Context.CajaActual;

                //descontar de la caja
                if (caja.Egresos == null)
                    caja.Egresos = 0;

                caja.Egresos += (float?)efectivo;

                if (caja.Saldo == null)
                    caja.Saldo = 0;
                caja.Saldo -= (float?)ucTotalesCompraSeña1.SubTotal;

                caja.FechaModificacion = _clock.Now;
                caja.SucursalModificacionId = Context.SucursalActual.Id;
                caja.OperadorModificacionId = (Context.OperadorActual.Id);
            }


            //aca descontamos las señas en el caso de que se utilicen. 
            var _seña = UsoDeSeña();
            var _credito = UsoDeCredito();
            var _egreso = UsoEgreso();

            if (efectivo > 0)
            {
                CajaMovimiento cajaMovimiento = new CajaMovimiento();
                cajaMovimiento.Id = Guid.NewGuid();
                cajaMovimiento.CajaId = caja.Id;

                cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.PagoProveedores;

                //le paso guid empty pero hay que ver que se le pasa
                cajaMovimiento.ComprobanteId = _pagoIdConsignacion;
                cajaMovimiento.Importe = efectivo;
                cajaMovimiento.ImpFac = (decimal?)ucTotalesCompraSeña1.SubTotal;
                cajaMovimiento.Efectivo = efectivo;

                cajaMovimiento.Senia = _seña + _credito + _egreso;
                if (_seña > 0)
                {
                    //cajaMovimiento.Senia = _seña;
                    _seña = 0;
                }

                if (_credito > 0)
                {
                    //cajaMovimiento.Senia = _seña;
                    _credito = 0;
                }

                if (_egreso > 0)
                {
                    _egreso = 0;
                }

                cajaMovimiento.FechaAlta = DtpFechaPago.Value;

                cajaMovimiento.PcAlta = System.Environment.MachineName;
                cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                cajaMovimiento.OperadorModificacionId = Context.OperadorActual.Id;
                cajaMovimiento.FechaModificacion = _clock.Now;
                cajaMovimiento.SucursalModificacionId = Context.SucursalActual.Id;

                cajaMovimiento.TipoComprobante = TipoComprobanteEnum.PagoProveedores;
                Uow.CajaMovimientos.Agregar(cajaMovimiento);
            }

            if (tarjeta > 0 || deposito > 0 || cheque > 0 || efectivoCajaAnterior > 0 || transferencia > 0)
            {
                CajaMovimiento cajaMovimientoAnterior = new CajaMovimiento();
                cajaMovimientoAnterior.Id = Guid.NewGuid();
                cajaMovimientoAnterior.CajaId = caja.Id;

                //cajaMovimientoAnterior.TipoMovimientoCajaId =
                //    TipoMovimientoCajaEnum.PagoProveedorCajaAnterior; -2
                cajaMovimientoAnterior.TipoMovimientoCajaId =
                    TipoMovimientoCajaEnum.PagoCtaProveedorCajaAnterior;

                cajaMovimientoAnterior.ComprobanteId = _pagoIdConsignacion;
                cajaMovimientoAnterior.Importe = tarjeta + deposito + cheque + efectivoCajaAnterior + transferencia;
                cajaMovimientoAnterior.ImpFac = (decimal?)ucTotalesCompraSeña1.SubTotal;
               
                cajaMovimientoAnterior.FechaModificacion = _clock.Now;
                cajaMovimientoAnterior.PcAlta = System.Environment.MachineName;
                cajaMovimientoAnterior.OperadorAltaId = Context.OperadorActual.Id;
                cajaMovimientoAnterior.SucursalAltaId = Context.SucursalActual.Id;
                cajaMovimientoAnterior.OperadorModificacionId = Context.OperadorActual.Id;
                cajaMovimientoAnterior.SucursalModificacionId = Context.SucursalActual.Id;
                cajaMovimientoAnterior.TipoComprobante = TipoComprobanteEnum.PagoProveedores;
                cajaMovimientoAnterior.Efectivo = efectivoCajaAnterior;
                cajaMovimientoAnterior.Tarjeta = tarjeta;
                cajaMovimientoAnterior.Deposito = deposito;
                
                cajaMovimientoAnterior.Cheque = cheque;
                cajaMovimientoAnterior.Transferencia = transferencia;

                //if (cheque > 0)
                //    cajaMovimientoAnterior.FechaAlta = tipo;
                //else
                    cajaMovimientoAnterior.FechaAlta = _clock.Now;


                cajaMovimientoAnterior.Senia = _seña + _credito + _egreso;
              
                Uow.CajaMovimientos.Agregar(cajaMovimientoAnterior);

                //Guardamos el movimiento del depósito
                foreach (var pago in ucTotalesCompraSeña1.Pagos)
                {
                    switch (pago.TipoPago)
                    {
                        case FormaPago.Cheque:
                            // HACER ALGO
                            break;

                        case FormaPago.Deposito:
                            var pagoDeposito = pago as VentaPagoDeposito;

                            CuentasMovimiento cuentasMovimiento = new CuentasMovimiento();
                            cuentasMovimiento.CuentaId = pagoDeposito.CuentaId ?? 0;
                            cuentasMovimiento.TipoMovimientoId = 1;//Deposito a proveedor
                            cuentasMovimiento.FechaMovimiento = pagoDeposito.Fecha;
                            cuentasMovimiento.EstadoMovimientoCuentaId = 0;

                            //CONTROLAR!!
                            cuentasMovimiento.TipoComprobanteId = TipoComprobanteEnum.PagoProveedores;

                            //le paso guid empty pero hay que ver que se le pasa
                            cuentasMovimiento.ComprobanteId = Guid.Empty;
                            cuentasMovimiento.MonedaId = 0;
                            cuentasMovimiento.NroMovimiento = pagoDeposito.Numero;
                            cuentasMovimiento.Descripcion = "DEPOSITO NRO " + pagoDeposito.Numero.ToString();
                            cuentasMovimiento.FechaCobro = _clock.Now;
                            cuentasMovimiento.Debito = pago.Importe;
                            cuentasMovimiento.Credito = 0;
                            cuentasMovimiento.TipoCarga = 1;
                            cuentasMovimiento.CajaId = caja.Id;
                            cuentasMovimiento.FechaAlta = _clock.Now;
                            cuentasMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                            cuentasMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                            Uow.CuentasMovimientos.Agregar(cuentasMovimiento);
                            break;

                        case FormaPago.Transferencia:
                            var pagoTransferencia = pago as VentaPagoTransferencia;

                            CuentasMovimiento cuentasMovimientoTransferecia = new CuentasMovimiento();
                            cuentasMovimientoTransferecia.CuentaId = pagoTransferencia.CuentaId ?? 0;
                            cuentasMovimientoTransferecia.TipoMovimientoId = 1;//Deposito a proveedor
                            cuentasMovimientoTransferecia.FechaMovimiento = pagoTransferencia.Fecha;
                            cuentasMovimientoTransferecia.EstadoMovimientoCuentaId = 0;

                            //CONTROLAR!!
                            cuentasMovimientoTransferecia.TipoComprobanteId = TipoComprobanteEnum.PagoProveedores;
                            //le paso guid empty pero hay que ver que se le pasa
                            cuentasMovimientoTransferecia.ComprobanteId = Guid.Empty;
                            cuentasMovimientoTransferecia.MonedaId = 0;
                            cuentasMovimientoTransferecia.NroMovimiento = pagoTransferencia.Numero;
                            cuentasMovimientoTransferecia.Descripcion = "TRANSFERENCIA NRO " + pagoTransferencia.Numero.ToString();
                            cuentasMovimientoTransferecia.FechaCobro = _clock.Now;
                            cuentasMovimientoTransferecia.Debito = pago.Importe;
                            cuentasMovimientoTransferecia.Credito = 0;
                            cuentasMovimientoTransferecia.TipoCarga = 1;
                            cuentasMovimientoTransferecia.CajaId = caja.Id;
                            cuentasMovimientoTransferecia.FechaAlta = _clock.Now;
                            cuentasMovimientoTransferecia.OperadorAltaId = Context.OperadorActual.Id;
                            cuentasMovimientoTransferecia.SucursalAltaId = Context.SucursalActual.Id;

                            Uow.CuentasMovimientos.Agregar(cuentasMovimientoTransferecia);
                            break;
                    }
                }

            }


            Uow.Cajas.Modificar(caja);

            #endregion



            Uow.Commit();

            _messageBoxDisplayService.ShowSuccess(Resources.MessageSuccessPagoExitoso);

        }
        private void RealizarSenia()
        {
            try
            {
                Caja caja = this.Context.CajaActual;

                ProveedorSenia seña = new ProveedorSenia();

                seña.Id = Guid.NewGuid();
                seña.ProveedorId = _proveedor.Id;
                seña.FechaAlta = _clock.Now;
                seña.FechaModificacion = _clock.Now;
                seña.Importe = UcTotalesSeña.TotalPagar;
                seña.ImporteUsado = 0;
                seña.OperadorAltaId = Context.OperadorActual.Id;
                seña.SucursalAltaId = Context.SucursalActual.Id;
                seña.OperadorModificacionId = Context.OperadorActual.Id;
                seña.SucursalModificacionId = Context.SucursalActual.Id;

                decimal? efectivo = 0;
                decimal? tarjeta = 0;
                decimal? cheque = 0;
                decimal? deposito = 0;

                foreach (var pago in UcTotalesSeña.Pagos)
                {
                    switch (pago.TipoPago)
                    {
                        case FormaPago.Efectivo:
                            efectivo += pago.Importe;
                            break;

                        case FormaPago.Tarjeta:
                            tarjeta += pago.Importe;
                            break;

                        case FormaPago.Cheque:
                            cheque += pago.Importe;
                            break;

                        case FormaPago.Deposito:
                            deposito += pago.Importe;
                            break;
                    }
                }

                if (efectivo > 0 && ChkCajaAnterior.Checked == false)
                {
                    //creo la caja movimiento para los pagos en efectivo que tocan la caja actual
                    CajaMovimiento cajaMovimiento = new CajaMovimiento();

                    cajaMovimiento.Id = Guid.NewGuid();
                    cajaMovimiento.CajaId = caja.Id;
                    cajaMovimiento.TipoComprobante = TipoComprobanteEnum.SeñaProveedor;
                    cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.SeñaProveedor;

                    cajaMovimiento.ComprobanteId = seña.Id;
                    cajaMovimiento.Importe = efectivo;
                    cajaMovimiento.FechaAlta = _clock.Now;
                    cajaMovimiento.FechaModificacion = _clock.Now;
                    cajaMovimiento.PcAlta = System.Environment.MachineName;
                    cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                    cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;
                    cajaMovimiento.OperadorModificacionId = Context.OperadorActual.Id;
                    cajaMovimiento.SucursalModificacionId = Context.SucursalActual.Id;

                    //descontar de la caja
                    if (caja.Egresos == null)
                        caja.Egresos = 0;

                    if (ChkCajaAnterior.Checked == false)
                        caja.Egresos += (float?)efectivo;

                    if (caja.Saldo == null)
                        caja.Saldo = 0;

                    caja.Saldo -= (float?)efectivo;

                    caja.FechaModificacion = _clock.Now;
                    caja.SucursalModificacionId = Context.SucursalActual.Id;//Sucursal del operador
                    caja.OperadorModificacionId = (Context.OperadorActual.Id);//Id el operador

                    //traer la caja
                    if (cajaMovimiento.Efectivo == null)
                        cajaMovimiento.Efectivo = 0;

                    cajaMovimiento.Cheque = cheque;
                    cajaMovimiento.Tarjeta = tarjeta;
                    cajaMovimiento.Deposito = deposito;
                    cajaMovimiento.Efectivo = efectivo;
                    efectivo = 0;

                    Uow.CajaMovimientos.Agregar(cajaMovimiento);
                }

                if (tarjeta > 0 || deposito > 0 || cheque > 0 || efectivo > 0)
                {
                    //creo la caja movimiento para los pagos en efectivo que tocan la caja actual
                    CajaMovimiento cajaMovimientoAnterior = new CajaMovimiento();

                    cajaMovimientoAnterior.Id = Guid.NewGuid();
                    cajaMovimientoAnterior.CajaId = caja.Id;
                    cajaMovimientoAnterior.TipoComprobante = TipoComprobanteEnum.SeñaProveedor;
                    cajaMovimientoAnterior.TipoMovimientoCajaId = TipoMovimientoCajaEnum.SeñaProveedorCajaAnterior;
                    cajaMovimientoAnterior.ComprobanteId = seña.Id;
                    cajaMovimientoAnterior.Importe = tarjeta + deposito + cheque + efectivo;
                    cajaMovimientoAnterior.FechaAlta = _clock.Now;
                    cajaMovimientoAnterior.FechaModificacion = _clock.Now;
                    cajaMovimientoAnterior.PcAlta = System.Environment.MachineName;
                    cajaMovimientoAnterior.OperadorAltaId = Context.OperadorActual.Id;
                    cajaMovimientoAnterior.SucursalAltaId = Context.SucursalActual.Id;
                    cajaMovimientoAnterior.OperadorModificacionId = Context.OperadorActual.Id;
                    cajaMovimientoAnterior.SucursalModificacionId = Context.SucursalActual.Id;

                    if (efectivo > 0)
                    {
                        if (cajaMovimientoAnterior.Efectivo == null)
                            cajaMovimientoAnterior.Efectivo = 0;

                        cajaMovimientoAnterior.Efectivo += efectivo;

                        cajaMovimientoAnterior.Cheque += cheque;
                        cajaMovimientoAnterior.Tarjeta += tarjeta;
                        cajaMovimientoAnterior.Deposito += deposito;

                        if (caja.Saldo == null)
                            caja.Saldo = 0;
                        caja.Saldo -= (float?)efectivo;
                    }

                    if (tarjeta > 0)
                    {
                        if (cajaMovimientoAnterior.Tarjeta == null)
                            cajaMovimientoAnterior.Tarjeta = 0;

                        cajaMovimientoAnterior.Tarjeta += tarjeta;
                    }

                    if (cheque > 0)
                    {
                        if (cajaMovimientoAnterior.Cheque == null)
                            cajaMovimientoAnterior.Cheque = 0;

                        cajaMovimientoAnterior.Cheque += cheque;
                    }

                    if (deposito > 0)
                    {
                        if (cajaMovimientoAnterior.Deposito == null)
                            cajaMovimientoAnterior.Deposito = 0;

                        cajaMovimientoAnterior.Deposito += deposito;
                    }

                    Uow.CajaMovimientos.Agregar(cajaMovimientoAnterior);
                }


                Uow.Cajas.Modificar(caja);

                Uow.ProveedoresSenias.Agregar(seña);

                Uow.Commit();

                _messageBoxDisplayService.ShowSuccess(Resources.MessageSuccessSeniaExitosa);
            }
            catch (Exception)
            {
                throw;
            }
        }
Пример #6
0
        private void BtnGuardar_Click(object sender, EventArgs e)
        {
            if (Monto != ucTotalesSeña.TotalPagar)
            {
                _messageBoxDisplayService.ShowError("Los montos no coinciden");
                return;
            }

            Guid operadorAutoriza = Guid.Empty;

            if (_formMode == ActionFormMode.Edit)
            {

                //////Autorizacion para sin movimiento
                var operador = this.ObtenerOperadorAdministrador();

                if (operador == null)
                {
                    return;
                }

                if (!this.EsOperadorAdmin)
                {
                    //Guardamos el operador que autorizo la operacion.
                    operadorAutoriza = operador.Id;
                }

            }
            ////////////////////////////////




            //TODO: Reemplzar el numero cuando se agrege la columna a sucursal.
            int numeroDeSucursal = 1;

            ClienteMontoFavor clienteMontoFavor = new ClienteMontoFavor();
            clienteMontoFavor.Id = Guid.NewGuid();
            clienteMontoFavor.ClienteId = _cliente.Id;
            clienteMontoFavor.FechaComprobante = _clock.Now;
            clienteMontoFavor.TipoComprobanteId = TipoComprobanteEnum.SeñaCliente;
            clienteMontoFavor.LCN = "R" + numeroDeSucursal.ToString().PadLeft(4, '0') + CalcularLCN().PadLeft(8, '0');
            clienteMontoFavor.Concepto = "Seña " + clienteMontoFavor.LCN;
            clienteMontoFavor.Importe = ucTotalesSeña.TotalPagar;
            clienteMontoFavor.ImpOcupado = 0;
            clienteMontoFavor.Observaciones = TipoComprobanteEnum.SeñaCliente.ToString();
            clienteMontoFavor.FechaAlta = _clock.Now;
            clienteMontoFavor.OperadorAltaId = Context.OperadorActual.Id;
            clienteMontoFavor.SucursalAltaId = Context.SucursalActual.Id;
            if (operadorAutoriza != Guid.Empty)
                clienteMontoFavor.OperadorAutoriza = operadorAutoriza;

            Uow.ClientesMontosFavor.Agregar(clienteMontoFavor);

            //Si el Form=Editar significa que es SinGuardar los movimientos de caja
            if (_formMode == ActionFormMode.Create)
            {
                //ActualizarCaja y CajaMovimiento
                Caja caja = this.Context.CajaActual;
                if (caja.Egresos == null)
                    caja.Egresos = 0;
                caja.Ingresos += (float?)ucTotalesSeña.TotalPagar;
                caja.Saldo += (float?)ucTotalesSeña.TotalPagar;
                caja.FechaModificacion = _clock.Now;
                caja.SucursalModificacionId = 2;//Sucursal del operador
                caja.OperadorModificacionId = (Context.OperadorActual.Id);//Id el operador

                Uow.Cajas.Modificar(caja);

                CajaMovimiento cajaMovimiento = new CajaMovimiento();
                cajaMovimiento.Id = Guid.NewGuid();
                cajaMovimiento.CajaId = caja.Id;
                cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.SeñaCliente;
                cajaMovimiento.TipoComprobante = TipoComprobanteEnum.SeñaCliente;
                cajaMovimiento.ComprobanteId = clienteMontoFavor.Id;
                cajaMovimiento.Importe = ucTotalesSeña.TotalPagar;
                cajaMovimiento.FechaAlta = _clock.Now;
                cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;
                cajaMovimiento.PcAlta = Environment.MachineName;
                //tipos de pagos
                foreach (VentaPago pago in ucTotalesSeña.Pagos)
                {
                    switch (pago.TipoPago)
                    {
                        case FormaPago.Efectivo:
                            cajaMovimiento.Efectivo = pago.Importe;
                            break;
                        case FormaPago.Tarjeta:
                            var pagoTarjeta = pago as VentaPagoTarjeta;
                            if (cajaMovimiento.Tarjeta == null)
                                cajaMovimiento.Tarjeta = 0;

                            cajaMovimiento.Tarjeta += pago.Importe;
                            //GUARDAR TARJETA MOVIMIENTO 
                            TarjetasMovimiento tarjetasMovimiento = new TarjetasMovimiento();
                            tarjetasMovimiento.CajaMovimientoId = cajaMovimiento.Id;
                            tarjetasMovimiento.TarjetaId = pagoTarjeta.TarjetaId ?? 0;
                            tarjetasMovimiento.LoteCupon = pagoTarjeta.CuponNumero;
                            tarjetasMovimiento.Fecha = _clock.Now;
                            tarjetasMovimiento.Importe = (float)pago.Importe;
                            tarjetasMovimiento.Estado = 1; // No se 
                            tarjetasMovimiento.FechaAlta = _clock.Now;
                            tarjetasMovimiento.SucursalAltaId = Context.SucursalActual.Id; //Sucursal del operador
                            tarjetasMovimiento.OperadorAltaId = (Context.OperadorActual.Id); //Id el operador

                            Uow.TarjetasMovimientos.Agregar(tarjetasMovimiento);
                            break;
                        case FormaPago.Cheque:
                            var pagoCheque = pago as VentaPagoCheque;

                            if (cajaMovimiento.Cheque == null)
                                cajaMovimiento.Cheque = 0;

                            cajaMovimiento.Cheque += pago.Importe;

                            ChequesTercero chequesTercero = new ChequesTercero();
                            chequesTercero.Id = Guid.NewGuid();
                            chequesTercero.CajaMovimientoId = cajaMovimiento.Id;
                            chequesTercero.BancoId = pagoCheque.BancoId ?? 0;
                            chequesTercero.NroCheque = pagoCheque.Numero;
                            chequesTercero.Fecha = _clock.Now;
                            chequesTercero.FechaCobro = _clock.Now;
                            chequesTercero.Importe = (float)pago.Importe;
                            chequesTercero.FechaAlta = _clock.Now;
                            chequesTercero.SucursalAltaId = Context.SucursalActual.Id;
                            chequesTercero.OperadorAltaId = (Context.OperadorActual.Id);

                            Uow.ChequesTerceros.Agregar(chequesTercero);
                            break;
                        case FormaPago.Deposito:
                            var pagoDeposito = pago as VentaPagoDeposito;
                            if (cajaMovimiento.Deposito == null)
                                cajaMovimiento.Deposito = 0;

                            //Guardar Cuentas Movimientos
                            cajaMovimiento.Deposito += pago.Importe;

                            CuentasMovimiento cuentasMovimiento = new CuentasMovimiento();
                            cuentasMovimiento.CuentaId = pagoDeposito.CuentaId;
                            cuentasMovimiento.TipoMovimientoId = 2; //Deposito
                            cuentasMovimiento.FechaMovimiento = pagoDeposito.Fecha;
                            cuentasMovimiento.EstadoMovimientoCuentaId = 0;
                            cuentasMovimiento.TipoComprobanteId = TipoComprobanteEnum.SeñaCliente;
                            cuentasMovimiento.ComprobanteId = clienteMontoFavor.Id;
                            cuentasMovimiento.MonedaId = 0;
                            cuentasMovimiento.CondicionVentaId = CondicionVentaEnum.Contado;
                            cuentasMovimiento.NroMovimiento = pagoDeposito.Numero;
                            cuentasMovimiento.Descripcion = "DEPOSITO NRO " + pagoDeposito.Numero.ToString();
                            cuentasMovimiento.FechaCobro = _clock.Now;
                            cuentasMovimiento.Debito = 0;
                            cuentasMovimiento.Credito = pago.Importe;
                            cuentasMovimiento.TipoCarga = 2;
                            cuentasMovimiento.CajaId = caja.Id;
                            cuentasMovimiento.FechaAlta = _clock.Now;
                            cuentasMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                            cuentasMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                            Uow.CuentasMovimientos.Agregar(cuentasMovimiento);
                            break;

                    }
                }

                Uow.CajaMovimientos.Agregar(cajaMovimiento);
            }


            Uow.Commit();
            _messageBoxDisplayService.ShowSuccess("Seña generada con éxito");

            //Si el Form=Editar significa que es SinGuardar los movimientos de caja
            if (_formMode == ActionFormMode.Create)
            {
                var crearSenia = FormFactory.Create<FrmComprobante>();
                crearSenia._concepto = "Seña de Cliente";
                crearSenia._LCN = clienteMontoFavor.LCN;
                var conv = new Conversion();

                crearSenia._montoTexto = conv.enletras(ucTotalesSeña.TotalPagar.ToString());
                //crearSenia._montoTexto = "cien";
                crearSenia.Show();
            }

            BuscarHistorial();
            Limpiar();
        }
Пример #7
0
        private void ProcesarPagoCheque(VentaDataBase ventaData, VentaPago pago, CajaMovimiento cajaMovimiento)
        {
            var pagoCheque = pago as VentaPagoCheque;

            if (cajaMovimiento.Cheque == null)
                cajaMovimiento.Cheque = 0;

            cajaMovimiento.Cheque += pago.Importe;

            ChequesTercero chequesTercero = new ChequesTercero();
            chequesTercero.Id = Guid.NewGuid();
            chequesTercero.CajaMovimientoId = cajaMovimiento.Id;
            chequesTercero.BancoId = pagoCheque.BancoId ?? 0;
            chequesTercero.NroCheque = pagoCheque.Numero;
            chequesTercero.Fecha = _clock.Now;
            chequesTercero.FechaCobro = _clock.Now;
            chequesTercero.Importe = (float)pago.Importe;
            chequesTercero.FechaAlta = _clock.Now;
            chequesTercero.EstadoChequeId = 0;
            chequesTercero.SucursalAltaId = ventaData.SucursalId;
            chequesTercero.OperadorAltaId = ventaData.OperadorId;

            Uow.ChequesTerceros.Agregar(chequesTercero);
        }
Пример #8
0
 private void ActualizarCajaActual(OrdenesPagoDetalle pago, CajaMovimiento movimiento, Caja caja)
 {
     movimiento.Efectivo = pago.Efectivo;
     caja.Egresos += (float)(pago.Efectivo ?? 0);
     caja.Saldo -= (float)(pago.Efectivo ?? 0);
     caja.FechaModificacion = pago.Id == default(Guid) ? (DateTime?)null : _clock.Now;
     caja.SucursalModificacionId = pago.Id == default(Guid)
                                       ? (int?)null
                                       : _context.SucursalActual.Id;
     caja.OperadorModificacionId = pago.Id == default(Guid)
                                       ? (Guid?)null
                                       : _context.OperadorActual.Id;
     _uow.Cajas.Modificar(caja);
 }
Пример #9
0
        public void AnularSeniaProveedor(ProveedorSenia senia, Caja caja, Guid operadorId, int sucursalId)
        {
            using (var uow = UowFactory.Create<ILaPazUow>())
            {
                var diferencia = senia.Importe - senia.ImporteUsado;
                if (diferencia == 0)
                    return;

                senia.ImporteUsado = senia.Importe;
                senia.FechaAnulacion = _clock.Now;
                senia.FechaModificacion = _clock.Now;
                senia.OperadorModificacionId = operadorId;
                senia.SucursalModificacionId = sucursalId;

                uow.ProveedoresSenias.Modificar(senia);

                if (caja.Ingresos == null)
                    caja.Ingresos = 0;
                caja.Egresos += (float?)diferencia;
                if (caja.Saldo == null)
                    caja.Saldo = 0;
                caja.Saldo -= (float?)diferencia;
                caja.FechaModificacion = _clock.Now;
                caja.SucursalModificacionId = sucursalId;
                caja.OperadorModificacionId = operadorId;

                uow.Cajas.Modificar(caja);

                //Se deben buscar todas las cajasMovimientos
                var cajaMovimientoAnterior = uow.CajaMovimientos.Listado().Where(cm => cm.ComprobanteId == senia.Id);
                foreach (CajaMovimiento movimiento in cajaMovimientoAnterior)
                {
                    CajaMovimiento cajaMovimiento = new CajaMovimiento();
                    cajaMovimiento.Id = Guid.NewGuid();
                    cajaMovimiento.CajaId = caja.Id;
                    cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.AnulacionSeniaProveedor;
                    cajaMovimiento.TipoComprobante = TipoComprobanteEnum.SeñaCliente;
                    cajaMovimiento.ComprobanteId = senia.Id;
                    cajaMovimiento.Senia = 0;
                    //analizar para Anulaciones Parciales
                    cajaMovimiento.Importe = movimiento.Importe;
                    cajaMovimiento.Efectivo = movimiento.Efectivo;
                    cajaMovimiento.Tarjeta = movimiento.Tarjeta;
                    cajaMovimiento.Cheque = movimiento.Cheque;
                    cajaMovimiento.Deposito = movimiento.Deposito;
                    cajaMovimiento.ImpFac = 0;
                    cajaMovimiento.PcAlta = Environment.MachineName;
                    cajaMovimiento.SucursalAltaId = sucursalId;
                    cajaMovimiento.OperadorAltaId = operadorId;
                    cajaMovimiento.FechaAlta = _clock.Now;
                    uow.CajaMovimientos.Agregar(cajaMovimiento);
                }

                uow.Commit();
            }
        }
        private void GenerarClienteMontoFavor()
        {
            //TODO:Agregar el numero de sucursal a la tabla el mismo no coincide con el id.
            int numeroDeSucursal = Context.SucursalActual.SucursalNumero ?? 1;// 1;
            
            ClienteMontoFavor clienteMontoFavor = new ClienteMontoFavor();

            clienteMontoFavor.Id = Guid.NewGuid();
            _notaCreditoId = clienteMontoFavor.Id;
            clienteMontoFavor.OperadorAutoriza = _operadorIdAutoriza;
            clienteMontoFavor.ClienteId = _venta.ClienteId;
            clienteMontoFavor.FechaComprobante = _clock.Now;
            clienteMontoFavor.TipoComprobanteId = TipoComprobanteEnum.NotaCrédito;
            clienteMontoFavor.LCN = "R" + numeroDeSucursal.ToString().PadLeft(4, '0') + CalcularLCN().PadLeft(8, '0');
            _lcn = clienteMontoFavor.LCN;
            clienteMontoFavor.Concepto = "Nota de crédito " + clienteMontoFavor.LCN;
            clienteMontoFavor.Importe = Total;
            clienteMontoFavor.ImpOcupado = 0;
            clienteMontoFavor.Observaciones = TipoComprobanteEnum.NotaCrédito.ToString();
            clienteMontoFavor.FechaAlta = _clock.Now;
            clienteMontoFavor.OperadorAltaId = Context.OperadorActual.Id;
            clienteMontoFavor.SucursalAltaId = Context.SucursalActual.Id;

            Uow.ClientesMontosFavor.Agregar(clienteMontoFavor);

            foreach (VentaDetalleDevolucion devuleto in Devuletos)
            {
                ClientesMontosFavorDetalle clientesMontosAfavorDetalle = new ClientesMontosFavorDetalle();
                clientesMontosAfavorDetalle.Id = Guid.NewGuid();
                clientesMontosAfavorDetalle.ClientesMontosFavorId = clienteMontoFavor.Id;
                clientesMontosAfavorDetalle.TitulosId = devuleto.TituloId;
                clientesMontosAfavorDetalle.CantidadPropia = devuleto.CantidadPropia;
                clientesMontosAfavorDetalle.CantidadConsig = devuleto.CantidadConsignada;
                clientesMontosAfavorDetalle.FechaAlta = _clock.Now;
                clientesMontosAfavorDetalle.SucursalAltaId = Context.SucursalActual.Id;
                clientesMontosAfavorDetalle.OperadorAltaId = Context.OperadorActual.Id;

                Uow.ClientesMontosFavorDetalles.Agregar(clientesMontosAfavorDetalle);
            }

            var cajaMovimientoAnterior = Uow.CajaMovimientos.Obtener(cm => cm.ComprobanteId == _venta.Id);
            var montoDevolucion = Total;

            CajaMovimiento cajaMovimiento = new CajaMovimiento();
            cajaMovimiento.Id = Guid.NewGuid();
            cajaMovimiento.CajaId = this.Context.CajaActual.Id;
            cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.CreditoFavorPorNc;
            cajaMovimiento.TipoComprobante = TipoComprobanteEnum.NotaCrédito;
            cajaMovimiento.ComprobanteId = clienteMontoFavor.Id;
            cajaMovimiento.Importe = Total;
            cajaMovimiento.ImpFac = Total;
            cajaMovimiento.Efectivo = cajaMovimientoAnterior.Efectivo >= montoDevolucion ? montoDevolucion : cajaMovimientoAnterior.Efectivo;
            montoDevolucion -= cajaMovimiento.Efectivo;
            if (montoDevolucion > 0)
            {
                cajaMovimiento.Tarjeta = (cajaMovimientoAnterior.Tarjeta >= montoDevolucion) ? montoDevolucion : cajaMovimientoAnterior.Tarjeta;
                montoDevolucion -= cajaMovimiento.Tarjeta;
            }
            if (montoDevolucion > 0)
            {
                cajaMovimiento.Cheque = (cajaMovimientoAnterior.Cheque >= montoDevolucion ? montoDevolucion : cajaMovimientoAnterior.Cheque);
                montoDevolucion -= cajaMovimiento.Cheque;
            }
            if (montoDevolucion > 0)
            {
                cajaMovimiento.Deposito = (cajaMovimientoAnterior.Deposito >= montoDevolucion ? montoDevolucion : cajaMovimientoAnterior.Deposito);
                montoDevolucion -= cajaMovimiento.Deposito;
            }
            if (montoDevolucion > 0)
            {
                cajaMovimiento.Transferencia = (cajaMovimientoAnterior.Transferencia >= montoDevolucion ? montoDevolucion : cajaMovimientoAnterior.Transferencia);
                montoDevolucion -= cajaMovimiento.Transferencia;
            }
            cajaMovimiento.FechaAlta = _clock.Now;
            cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
            cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;

            Uow.CajaMovimientos.Agregar(cajaMovimiento);
        }
Пример #11
0
        public void AgregarMovimientos(OrdenesPago ordenPago, OrdenesPagoDetalle pago, DetalleFormaPago vPago)
        {
            var movimiento = new CajaMovimiento();
            var movimientoAnterior = new CajaMovimiento();
            if (vPago.IsDeleted)
                movimientoAnterior = _uow.CajaMovimientos.Obtener(c => c.ComprobanteId == ordenPago.Id);

            movimiento.Id = Guid.NewGuid();
            movimiento.Importe = pago.ImportePagado;
            movimiento.ComprobanteId = ordenPago.Id;
            movimiento.TipoComprobante = TipoComprobanteEnum.OrdenPago;
            movimiento.TipoMovimientoCajaId = vPago.IsDeleted ? movimientoAnterior.TipoMovimientoCajaId : TipoMovimientoCajaEnum.PagoGastos;
            //movimiento.TipoMovimientoCajaId = vPago.IsDeleted ? TipoMovimientoCajaEnum.AnulaciónOrdenPago : TipoMovimientoCajaEnum.PagoGastos;
            movimiento.PcAlta = Environment.MachineName;
            movimiento.CajaId = _cajaActual.Id;

            if (pago.Efectivo.HasValue && pago.Efectivo != 0)
            {
                //Si ImportePagado <> 0 => Pago Normal en Efectivo
                //Si ImportePagado = 0 => Pago Programado
                if (pago.ImportePagado.HasValue && pago.ImportePagado != 0)
                {
                    var pagoEfec = vPago as PagoEfectivo;

                    if (pagoEfec.CajaAnterior)
                    {
                        ActualizarCajaAnterior(ordenPago, pagoEfec, _cajaActual, movimiento);
                    }
                    else
                    {
                        ActualizarCajaActual(pago, movimiento, _cajaActual);
                    }

               }

                movimiento.Efectivo = pago.Efectivo;
            }

            if (pago.Cheques.HasValue && (pago.Cheques > 0 || pago.Cheques < 0))
            {
                movimiento.Cheque = pago.Cheques;
            }

            if (pago.DepositoEfectivo.HasValue && (pago.DepositoEfectivo > 0 || pago.DepositoEfectivo < 0))
            {
                movimiento.Deposito = pago.DepositoEfectivo;
            }

            if (pago.Transferencia.HasValue && (pago.Transferencia > 0 || pago.Transferencia < 0))
            {
                movimiento.Transferencia = pago.Transferencia;
            }

         //   movimiento.FechaAlta = pago.Id == default(Guid) ? _clock.Now : pago.FechaAlta;

            movimiento.FechaAlta = DateTime.Now;// pago.Id == default(Guid) ? _clock.Now : pago.FechaAlta;


            movimiento.SucursalAltaId = _context.SucursalActual.Id;
            movimiento.OperadorAltaId = _context.OperadorActual.Id;

            _uow.CajaMovimientos.Agregar(movimiento);
        }
        private void ActualizarCaja()
        {
            //ActualizarCaja y CajaMovimiento
            Caja caja = this.Context.CajaActual;
            if (caja.Egresos == null)
                caja.Egresos = 0;
            caja.Egresos += (float?)Total;
            caja.Saldo -= (float?)Total;
            caja.FechaModificacion = _clock.Now;
            caja.SucursalModificacionId = Context.SucursalActual.Id;//Sucursal del operador
            caja.OperadorModificacionId = (Context.OperadorActual.Id);//Id el operador

            Uow.Cajas.Modificar(caja);

            CajaMovimiento cajaMovimiento = new CajaMovimiento();
            cajaMovimiento.Id = Guid.NewGuid();
            cajaMovimiento.CajaId = caja.Id;
            cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.NotaCredito;
            cajaMovimiento.TipoComprobante = TipoComprobanteEnum.NotaCrédito;
            cajaMovimiento.ComprobanteId = _venta.Id;
            cajaMovimiento.Importe = Total;
            cajaMovimiento.ImpFac = Total;
            cajaMovimiento.Efectivo = Total;
            cajaMovimiento.FechaAlta = _clock.Now;
            cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
            cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;

            Uow.CajaMovimientos.Agregar(cajaMovimiento);
        }
Пример #13
0
        private CajaMovimiento CrearCajaMovimiento(VentaDataBase ventaData, Caja caja, Venta venta)
        {
            CajaMovimiento cajaMovimiento = new CajaMovimiento();
            cajaMovimiento.Id = Guid.NewGuid();
            cajaMovimiento.CajaId = caja.Id;
            cajaMovimiento.TipoMovimientoCajaId = ventaData.TipoCajaMovimientoSeleccionado;
            cajaMovimiento.TipoComprobante = ventaData.TipoComprobanteSeleccionado;
            cajaMovimiento.ComprobanteId = venta.Id;
            cajaMovimiento.Senia = ventaData.Senas + ventaData.CreditosDevolucion;
            if (ventaData.CondicionVentaSeleccionada == CondicionVentaEnum.CuentaCorriente)
                cajaMovimiento.Importe = ventaData.Anticipo;
            else
                cajaMovimiento.Importe = ventaData.TotalPagar;

            cajaMovimiento.ImpFac = ventaData.SubTotal;
            
            //if (ventaData.CondicionVentaSeleccionada == CondicionVentaEnum.CuentaCorriente)
            //    cajaMovimiento.ImpFac = ventaData.SubTotal;
            //else
            //    cajaMovimiento.ImpFac = ventaData.TotalPagar;


            cajaMovimiento.PcAlta = ventaData.PcAlta;
            cajaMovimiento.SucursalAltaId = ventaData.SucursalId;
            cajaMovimiento.OperadorAltaId = ventaData.OperadorId;
            cajaMovimiento.FechaAlta = _clock.Now;

            return cajaMovimiento;
        }
Пример #14
0
        private void ProcesarPagoTarjeta(VentaDataBase ventaData, VentaPago pago, CajaMovimiento cajaMovimiento)
        {
            var pagoTarjeta = pago as VentaPagoTarjeta;
            if (cajaMovimiento.Tarjeta == null)
                cajaMovimiento.Tarjeta = 0;

            cajaMovimiento.Tarjeta += pago.Importe;
            //GUARDAR TARJETA MOVIMIENTO 
            TarjetasMovimiento tarjetasMovimiento = new TarjetasMovimiento();
            tarjetasMovimiento.CajaMovimientoId = cajaMovimiento.Id;
            tarjetasMovimiento.TarjetaId = pagoTarjeta.TarjetaId ?? 0;
            tarjetasMovimiento.LoteCupon = pagoTarjeta.CuponNumero;
            tarjetasMovimiento.Fecha = _clock.Now;
            tarjetasMovimiento.Importe = (float)pago.Importe;
            tarjetasMovimiento.Estado = 1; // No se 
            tarjetasMovimiento.FechaAlta = _clock.Now;
            tarjetasMovimiento.SucursalAltaId = ventaData.SucursalId;
            tarjetasMovimiento.OperadorAltaId = ventaData.OperadorId;

            Uow.TarjetasMovimientos.Agregar(tarjetasMovimiento);
        }
        private void ActualizarCajaAnterior(PagoEfectivo pagoEfec, Caja caja, CajaMovimiento cajaMovimiento)
        {
            cajaMovimiento.CajaId = caja.Id;
            cajaMovimiento.TipoComprobante = TipoComprobanteEnum.OrdenPago;
            cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.DepositoConCajaAnterior;
            cajaMovimiento.ComprobanteId = _ordenPago.Id;
            cajaMovimiento.Importe = pagoEfec.Importe;

            if (cajaMovimiento.Efectivo == null)
                cajaMovimiento.Efectivo = 0;

            cajaMovimiento.Efectivo = pagoEfec.Importe;

            if (caja.Saldo == null)
                caja.Saldo = 0;

            //Pago Efectivo para Caja Anterior solo se Modifica el Saldo Acumulado
            caja.Saldo -= (float?)pagoEfec.Importe;
        }
Пример #16
0
        public void CrearSeniaProveedor(ProveedorSenia senia, IList<VentaPago> pagos, Caja caja, Guid operadorId, int sucursalId)
        {
            using (var uow = UowFactory.Create<ILaPazUow>())
            {
                decimal? efectivo = 0;
                decimal? efectivoCajaAnterior = 0;
                decimal? tarjeta = 0;
                decimal? cheque = 0;
                decimal? deposito = 0;
                decimal? transferencia = 0;

                foreach (var pago in pagos)
                {
                    switch (pago.TipoPago)
                    {
                        case FormaPago.Efectivo:
                            efectivo += pago.Importe;
                            break;

                        case FormaPago.EfectivoCajaAnterior:
                            efectivoCajaAnterior += pago.Importe;
                            break;

                        case FormaPago.Tarjeta:
                            tarjeta += pago.Importe;
                            break;

                        case FormaPago.Cheque:
                            cheque += pago.Importe;
                            break;

                        case FormaPago.Deposito:
                            deposito += pago.Importe;
                            break;

                        case FormaPago.Transferencia:
                            transferencia += pago.Importe;
                            break;
                    }
                }

                if (efectivo > 0)
                {
                    //creo la caja movimiento para los pagos en efectivo que tocan la caja actual
                    CajaMovimiento cajaMovimiento = new CajaMovimiento();

                    cajaMovimiento.Id = Guid.NewGuid();
                    cajaMovimiento.CajaId = caja.Id;
                    cajaMovimiento.TipoComprobante = TipoComprobanteEnum.SeñaProveedor;
                    cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.SeñaProveedor;

                    cajaMovimiento.ComprobanteId = senia.Id;
                    cajaMovimiento.Importe = efectivo;
                    cajaMovimiento.ImpFac = efectivo;
                    cajaMovimiento.FechaAlta = _clock.Now;
                    cajaMovimiento.FechaModificacion = _clock.Now;
                    cajaMovimiento.PcAlta = System.Environment.MachineName;
                    cajaMovimiento.OperadorAltaId = operadorId;
                    cajaMovimiento.SucursalAltaId = sucursalId;
                    cajaMovimiento.OperadorModificacionId = operadorId;
                    cajaMovimiento.SucursalModificacionId = sucursalId;

                    //descontar de la caja
                    if (caja.Egresos == null)
                        caja.Egresos = 0;

                    caja.Egresos += (float?)efectivo;

                    if (caja.Saldo == null)
                        caja.Saldo = 0;

                    caja.Saldo -= (float?)efectivo;

                    caja.FechaModificacion = _clock.Now;
                    caja.SucursalModificacionId = sucursalId;//Sucursal del operador
                    caja.OperadorModificacionId = (operadorId);//Id el operador

                    //traer la caja
                    if (cajaMovimiento.Efectivo == null)
                        cajaMovimiento.Efectivo = 0;

                    cajaMovimiento.Efectivo = efectivo;

                    uow.CajaMovimientos.Agregar(cajaMovimiento);
                }

                if (tarjeta > 0 || deposito > 0 || cheque > 0 || efectivoCajaAnterior > 0 || transferencia > 0)
                {
                    //creo la caja movimiento para los pagos en efectivo que tocan la caja actual
                    CajaMovimiento cajaMovimientoAnterior = new CajaMovimiento();

                    cajaMovimientoAnterior.Id = Guid.NewGuid();
                    cajaMovimientoAnterior.CajaId = caja.Id;
                    cajaMovimientoAnterior.TipoComprobante = TipoComprobanteEnum.SeñaProveedor;
                    cajaMovimientoAnterior.TipoMovimientoCajaId = TipoMovimientoCajaEnum.SeñaProveedorCajaAnterior;
                    cajaMovimientoAnterior.ComprobanteId = senia.Id;
                    cajaMovimientoAnterior.Importe = tarjeta + deposito + cheque + efectivoCajaAnterior + transferencia;
                    cajaMovimientoAnterior.ImpFac = tarjeta + deposito + cheque + efectivoCajaAnterior + transferencia;
                    cajaMovimientoAnterior.FechaAlta = _clock.Now;
                    cajaMovimientoAnterior.FechaModificacion = _clock.Now;
                    cajaMovimientoAnterior.PcAlta = System.Environment.MachineName;
                    cajaMovimientoAnterior.OperadorAltaId = operadorId;
                    cajaMovimientoAnterior.SucursalAltaId = sucursalId;
                    cajaMovimientoAnterior.OperadorModificacionId = operadorId;
                    cajaMovimientoAnterior.SucursalModificacionId = sucursalId;

                    if (efectivoCajaAnterior > 0)
                    {
                        if (cajaMovimientoAnterior.Efectivo == null)
                            cajaMovimientoAnterior.Efectivo = 0;

                        cajaMovimientoAnterior.Efectivo += efectivoCajaAnterior;

                        if (caja.Saldo == null)
                            caja.Saldo = 0;
                        caja.Saldo -= (float?)efectivo;
                    }

                    if (tarjeta > 0)
                    {
                        if (cajaMovimientoAnterior.Tarjeta == null)
                            cajaMovimientoAnterior.Tarjeta = 0;

                        cajaMovimientoAnterior.Tarjeta += tarjeta;
                    }

                    if (cheque > 0)
                    {
                        if (cajaMovimientoAnterior.Cheque == null)
                            cajaMovimientoAnterior.Cheque = 0;

                        cajaMovimientoAnterior.Cheque += cheque;
                    }

                    if (deposito > 0)
                    {
                        if (cajaMovimientoAnterior.Deposito == null)
                            cajaMovimientoAnterior.Deposito = 0;

                        cajaMovimientoAnterior.Deposito += deposito;
                    }

                    if (transferencia > 0)
                    {
                        if (cajaMovimientoAnterior.Transferencia == null)
                            cajaMovimientoAnterior.Transferencia = 0;

                        cajaMovimientoAnterior.Transferencia += transferencia;
                    }

                    uow.CajaMovimientos.Agregar(cajaMovimientoAnterior);
                }

                //Guardamos el movimiento del depósito
                foreach (var pago in pagos)
                {
                    switch (pago.TipoPago)
                    {
                        case FormaPago.Cheque:
                            // HACER ALGO
                            break;

                        case FormaPago.Deposito:
                            var pagoDeposito = pago as VentaPagoDeposito;

                            CuentasMovimiento cuentasMovimiento = new CuentasMovimiento();
                            cuentasMovimiento.CuentaId = pagoDeposito.CuentaId ?? 0;
                            cuentasMovimiento.TipoMovimientoId = 1;//Deposito a proveedor
                            cuentasMovimiento.FechaMovimiento = pagoDeposito.Fecha;
                            cuentasMovimiento.EstadoMovimientoCuentaId = 0;
                            cuentasMovimiento.TipoComprobanteId = TipoComprobanteEnum.SeñaProveedor;
                            cuentasMovimiento.ComprobanteId = senia.Id;
                            cuentasMovimiento.MonedaId = 0;
                            cuentasMovimiento.NroMovimiento = pagoDeposito.Numero;
                            cuentasMovimiento.Descripcion = "DEPOSITO SEÑA NRO " + pagoDeposito.Numero.ToString();
                            cuentasMovimiento.FechaCobro = _clock.Now;
                            cuentasMovimiento.Debito = pago.Importe;
                            cuentasMovimiento.Credito = 0;
                            cuentasMovimiento.TipoCarga = 1;
                            cuentasMovimiento.CajaId = caja.Id;
                            cuentasMovimiento.FechaAlta = _clock.Now;
                            cuentasMovimiento.OperadorAltaId = operadorId;
                            cuentasMovimiento.SucursalAltaId = sucursalId;

                            uow.CuentasMovimientos.Agregar(cuentasMovimiento);
                            break;

                        case FormaPago.Transferencia:
                            var pagoTransferencia = pago as VentaPagoTransferencia;

                            CuentasMovimiento cuentasMovimientoTransferecia = new CuentasMovimiento();
                            cuentasMovimientoTransferecia.CuentaId = pagoTransferencia.CuentaId ?? 0;
                            cuentasMovimientoTransferecia.TipoMovimientoId = 1;//Deposito a proveedor
                            cuentasMovimientoTransferecia.FechaMovimiento = pagoTransferencia.Fecha;
                            cuentasMovimientoTransferecia.EstadoMovimientoCuentaId = 0;
                            cuentasMovimientoTransferecia.TipoComprobanteId = TipoComprobanteEnum.SeñaProveedor;
                            cuentasMovimientoTransferecia.ComprobanteId = senia.Id;
                            cuentasMovimientoTransferecia.MonedaId = 0;
                            cuentasMovimientoTransferecia.NroMovimiento = pagoTransferencia.Numero;
                            cuentasMovimientoTransferecia.Descripcion = "TRANSFERENCIA SEÑA NRO " + pagoTransferencia.Numero.ToString();
                            cuentasMovimientoTransferecia.FechaCobro = _clock.Now;
                            cuentasMovimientoTransferecia.Debito = pago.Importe;
                            cuentasMovimientoTransferecia.Credito = 0;
                            cuentasMovimientoTransferecia.TipoCarga = 1;
                            cuentasMovimientoTransferecia.CajaId = caja.Id;
                            cuentasMovimientoTransferecia.FechaAlta = _clock.Now;
                            cuentasMovimientoTransferecia.OperadorAltaId = operadorId;
                            cuentasMovimientoTransferecia.SucursalAltaId = sucursalId;

                            uow.CuentasMovimientos.Agregar(cuentasMovimientoTransferecia);
                            break;
                    }
                }

                uow.Cajas.Modificar(caja);

                uow.ProveedoresSenias.Agregar(senia);

                uow.Commit();
            }
        }
        private void BtnGuardar_Click(object sender, EventArgs e)
        {
            if (_venta.EstadoVentaId == EstadoVentaEnum.Anulada)
            {
                _messageBoxDisplayService.ShowWarning("Factura ya anulada");
                return;
            }

            var operador = this.ObtenerOperadorAdministrador();

            if (operador == null)
            {
                return;
            }

            if (!this.EsOperadorAdmin)
            {
                //Guardamos el operador que autorizo la operacion.
                _venta.OperadorAutoriza = operador.Id;    
            }

            //Anular la Venta
            _venta.EstadoVentaId = EstadoVentaEnum.Anulada;
            _venta.FechaModificacion = _clock.Now;
            _venta.OperadorModificacionId = Context.OperadorActual.Id;
            _venta.SucursalModificacionId = Context.SucursalActual.Id;

            Uow.Ventas.Modificar(_venta);

            //devolver el stock
            foreach (VentaDetalleDto ventaDetalleDto in _ventaDetalleDto)
            {
                var tituloStock =
                    Uow.TitulosStock.Obtener(
                        ts => ts.TituloId == ventaDetalleDto.TituloId && ts.SucursalId == Context.SucursalActual.Id);

                tituloStock.StkPr += ventaDetalleDto.CantidadPropia;
                tituloStock.StkCn += ventaDetalleDto.CantidadConsig;
                tituloStock.FechaModificacion = _clock.Now;
                tituloStock.OperadorModificacionId = Context.OperadorActual.Id;
                tituloStock.SucursalModificacionId = Context.SucursalActual.Id;

                Uow.TitulosStock.Modificar(tituloStock);
            }

            //Devovler caja
            Caja caja = this.Context.CajaActual;
            if (caja.Ingresos == null)
                caja.Ingresos = 0;
            caja.Ingresos -= (float?)_venta.TotalPagado;
            if (caja.Saldo == null)
                caja.Saldo = 0;
            caja.Saldo -= (float?)_venta.TotalPagado;
            caja.FechaModificacion = _clock.Now;
            caja.SucursalModificacionId = Context.SucursalActual.Id;//Sucursal del operador
            caja.OperadorModificacionId = (Context.OperadorActual.Id);//Id el operador

            Uow.Cajas.Modificar(caja);

            //CajaMovimiento
            var cajaMovimientoAnterior = Uow.CajaMovimientos.Obtener(c => c.ComprobanteId == _venta.Id);

            CajaMovimiento cajaMovimiento = new CajaMovimiento();
            cajaMovimiento.Id = Guid.NewGuid();
            cajaMovimiento.CajaId = caja.Id;
            if (_venta.CondicionVentaId == CondicionVentaEnum.CuentaCorriente)
                cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.AnulaciónFacCtaCte;
            else
                cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.AnulaciónFacContado;

            cajaMovimiento.TipoComprobante = TipoComprobanteEnum.FacturaAnulada;
            cajaMovimiento.ComprobanteId = _venta.Id;
            cajaMovimiento.Senia = cajaMovimientoAnterior.Senia;
            cajaMovimiento.Importe = cajaMovimientoAnterior.Importe;
            cajaMovimiento.ImpFac = cajaMovimientoAnterior.ImpFac;
            cajaMovimiento.Recargo = cajaMovimientoAnterior.Recargo;
            cajaMovimiento.Efectivo = cajaMovimientoAnterior.Efectivo;
            cajaMovimiento.Tarjeta = cajaMovimientoAnterior.Tarjeta;
            cajaMovimiento.Cheque = cajaMovimientoAnterior.Cheque;
            cajaMovimiento.Deposito = cajaMovimientoAnterior.Deposito;

            cajaMovimiento.PcAlta = Environment.MachineName;
            cajaMovimiento.SucursalAltaId = _venta.SucursalAltaId;
            cajaMovimiento.OperadorAltaId = _venta.OperadorAltaId;
            cajaMovimiento.FechaAlta = _clock.Now;

            cajaMovimiento.SucursalModificacionId = Context.SucursalActual.Id;//Sucursal del operador
            cajaMovimiento.OperadorModificacionId = (Context.OperadorActual.Id);//Id el operador
            cajaMovimiento.FechaModificacion = _clock.Now;

            Uow.CajaMovimientos.Agregar(cajaMovimiento);

            //MovimientoCliente
            ClientesMovimiento clientesMovimiento = new ClientesMovimiento();
            clientesMovimiento.IdCliente = _venta.ClienteId;
            clientesMovimiento.IdTipoComprobante = (int)TipoComprobanteEnum.FacturaAnulada;
            clientesMovimiento.IdComprobante = _venta.Id;
            clientesMovimiento.Concepto = TipoComprobanteEnum.FacturaAnulada.ToString();
            clientesMovimiento.Debe = _venta.TotalPagado;
            clientesMovimiento.FechaGeneracion = _clock.Now;
            clientesMovimiento.FechaAlta = _clock.Now;
            clientesMovimiento.SucursalAltaId = Context.SucursalActual.Id;//Sucursal del operador
            clientesMovimiento.OperadorAltaId = (Context.OperadorActual.Id);//Id el operador

            Uow.ClientesMovimientos.Agregar(clientesMovimiento);

            //Actulizar señas de cliente
            var monto = cajaMovimientoAnterior.Senia;
            if (monto > 0 && monto != null)
            {
                int sucursal = 1;
                ClienteMontoFavor clienteMontoFavor = new ClienteMontoFavor();
                clienteMontoFavor.Id = Guid.NewGuid();
                clienteMontoFavor.ClienteId = _venta.ClienteId;
                clienteMontoFavor.FechaComprobante = _clock.Now;
                clienteMontoFavor.TipoComprobanteId = TipoComprobanteEnum.SeñaCliente;
                clienteMontoFavor.LCN = "R" + sucursal.ToString().PadLeft(4, '0') + CalcularLCN().PadLeft(8, '0');
                clienteMontoFavor.Concepto = "Seña " + clienteMontoFavor.LCN;
                clienteMontoFavor.Importe = monto;
                clienteMontoFavor.ImpOcupado = 0;
                clienteMontoFavor.Observaciones = TipoComprobanteEnum.SeñaCliente.ToString() + "Por anulación de factura";
                clienteMontoFavor.FechaAlta = _clock.Now;
                clienteMontoFavor.OperadorAltaId = Context.OperadorActual.Id;
                clienteMontoFavor.SucursalAltaId = Context.SucursalActual.Id;

                Uow.ClientesMontosFavor.Agregar(clienteMontoFavor);

            }

            //si la venta fue en CuentaCorriente, Anular las cuotas
            if (_venta.CondicionVentaId==CondicionVentaEnum.CuentaCorriente)
            {
                var cuotas = Uow.ClientesCuentasCorrientes.Listado().Where(cc => cc.VentaId == _venta.Id);
                foreach (ClienteCuentaCorriente cuota in cuotas)
                {
                    cuota.Pagado = cuota.Importe;
                    cuota.Observaciones = "Venta Anulada";
                    cuota.FechaModificacion = _clock.Now;
                    cuota.OperadorModificacionId = Context.OperadorActual.Id;
                    cuota.SucursalModificacionId = Context.SucursalActual.Id;

                    Uow.ClientesCuentasCorrientes.Modificar(cuota);
                }
            }

            //Si la venta fue con tarjeta, setear en 0 el estado del movimiento
            if (cajaMovimientoAnterior.Tarjeta!= null)
            {
                var tarjetamovimiento =
                    Uow.TarjetasMovimientos.Obtener(t => t.CajaMovimientoId == cajaMovimientoAnterior.Id);

                if (tarjetamovimiento != null)
                {
                    tarjetamovimiento.Estado = 0;
                    tarjetamovimiento.FechaModificacion = _clock.Now;
                    tarjetamovimiento.OperadorModificacionId = Context.OperadorActual.Id;
                    tarjetamovimiento.SucursalModificacionId = Context.SucursalActual.Id;

                    Uow.TarjetasMovimientos.Modificar(tarjetamovimiento);
                }
                
            }

            //si la venta fue con deposito, setear la columna debito=credito para que se anule
            if (cajaMovimientoAnterior.Deposito != null)
            {
                var cuentaMovimiento =
                    Uow.CuentasMovimientos.Obtener(t => t.ComprobanteId == _venta.Id);

                if (cuentaMovimiento != null)
                {
                    cuentaMovimiento.Debito = cuentaMovimiento.Credito;
                    cuentaMovimiento.FechaModificacion = _clock.Now;
                    cuentaMovimiento.OperadorModificacionId = Context.OperadorActual.Id;
                    cuentaMovimiento.SucursalModificacionId = Context.SucursalActual.Id;

                    Uow.CuentasMovimientos.Modificar(cuentaMovimiento);
                }

            }

            //si la venta fue con Cheque, setear estadocheque=1
            if (cajaMovimientoAnterior.Cheque != null)
            {
                var chequeTercero =
                    Uow.ChequesTercero.Obtener(t => t.CajaMovimientoId == cajaMovimientoAnterior.Id);

                if (chequeTercero != null)
                {
                    chequeTercero.EstadoChequeId = 1;
                    chequeTercero.FechaModificacion = _clock.Now;
                    chequeTercero.OperadorModificacionId = Context.OperadorActual.Id;
                    chequeTercero.SucursalModificacionId = Context.SucursalActual.Id;

                    Uow.ChequesTercero.Modificar(chequeTercero);
                }

            }


            Uow.Commit();
            _messageBoxDisplayService.ShowSuccess("Factura anulada correctamente");

            //this.Close();
            OnAccionTerminada();
        }
Пример #18
0
        private void BtnGuardar_Click(object sender, EventArgs e)
        {

            if (_proveedor == null)
            {
                return;
            }
            if (!ucTitulosCompra.Titulos.Any())
            {
                _messageBoxDisplayService.ShowError("Debe seleccionar al menos un libro para la compra.");
                return;
            }

            if (!ucTotalesCompraSeña1.Validar())
            {
                return;
            }

            if (ucTipoCompra.TipoComprobanteSeleccionado== Entidades.Enums.TipoComprobanteEnum.FacCpraContado)
            {
                if(TxtRemito1.Text==""||TxtRemito2.Text==""||TxtFactura1.Text==""||TxtFactura2.Text=="")
                    return;
            }

            if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraCtaCte)
            {
                if (TxtRemito1.Text == "" || TxtRemito2.Text == "" || TxtFactura1.Text == "" || TxtFactura2.Text == "" || ucCuentaCorrienteCompra.Cuotas == null)
                    return;
            }

            if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor)
            {
                  if (TxtRemito1.Text == "" || TxtRemito2.Text == "" || DtpFechaVencimiento.Value.Date<_clock.Now.Date)
                      return;
            }

            //Acumulamos los pagos
            decimal? efectivo = 0;
            decimal? efectivoCajaAnterior = 0;
            decimal? tarjeta = 0;
            decimal? cheque = 0;
            decimal? deposito = 0;
            decimal? transferencia = 0;

            foreach (var pago in ucTotalesCompraSeña1.Pagos)
            {
                switch (pago.TipoPago)
                {
                    case FormaPago.Efectivo:
                        efectivo += pago.Importe;
                        break;

                    case FormaPago.EfectivoCajaAnterior:
                        efectivoCajaAnterior += pago.Importe;
                        break;

                    case FormaPago.Tarjeta:
                        tarjeta += pago.Importe;
                        break;

                    case FormaPago.Cheque:
                        cheque += pago.Importe;
                        //Guardar una cajaMovimiento por cada cheque con la fecha de cobro como fecha de alta
                        //var cajaMovimiento = new CajaMovimiento();
                        //cajaMovimiento.Id = Guid.NewGuid();
                        //cajaMovimiento.CajaId = Context.CajaActual.Id;
                        //cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.PagoProveedorCajaAnterior;
                        //cajaMovimiento.TipoComprobante = ucTipoCompra.TipoComprobanteSeleccionado;
                        //cajaMovimiento.ComprobanteId = _idCompra;
                        //cajaMovimiento.Importe = pago.Importe;
                        //cajaMovimiento.ImpFac = pago.Importe;
                        //cajaMovimiento.Cheque = pago.Importe;
                        //VentaPagoCheque vcheque = (VentaPagoCheque)pago;
                        //cajaMovimiento.FechaAlta = vcheque.FechaCobro;
                        //cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                        //cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                        //Uow.CajaMovimientos.Agregar(cajaMovimiento);
                        break;

                    case FormaPago.Deposito:
                        deposito += pago.Importe;
                        break;

                    case FormaPago.Transferencia:
                        transferencia += pago.Importe;
                        break;
                }
            }


            //Pedimos autorización para caja anterior
            if (efectivoCajaAnterior > 0)
            {
                Guid operadorAutoriza = Guid.Empty;

                //////Autorizacion para sin movimiento
                var operador = this.ObtenerOperadorAdministrador();

                if (operador == null)
                {
                    return;
                }

                if (!this.EsOperadorAdmin)
                {
                    //Guardamos el operador que autorizo la operacion.
                    operadorAutoriza = operador.Id;
                }
            }

            //Compras
            Guid _idCompra = Guid.NewGuid();
            string _lcn = "";
            PuntoVenta = Context.SucursalActual.SucursalNumero ?? 1;
            Compra compraNueva = new Compra();

            switch (ucTipoCompra.TipoComprobanteSeleccionado)
            {
                case Entidades.Enums.TipoComprobanteEnum.FacCpraContado:
                    EstadoCompra = 1;
                    break;

                case Entidades.Enums.TipoComprobanteEnum.FacCpraCtaCte:
                    EstadoCompra = 1;
                    break;

                case Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor:
                    compraNueva.FechaVencimiento = DtpFechaVencimiento.Value;
                    NumeroComprobante = (Convert.ToInt32(TxtRemito2.Text)).ToString();

                    LetraComprobante = "X";
                    EstadoCompra = 1;
                    break;

                case Entidades.Enums.TipoComprobanteEnum.IngresosProducción:
                    NumeroComprobante = (Convert.ToInt16(TxtRemito2.Text)).ToString();
                    DdlFacturaTipo.Enabled = true;
                    DdlFacturaTipo.Visible = true;
                    LetraComprobante = "X";
                    EstadoCompra = 1;
                    break;

                case Entidades.Enums.TipoComprobanteEnum.RemitosAnulacConsigVend:
                    EstadoCompra = 2;
                    break;
            }

            //controlo cuantos ceros me faltan para armar el lcn y los agrego en la variable ceros
            string _ceros = "";
            for (int i = 0; i < (13 - (NumeroComprobante.Count() + 3 + PuntoVenta.ToString().Count())); i++)
            {
                _ceros += "0";
            }

            _lcn += LetraComprobante + PuntoVenta.ToString().PadLeft(3,'0')+ _ceros + NumeroComprobante;
            NumeroComprobante = TxtRemito1.Text + TxtRemito2.Text;

            //compraNueva.
            compraNueva.Id = _idCompra;
            compraNueva.LCN = _lcn;
            compraNueva.TipoComprobanteId = ucTipoCompra.TipoComprobanteSeleccionado;
            compraNueva.ProveedorId = _proveedor.Id;
            compraNueva.LetraComprobante = LetraComprobante;
            compraNueva.PuntoVenta = PuntoVenta;
            compraNueva.NumeroComprobante = NumeroComprobante;
            compraNueva.FechaComprobante = DtpFechaEmision.Value;
            compraNueva.Concepto = ucTipoCompra.TipoComprobanteSeleccionado.ToString();
            compraNueva.ImporteNeto = ucTitulosCompra.CalcularSubTotal();
            compraNueva.Observaciones = Observaciones;
            compraNueva.EstadoCompraId = EstadoCompra;
            compraNueva.OperadorAltaId = (Context.OperadorActual.Id);
            compraNueva.SucursalAltaId = Context.SucursalActual.Id;
            compraNueva.FechaAlta = _clock.Now;
            Uow.Compras.Agregar(compraNueva);

            //FacturaCompra.
            FacturasCompra facturaCompra = new FacturasCompra();
            facturaCompra.Id = Guid.NewGuid();
            facturaCompra.CompraId = _idCompra;
            facturaCompra.TipoComprobante = ucTipoCompra.TipoComprobanteSeleccionado;
            facturaCompra.ProveedorId = _proveedor.Id;
            facturaCompra.LCN = _lcn;
            facturaCompra.PuntoVenta = PuntoVenta;
            facturaCompra.NumeroComprobante = NumeroComprobante;
            facturaCompra.Concepto = ucTipoCompra.TipoComprobanteSeleccionado.ToString();
            facturaCompra.FechaComprobante = _clock.Now;
            if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraConsigCliente)
                facturaCompra.FechaVencimiento = DtpFechaEmision.Value;
            facturaCompra.ImporteNeto = ucTotalesCompraSeña1.SubTotal;
            facturaCompra.ImporteIVA = ucTotalesCompraSeña1.SubTotal;
            facturaCompra.EstadoId = 0;
            facturaCompra.FechaAlta = _clock.Now;
            facturaCompra.SucursalAltaId = Context.SucursalActual.Id;
            facturaCompra.OperadorAltaId = Context.OperadorActual.Id;
            Uow.FacturasCompras.Agregar(facturaCompra);

            //Remito
            if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraContado || 
                ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraCtaCte ||
                ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraConsigCliente)
            {
            RemitosCompra remitoCompra = new RemitosCompra();
            remitoCompra.Id = Guid.NewGuid();
            _remitoID = remitoCompra.Id;
            remitoCompra.CompraId = _idCompra;
            //remitoCompra.TipoComprobante = ucTipoCompra.TipoComprobanteSeleccionado;
            remitoCompra.ProveedorId = _proveedor.Id;
            remitoCompra.LCN = _lcn;
            remitoCompra.PuntoVenta = PuntoVenta;
            remitoCompra.NumeroComprobante = NumeroComprobante;
            remitoCompra.Concepto = ucTipoCompra.TipoComprobanteSeleccionado.ToString();
            remitoCompra.FechaComprobante = DtpFechaEmision.Value;
            if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraConsigCliente)
                remitoCompra.FechaVencimiento = DtpFechaVencimiento.Value;
            remitoCompra.ImporteNeto = ucTotalesCompraSeña1.SubTotal;
            remitoCompra.ImporteIVA = ucTotalesCompraSeña1.SubTotal;
            remitoCompra.Observaciones = Observaciones;
            remitoCompra.EstadoId = EstadoCompra;
            remitoCompra.FechaAlta = _clock.Now;
            remitoCompra.SucursalAltaId = Context.SucursalActual.Id;
            remitoCompra.OperadorAltaId = Context.SucursalActual.OperadorAltaId;
            Uow.RemitosCompra.Agregar(remitoCompra);
            }
           
            
            //TitulosStock. & Compra detalle
            foreach (var titulo in ucTitulosCompra.Titulos)
            {
                var tituloStock =
                Uow.TitulosStock.Obtener(ts => ts.TituloId == titulo.TituloId && ts.SucursalId == Context.SucursalActual.Id);

                //Compra detalle
                ComprasDetalle compraDetalle = new ComprasDetalle();
                compraDetalle.CompraId = _idCompra;
                compraDetalle.Id = Guid.NewGuid();
                compraDetalle.TituloId = titulo.TituloId;
                if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor)
                {
                    compraDetalle.CntCn = titulo.CantidadCompra;
                    compraDetalle.CntPr = 0;
                }
                else
                {
                    compraDetalle.CntPr = titulo.CantidadCompra;
                    compraDetalle.CntCn = 0;
                }
                compraDetalle.PrecioCompra = titulo.PrecioBase;
                compraDetalle.PrecioVenta = titulo.PrecioVenta;
                compraDetalle.FechaAlta = _clock.Now;
                compraDetalle.SucursalAltaId = Context.SucursalActual.Id;
                compraDetalle.OperadorAltaId = Context.OperadorActual.Id;
                compraDetalle.FechaModificacion = _clock.Now;
                compraDetalle.SucursalModificacionId = Context.SucursalActual.Id;
                compraDetalle.OperadorModificacionId = Context.OperadorActual.Id;
                Uow.ComprasDetalles.Agregar(compraDetalle);

                //Aumentar stock
                //deacuerdo al tipo de compra modificar el stock propio o en consigancion
                if (tituloStock == null)
                {
                    TituloStock tituloStockNuevo = new TituloStock();
                    tituloStockNuevo.TituloId = titulo.TituloId;
                    tituloStockNuevo.SucursalId = Context.SucursalActual.Id;
                    if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor)
                    {
                        tituloStockNuevo.StkPr = 0;
                        tituloStockNuevo.StkCn = titulo.CantidadCompra;
                    }
                    else
                    {
                        tituloStockNuevo.StkPr = titulo.CantidadCompra;
                        tituloStockNuevo.StkCn = 0;
                    }

                    tituloStockNuevo.FechaAlta = _clock.Now;
                    tituloStockNuevo.OperadorAltaId = (Context.OperadorActual.Id);
                    tituloStockNuevo.SucursalAltaId = Context.SucursalActual.Id;
                    Uow.TitulosStock.Agregar(tituloStockNuevo);
                }
                else
                {
                    //Aumento el stock propio o consignado de acuerdo a la opcion seleccionada.
                    if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor)
                    {
                        if (tituloStock.StkCn == null)
                            tituloStock.StkCn = titulo.CantidadCompra;
                        else
                            tituloStock.StkCn += titulo.CantidadCompra;
                    }
                    else
                        if (tituloStock.StkPr == null)
                            tituloStock.StkPr = titulo.CantidadCompra;
                        else
                            tituloStock.StkPr += titulo.CantidadCompra;

                    tituloStock.FechaModificacion = _clock.Now;
                    tituloStock.OperadorModificacionId = (Context.OperadorActual.Id);
                    tituloStock.SucursalModificacionId = Context.SucursalActual.Id;
                    Uow.TitulosStock.Modificar(tituloStock);
                }

                //FacturasCompraDetalle.
                FacturasComprasDetalle facturasComprasDetalle = new FacturasComprasDetalle();
                facturasComprasDetalle.Id = Guid.NewGuid();
                facturasComprasDetalle.FacturaCompraId = facturaCompra.Id;
                facturasComprasDetalle.TituloId = titulo.TituloId;

                if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor)
                {
                    facturasComprasDetalle.CntCn = titulo.CantidadCompra;
                    facturasComprasDetalle.CntPr = 0;
                }
                else
                {
                    facturasComprasDetalle.CntPr = titulo.CantidadCompra;
                    facturasComprasDetalle.CntCn = 0;
                }

                facturasComprasDetalle.PrecioCompra = titulo.PrecioBase;
                facturasComprasDetalle.PrecioVenta = titulo.PrecioVenta;
                facturasComprasDetalle.FechaAlta = _clock.Now;
                facturasComprasDetalle.SucursalAltaId = Context.SucursalActual.Id;
                facturasComprasDetalle.OperadorAltaId = (Context.OperadorActual.Id);
                
                Uow.FacturasComprasDetalles.Agregar(facturasComprasDetalle);

                if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.RemitosConsignacProveedor)
                {
                    //(TitulosConsiganciones).
                    TitulosConsignacion tituloConsignacion = new TitulosConsignacion();
                    tituloConsignacion.Id = Guid.NewGuid();
                    tituloConsignacion.TituloId = titulo.TituloId;
                    tituloConsignacion.ClienteId = Guid.Empty;
                    tituloConsignacion.ProveedorId = _proveedor.Id;
                    tituloConsignacion.TipoConsignacion = _tipoConsignacion;
                    tituloConsignacion.CntPr = 0;
                    tituloConsignacion.CntCn = titulo.CantidadCompra.GetValueOrDefault();
                    tituloConsignacion.CntVn = 0;
                    tituloConsignacion.FechaAlta = _clock.Now;
                    tituloConsignacion.SucursalAltaId = Context.SucursalActual.Id;
                    tituloConsignacion.OperadorAltaId = Context.OperadorActual.Id;
                    
                    Uow.TitulosConsignaciones.Agregar(tituloConsignacion);
                }
                //Remito Detalle
                if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraContado || 
                    ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraCtaCte ||
                    ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraConsigCliente)
                {
                    RemitosCompraDetalle remitoCompraDetalle = new RemitosCompraDetalle();
                    remitoCompraDetalle.Id = Guid.NewGuid();
                    remitoCompraDetalle.RemitoCompraId = _remitoID;
                    remitoCompraDetalle.TituloId = titulo.TituloId;
                    if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraConsigCliente)
                        remitoCompraDetalle.CntCn = titulo.CantidadCompra;
                    else
                        remitoCompraDetalle.CntPr = titulo.CantidadCompra;
                    remitoCompraDetalle.PrecioCompra = titulo.PrecioBase;
                    remitoCompraDetalle.PrecioVenta = titulo.PrecioVenta;
                    remitoCompraDetalle.FechaAlta = _clock.Now;
                    remitoCompraDetalle.SucursalAltaId = Context.SucursalActual.Id;
                    remitoCompraDetalle.OperadorAltaId = Context.OperadorActual.Id;
                    Uow.RemitosCompraDetalle.Agregar(remitoCompraDetalle);
                }
            }

            //Cuenta corriente
            if (ucTipoCompra.TipoComprobanteSeleccionado == Entidades.Enums.TipoComprobanteEnum.FacCpraCtaCte)
            {
                //Guardo toda la cuenta corriente
                var cuotas = ucCuentaCorrienteCompra.Cuotas;
                for (int i = 1; i <= cuotas; i++)
                {
                    ProveedoresCuentasCorriente proveedoresCuentaCorriente = new ProveedoresCuentasCorriente();
                    proveedoresCuentaCorriente.Id = Guid.NewGuid();
                    proveedoresCuentaCorriente.CompraId = _idCompra;
                    proveedoresCuentaCorriente.ProveedorId = _proveedor.Id;
                    proveedoresCuentaCorriente.Cuota = i;
                    proveedoresCuentaCorriente.Fecha = _clock.Now;
                    DateTime venc = ucCuentaCorrienteCompra.Vencimiento;
                    proveedoresCuentaCorriente.FechaVencimiento = venc.AddMonths(i - 1);
                    proveedoresCuentaCorriente.Importe = Convert.ToDecimal(ucCuentaCorrienteCompra.Montocuota);
                    proveedoresCuentaCorriente.Pagado = 0;
                    proveedoresCuentaCorriente.Observaciones = "";
                    proveedoresCuentaCorriente.FechaAlta = _clock.Now;
                    proveedoresCuentaCorriente.SucursalAltaId = Context.SucursalActual.Id;
                    proveedoresCuentaCorriente.OperadorAltaId = Context.OperadorActual.Id;
                    proveedoresCuentaCorriente.FechaModificacion = _clock.Now;
                    proveedoresCuentaCorriente.SucursalModificacionId = Context.SucursalActual.Id;
                    proveedoresCuentaCorriente.OperadorModificacionId = Context.OperadorActual.Id;
                    Uow.ProveedoresCuentasCorrientes.Agregar(proveedoresCuentaCorriente);
                }
            }

            #region Guardamos caja en contado
            
            //Guardamos la caja
            if (ucTipoCompra.TipoComprobanteSeleccionado == TipoComprobanteEnum.FacCpraContado)
            {
                Caja caja = this.Context.CajaActual;
                
                switch (ucTipoCompra.TipoComprobanteSeleccionado)
                {

                    case TipoComprobanteEnum.FacCpraContado:


                        //descontar de la caja
                        if (caja.Egresos == null)
                            caja.Egresos = 0;

                        caja.Egresos += (float?) efectivo;

                        if (caja.Saldo == null)
                            caja.Saldo = 0;
                        caja.Saldo -= (float?) ucTotalesCompraSeña1.SubTotal;

                        caja.FechaModificacion = _clock.Now;
                        caja.SucursalModificacionId = Context.SucursalActual.Id;
                        caja.OperadorModificacionId = (Context.OperadorActual.Id);

                        //aca descontamos las señas en el caso de que se utilicen. 
                        var _seña = UsoDeSeña();
                        var _credito = UsoDeCredito();
                        var _egreso = UsoEgreso();
                       
                        //Desde aca Controlar
                        if (efectivo > 0 || (_seña+_credito+_egreso) >0)
                        {
                            CajaMovimiento cajaMovimiento = new CajaMovimiento();
                            cajaMovimiento.Id = Guid.NewGuid();
                            cajaMovimiento.CajaId = caja.Id;
                            
                            cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.PagoProveedores;

                            cajaMovimiento.ComprobanteId = compraNueva.Id;
                            cajaMovimiento.Importe = efectivo;
                            cajaMovimiento.ImpFac = (decimal?)ucTotalesCompraSeña1.SubTotal;
                            cajaMovimiento.Efectivo = efectivo;

                            cajaMovimiento.Senia = _seña + _credito + _egreso ;
                            if (_seña > 0)
                            {
                               // cajaMovimiento.Senia = _seña;
                                _seña = 0;
                            }

                            if (_credito > 0)
                            {
                                //cajaMovimiento.Senia += _credito;
                                _credito = 0;
                            }

                            if (_egreso > 0)
                            {
                                //cajaMovimiento.Senia += _credito;
                                _egreso = 0;
                            }

                            cajaMovimiento.FechaAlta = _clock.Now;

                            cajaMovimiento.PcAlta = System.Environment.MachineName;
                            cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                            cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                            cajaMovimiento.TipoComprobante = TipoComprobanteEnum.FacCpraContado;
                            Uow.CajaMovimientos.Agregar(cajaMovimiento);
                        }

                        if (tarjeta > 0 || deposito > 0 || cheque > 0 || efectivoCajaAnterior > 0 || transferencia > 0)
                        {
                            CajaMovimiento cajaMovimientoAnterior = new CajaMovimiento();
                            cajaMovimientoAnterior.Id = Guid.NewGuid();
                            cajaMovimientoAnterior.CajaId = caja.Id;

                            cajaMovimientoAnterior.TipoMovimientoCajaId =
                                TipoMovimientoCajaEnum.PagoProveedorCajaAnterior;
                            cajaMovimientoAnterior.ComprobanteId = compraNueva.Id;
                            cajaMovimientoAnterior.Importe = tarjeta+deposito+cheque+efectivoCajaAnterior+transferencia;
                            cajaMovimientoAnterior.ImpFac = (decimal?)ucTotalesCompraSeña1.SubTotal;
                            cajaMovimientoAnterior.FechaAlta = _clock.Now;
                            cajaMovimientoAnterior.FechaModificacion = _clock.Now;
                            cajaMovimientoAnterior.PcAlta = System.Environment.MachineName;
                            cajaMovimientoAnterior.OperadorAltaId = Context.OperadorActual.Id;
                            cajaMovimientoAnterior.SucursalAltaId = Context.SucursalActual.Id;
                            cajaMovimientoAnterior.OperadorModificacionId = Context.OperadorActual.Id;
                            cajaMovimientoAnterior.SucursalModificacionId = Context.SucursalActual.Id;
                            cajaMovimientoAnterior.TipoComprobante = TipoComprobanteEnum.FacCpraContado;
                            cajaMovimientoAnterior.Efectivo = efectivoCajaAnterior;
                            cajaMovimientoAnterior.Tarjeta = tarjeta;
                            cajaMovimientoAnterior.Deposito = deposito;
                            cajaMovimientoAnterior.Cheque = cheque;
                            cajaMovimientoAnterior.Transferencia = transferencia;

                            cajaMovimientoAnterior.Senia = _seña + _credito + _egreso;
                          
                            //if (_seña > 0)
                            //{
                            //    cajaMovimientoAnterior.Senia = _seña;
                            //}

                          
                            Uow.CajaMovimientos.Agregar(cajaMovimientoAnterior);

                            //Guardamos el movimiento del depósito
                             foreach (var pago in ucTotalesCompraSeña1.Pagos)
                            {
                                switch (pago.TipoPago)
                                {
                                    case FormaPago.Cheque:
                                       // HACER ALGO
                                        break;

                                    case FormaPago.Deposito:
                                        var pagoDeposito = pago as VentaPagoDeposito;
                                        
                                        CuentasMovimiento cuentasMovimiento = new CuentasMovimiento();
                                        cuentasMovimiento.CuentaId = pagoDeposito.CuentaId ?? 0;
                                        cuentasMovimiento.TipoMovimientoId = 1;//Deposito a proveedor
                                        cuentasMovimiento.FechaMovimiento = pagoDeposito.Fecha;
                                        cuentasMovimiento.EstadoMovimientoCuentaId = 0;
                                        cuentasMovimiento.TipoComprobanteId = ucTipoCompra.TipoComprobanteSeleccionado;
                                        cuentasMovimiento.ComprobanteId = compraNueva.Id;
                                        cuentasMovimiento.MonedaId = 0;
                                        cuentasMovimiento.NroMovimiento = pagoDeposito.Numero;
                                        cuentasMovimiento.Descripcion = "DEPOSITO NRO " + pagoDeposito.Numero.ToString();
                                        cuentasMovimiento.FechaCobro = _clock.Now;
                                        cuentasMovimiento.Debito = pago.Importe;
                                        cuentasMovimiento.Credito = 0;
                                        cuentasMovimiento.TipoCarga = 1;
                                        cuentasMovimiento.CajaId = caja.Id;
                                        cuentasMovimiento.FechaAlta = _clock.Now;
                                        cuentasMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                                        cuentasMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                                        Uow.CuentasMovimientos.Agregar(cuentasMovimiento);
                                        break;

                                    case FormaPago.Transferencia:
                                        var pagoTransferencia = pago as VentaPagoTransferencia;
                                        
                                        CuentasMovimiento cuentasMovimientoTransferecia = new CuentasMovimiento();
                                        cuentasMovimientoTransferecia.CuentaId = pagoTransferencia.CuentaId ?? 0;
                                        cuentasMovimientoTransferecia.TipoMovimientoId = 1;//Deposito a proveedor
                                        cuentasMovimientoTransferecia.FechaMovimiento = pagoTransferencia.Fecha;
                                        cuentasMovimientoTransferecia.EstadoMovimientoCuentaId = 0;
                                        cuentasMovimientoTransferecia.TipoComprobanteId = ucTipoCompra.TipoComprobanteSeleccionado;
                                        cuentasMovimientoTransferecia.ComprobanteId = compraNueva.Id;
                                        cuentasMovimientoTransferecia.MonedaId = 0;
                                        cuentasMovimientoTransferecia.NroMovimiento = pagoTransferencia.Numero;
                                        cuentasMovimientoTransferecia.Descripcion = "TRANSFERENCIA NRO " + pagoTransferencia.Numero.ToString();
                                        cuentasMovimientoTransferecia.FechaCobro = _clock.Now;
                                        cuentasMovimientoTransferecia.Debito = pago.Importe;
                                        cuentasMovimientoTransferecia.Credito = 0;
                                        cuentasMovimientoTransferecia.TipoCarga = 1;
                                        cuentasMovimientoTransferecia.CajaId = caja.Id;
                                        cuentasMovimientoTransferecia.FechaAlta = _clock.Now;
                                        cuentasMovimientoTransferecia.OperadorAltaId = Context.OperadorActual.Id;
                                        cuentasMovimientoTransferecia.SucursalAltaId = Context.SucursalActual.Id;

                                        Uow.CuentasMovimientos.Agregar(cuentasMovimientoTransferecia);
                                        break;
                                }
                            }
                           
                        }
                        break;
                }
                Uow.Cajas.Modificar(caja);
            }
            #endregion

            #region "Guardar cuenta corriente"
            if (ucTipoCompra.TipoComprobanteSeleccionado == TipoComprobanteEnum.FacCpraCtaCte)
            {
                //aca descontamos las señas en el caso de que se utilicen. 
               var _seña =  UsoDeSeña();
               var _credito = UsoDeCredito();
                var _egreso = UsoEgreso();

               Caja caja = this.Context.CajaActual;

               CajaMovimiento cajaMovimiento = new CajaMovimiento();
               cajaMovimiento.Id = Guid.NewGuid();
               cajaMovimiento.CajaId = caja.Id;

               cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.PagoProveedores;
               cajaMovimiento.TipoComprobante = ucTipoCompra.TipoComprobanteSeleccionado;
               cajaMovimiento.ComprobanteId = compraNueva.Id;

               cajaMovimiento.Senia = _seña + _credito + _egreso;
               cajaMovimiento.ImpFac = (decimal?)ucTotalesCompraSeña1.SubTotal;

               //////////////////////////////////////////////////////////////////////////////
               if (efectivo > 0)
               {
                   cajaMovimiento.Importe = efectivo;
                   cajaMovimiento.Efectivo = efectivo;

                   cajaMovimiento.Senia = _seña + _credito + _egreso;
               }

                  if (tarjeta > 0 || deposito > 0 || cheque > 0 || efectivoCajaAnterior > 0 || transferencia > 0)
                        {
                            CajaMovimiento cajaMovimientoAnterior = new CajaMovimiento();
                            cajaMovimientoAnterior.Id = Guid.NewGuid();
                            cajaMovimientoAnterior.CajaId = caja.Id;

                            cajaMovimientoAnterior.TipoMovimientoCajaId =
                                TipoMovimientoCajaEnum.PagoProveedorCajaAnterior;
                            cajaMovimientoAnterior.ComprobanteId = compraNueva.Id;
                            cajaMovimientoAnterior.Importe = tarjeta+deposito+cheque+efectivoCajaAnterior+transferencia;
                            cajaMovimientoAnterior.ImpFac = (decimal?)ucTotalesCompraSeña1.SubTotal;
                            cajaMovimientoAnterior.FechaAlta = _clock.Now;
                            cajaMovimientoAnterior.FechaModificacion = _clock.Now;
                            cajaMovimientoAnterior.PcAlta = System.Environment.MachineName;
                            cajaMovimientoAnterior.OperadorAltaId = Context.OperadorActual.Id;
                            cajaMovimientoAnterior.SucursalAltaId = Context.SucursalActual.Id;
                            cajaMovimientoAnterior.OperadorModificacionId = Context.OperadorActual.Id;
                            cajaMovimientoAnterior.SucursalModificacionId = Context.SucursalActual.Id;
                            cajaMovimientoAnterior.TipoComprobante = ucTipoCompra.TipoComprobanteSeleccionado; // TipoComprobanteEnum.FacCpraContado;
                            cajaMovimientoAnterior.Efectivo = efectivoCajaAnterior;
                            cajaMovimientoAnterior.Tarjeta = tarjeta;
                            cajaMovimientoAnterior.Deposito = deposito;
                            cajaMovimientoAnterior.Cheque = cheque;
                            cajaMovimientoAnterior.Transferencia = transferencia;

                            cajaMovimientoAnterior.Senia = _seña + _credito + _egreso;
                          
                            //if (_seña > 0)
                            //{
                            //    cajaMovimientoAnterior.Senia = _seña;
                            //}

                          
                            Uow.CajaMovimientos.Agregar(cajaMovimientoAnterior);

                            //Guardamos el movimiento del depósito
                             foreach (var pago in ucTotalesCompraSeña1.Pagos)
                            {
                                switch (pago.TipoPago)
                                {
                                    case FormaPago.Cheque:
                                       // HACER ALGO
                                        break;

                                    case FormaPago.Deposito:
                                        var pagoDeposito = pago as VentaPagoDeposito;
                                        
                                        CuentasMovimiento cuentasMovimiento = new CuentasMovimiento();
                                        cuentasMovimiento.CuentaId = pagoDeposito.CuentaId ?? 0;
                                        cuentasMovimiento.TipoMovimientoId = 1;//Deposito a proveedor
                                        cuentasMovimiento.FechaMovimiento = pagoDeposito.Fecha;
                                        cuentasMovimiento.EstadoMovimientoCuentaId = 0;
                                        cuentasMovimiento.TipoComprobanteId = ucTipoCompra.TipoComprobanteSeleccionado;
                                        cuentasMovimiento.ComprobanteId = compraNueva.Id;
                                        cuentasMovimiento.MonedaId = 0;
                                        cuentasMovimiento.NroMovimiento = pagoDeposito.Numero;
                                        cuentasMovimiento.Descripcion = "DEPOSITO NRO " + pagoDeposito.Numero.ToString();
                                        cuentasMovimiento.FechaCobro = _clock.Now;
                                        cuentasMovimiento.Debito = pago.Importe;
                                        cuentasMovimiento.Credito = 0;
                                        cuentasMovimiento.TipoCarga = 1;
                                        cuentasMovimiento.CajaId = caja.Id;
                                        cuentasMovimiento.FechaAlta = _clock.Now;
                                        cuentasMovimiento.OperadorAltaId = Context.OperadorActual.Id;
                                        cuentasMovimiento.SucursalAltaId = Context.SucursalActual.Id;

                                        Uow.CuentasMovimientos.Agregar(cuentasMovimiento);
                                        break;

                                    case FormaPago.Transferencia:
                                        var pagoTransferencia = pago as VentaPagoTransferencia;
                                        
                                        CuentasMovimiento cuentasMovimientoTransferecia = new CuentasMovimiento();
                                        cuentasMovimientoTransferecia.CuentaId = pagoTransferencia.CuentaId ?? 0;
                                        cuentasMovimientoTransferecia.TipoMovimientoId = 1;//Deposito a proveedor
                                        cuentasMovimientoTransferecia.FechaMovimiento = pagoTransferencia.Fecha;
                                        cuentasMovimientoTransferecia.EstadoMovimientoCuentaId = 0;
                                        cuentasMovimientoTransferecia.TipoComprobanteId = ucTipoCompra.TipoComprobanteSeleccionado;
                                        cuentasMovimientoTransferecia.ComprobanteId = compraNueva.Id;
                                        cuentasMovimientoTransferecia.MonedaId = 0;
                                        cuentasMovimientoTransferecia.NroMovimiento = pagoTransferencia.Numero;
                                        cuentasMovimientoTransferecia.Descripcion = "TRANSFERENCIA NRO " + pagoTransferencia.Numero.ToString();
                                        cuentasMovimientoTransferecia.FechaCobro = _clock.Now;
                                        cuentasMovimientoTransferecia.Debito = pago.Importe;
                                        cuentasMovimientoTransferecia.Credito = 0;
                                        cuentasMovimientoTransferecia.TipoCarga = 1;
                                        cuentasMovimientoTransferecia.CajaId = caja.Id;
                                        cuentasMovimientoTransferecia.FechaAlta = _clock.Now;
                                        cuentasMovimientoTransferecia.OperadorAltaId = Context.OperadorActual.Id;
                                        cuentasMovimientoTransferecia.SucursalAltaId = Context.SucursalActual.Id;

                                        Uow.CuentasMovimientos.Agregar(cuentasMovimientoTransferecia);
                                        break;
                                }
                            }
                           
                        }

                //////////////////////////////////////////////////////////////////////////////

               cajaMovimiento.PcAlta = System.Environment.MachineName;
               cajaMovimiento.FechaAlta = _clock.Now;
               cajaMovimiento.OperadorAltaId = Context.OperadorActual.Id;
               cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;
               Uow.CajaMovimientos.Agregar(cajaMovimiento);
            }
            #endregion

            Uow.Commit();

            _messageBoxDisplayService.ShowSuccess(Resources.MessageSuccessCompraExitosa);

            OnCompraRealizada();
        }
Пример #19
0
        private void Anular(ClienteMontoFavor senia)
        {
            //Utiliar toda la seña
            if (senia.TipoComprobanteId == TipoComprobanteEnum.SeñaCliente)
            {

                var operador = this.ObtenerOperadorAdministrador();

                if (operador == null)
                {
                    return;
                }

                if (!this.EsOperadorAdmin)
                {
                    //Guardamos el operador que autorizo la operacion.
                    senia.OperadorAutoriza = operador.Id;
                }

                var diferencia = senia.Importe - senia.ImpOcupado;
                if (diferencia == 0)
                    return;

                senia.ImpOcupado = senia.Importe;
                senia.FechaAnulacion = _clock.Now;
                senia.FechaModificacion = _clock.Now;
                senia.OperadorModificacionId = Context.OperadorActual.Id;
                senia.SucursalModificacionId = Context.SucursalActual.Id;

                Uow.ClientesMontosFavor.Modificar(senia);
                //generar cajamovimientno
                Caja caja = this.Context.CajaActual;
                if (caja.Ingresos == null)
                    caja.Ingresos = 0;
                caja.Egresos += (float?)diferencia;
                if (caja.Saldo == null)
                    caja.Saldo = 0;
                caja.Saldo -= (float?)diferencia;
                caja.FechaModificacion = _clock.Now;
                caja.SucursalModificacionId = Context.SucursalActual.Id;//Sucursal del operador
                caja.OperadorModificacionId = (Context.OperadorActual.Id);//Id el operador

                Uow.Cajas.Modificar(caja);

                CajaMovimiento cajaMovimiento = new CajaMovimiento();
                cajaMovimiento.Id = Guid.NewGuid();
                cajaMovimiento.CajaId = caja.Id;
                cajaMovimiento.TipoMovimientoCajaId = TipoMovimientoCajaEnum.AnulaciónSeña;
                cajaMovimiento.TipoComprobante = TipoComprobanteEnum.SeñaCliente;
                cajaMovimiento.ComprobanteId = senia.Id;
                cajaMovimiento.Senia = 0;
                cajaMovimiento.Importe = diferencia;
                cajaMovimiento.ImpFac = 0;
                cajaMovimiento.PcAlta = Environment.MachineName;
                cajaMovimiento.SucursalAltaId = Context.SucursalActual.Id;//Sucursal del operador
                cajaMovimiento.OperadorAltaId = (Context.OperadorActual.Id);//Id el operador
                cajaMovimiento.FechaAlta = _clock.Now;
                Uow.CajaMovimientos.Agregar(cajaMovimiento);

                //Generaregreso??
                Uow.Commit();
                _messageBoxDisplayService.ShowSuccess("Anulación de seña exitosa");

                BuscarHistorial();
            }
            else
            {
                _messageBoxDisplayService.ShowError("No puede anular una nota de crédito");
            }
        }
Пример #20
0
        private void ProcesarPagoDeposito(VentaDataBase ventaData, VentaPago pago, CajaMovimiento cajaMovimiento, Venta venta, Caja caja)
        {
            var pagoDeposito = pago as VentaPagoDeposito;
            if (cajaMovimiento.Deposito == null)
                cajaMovimiento.Deposito = 0;

            //Guardar Cuentas Movimientos
            cajaMovimiento.Deposito += pago.Importe;

            CuentasMovimiento cuentasMovimiento = new CuentasMovimiento();
            cuentasMovimiento.CuentaId = pagoDeposito.CuentaId ?? 0;
            cuentasMovimiento.TipoMovimientoId = 2; //Deposito
            cuentasMovimiento.FechaMovimiento = pagoDeposito.Fecha;
            cuentasMovimiento.EstadoMovimientoCuentaId = 0;
            cuentasMovimiento.TipoComprobanteId = ventaData.TipoComprobanteSeleccionado;
            cuentasMovimiento.ComprobanteId = venta.Id;
            cuentasMovimiento.MonedaId = 0;
            cuentasMovimiento.CondicionVentaId = ventaData.CondicionVentaSeleccionada;
            cuentasMovimiento.NroMovimiento = pagoDeposito.Numero;
            cuentasMovimiento.Descripcion = "DEPOSITO NRO " + pagoDeposito.Numero.ToString();
            cuentasMovimiento.FechaCobro = _clock.Now;
            cuentasMovimiento.Debito = 0;
            cuentasMovimiento.Credito = pago.Importe;
            cuentasMovimiento.TipoCarga = 2;
            cuentasMovimiento.CajaId = caja.Id;
            cuentasMovimiento.FechaAlta = _clock.Now;
            cuentasMovimiento.OperadorAltaId = ventaData.OperadorId;
            cuentasMovimiento.SucursalAltaId = ventaData.SucursalId;

            Uow.CuentasMovimientos.Agregar(cuentasMovimiento);
        }