Exemple #1
0
        private bool AccionGuardar()
        {
            // Se inicializa la barra de progreso
            this.pgvAvance.Inicializar(this.dgvPartes.Rows.Count, 1);

            foreach (DataGridViewRow oFila in this.dgvPartes.Rows)
            {
                int iParteID = Util.Entero(oFila.Cells["ParteID"].Value);

                if (this.chkAplicaciones.Checked)
                {
                    AdmonProc.CopiarAplicacionesDeEquivalentes(iParteID);
                }
                if (this.chkCodigosAlternos.Checked)
                {
                    AdmonProc.CopiarCodigosAlternosDeEquivalentes(iParteID);
                }
                if (this.chkPartesComplementarias.Checked)
                {
                    AdmonProc.CopiarPartesComplementariasDeEquivalentes(iParteID);
                }

                this.pgvAvance.EjecutarPaso(true);
            }

            this.pgvAvance.Finalizar();

            return(true);
        }
Exemple #2
0
        private void MovimientoAgrupar_Load(object sender, EventArgs e)
        {
            DateTime dVencimiento = DateTime.MaxValue;
            int      iProveedorID = 0;

            if (this.bEsNuevo)
            {
                this.Text = "Agrupar movimientos";

                // Se llenan los datos
                decimal mTotal = 0;
                foreach (int iMovID in this.oMovimientosAgrupados)
                {
                    var oReg = Datos.GetEntity <MovimientoInventario>(c => c.MovimientoInventarioID == iMovID && c.Estatus);
                    mTotal += oReg.ImporteFactura;
                    if (oReg.FechaRecepcion < dVencimiento)
                    {
                        dVencimiento = oReg.FechaRecepcion.Valor();
                    }
                    // Se obtiene el proveedor
                    if (iProveedorID == 0)
                    {
                        iProveedorID = oReg.ProveedorID.Valor();
                    }
                }
                this.lblMovimientos.Text    = this.oMovimientosAgrupados.Count.ToString();
                this.lblImporteFactura.Text = mTotal.ToString(GlobalClass.FormatoMoneda);
            }
            else
            {
                this.Text = "Editar movimiento agrupador";

                // Se llenan los datos
                var oMovAgr = Datos.GetEntity <MovimientoInventario>(c => c.MovimientoInventarioID == this.iMovimientoAgrupadorID && c.Estatus);
                iProveedorID = oMovAgr.ProveedorID.Valor();
                var oMovs = Datos.GetListOf <MovimientoInventario>(c => c.MovimientoAgrupadorID == this.iMovimientoAgrupadorID && c.Estatus);
                this.lblMovimientos.Text    = oMovs.Count.ToString();
                this.lblImporteFactura.Text = oMovAgr.ImporteFactura.ToString(GlobalClass.FormatoMoneda);
            }

            // Se sugiere la fecha de vencimiento
            var oProveedor = Datos.GetEntity <Proveedor>(c => c.ProveedorID == iProveedorID && c.Estatus);

            this.iDiasDePlazo         = oProveedor.DiasPlazo.Valor();
            dVencimiento              = AdmonProc.SugerirVencimientoCompra(dVencimiento, iDiasDePlazo);
            this.dtpVencimiento.Value = dVencimiento;
        }
Exemple #3
0
        public VerImagenesParte(int iParteID)
        {
            InitializeComponent();

            this.pcbParte.Controls.Add(this.pnlBotones);

            this.Icon = Properties.Resources.Ico_ControlRefaccionaria_Ant;

            var oParte = Datos.GetEntity <Parte>(q => q.Estatus && q.ParteID == iParteID);

            if (oParte != null)
            {
                this.Text = (oParte.NumeroParte + " - " + oParte.NombreParte);
            }

            this.oImagenes = AdmonProc.ObtenerImagenesParte(iParteID);
            // this.oImagenes = General.GetListOf<ParteImagen>(q => q.Estatus && q.ParteID == iParteID).OrderBy(q => q.Orden).ToList();

            // Se configuran los botones
            foreach (Control oControl in this.pnlBotones.Controls)
            {
                if (oControl is Button)
                {
                    oControl.MouseLeave += new EventHandler((s, e) =>
                    {
                        var btn = (s as Button);
                        // btn.Image = (Properties.Resources.ResourceManager.GetObject("Boton" + btn.Name.Replace("btn", "")) as Image);
                        btn.BackgroundImage = (Properties.Resources.ResourceManager.GetObject("Boton" + btn.Name.Replace("btn", "")) as Image);
                    });
                    oControl.MouseDown += new MouseEventHandler((s, e) =>
                    {
                        var btn = (s as Button);
                        // btn.Image = (Properties.Resources.ResourceManager.GetObject("Boton" + btn.Name.Replace("btn", "") + "Clic") as Image);
                        btn.BackgroundImage = (Properties.Resources.ResourceManager.GetObject("Boton" + btn.Name.Replace("btn", "") + "Clic") as Image);
                    });
                    oControl.MouseUp += new MouseEventHandler((s, e) =>
                    {
                        var btn = (s as Button);
                        // btn.Image = (Properties.Resources.ResourceManager.GetObject("Boton" + btn.Name.Replace("btn", "")) as Image);
                        btn.BackgroundImage = (Properties.Resources.ResourceManager.GetObject("Boton" + btn.Name.Replace("btn", "")) as Image);
                    });
                }
            }
        }
Exemple #4
0
        public ProveedorParteGanancia ObtenerParteGanancia(int?iParteID)
        {
            if (iParteID <= 0)
            {
                iParteID = null;
            }
            int iProveedorID = Util.Entero(this.cmbProveedor.SelectedValue);
            var oMarcaLinea  = (this.cmbLineaMarca.SelectedItem as ProveedoresMarcasLineasView);

            if (this.ParteIDSel > 0)
            {
                iParteID = this.ParteIDSel;
            }
            if (oMarcaLinea == null)
            {
                return(AdmonProc.ObtenerParteDescuentoGanancia(iProveedorID, null, null, iParteID));
            }
            else
            {
                return(AdmonProc.ObtenerParteDescuentoGanancia(iProveedorID, oMarcaLinea.MarcaID, oMarcaLinea.LineaID, iParteID));
            }
        }
Exemple #5
0
        public JsonResult RecibirTraspaso(int eParam1, string eParam2, List <modDetalleTraspaso> eParam3, bool eParam4)
        {
            var oRes = AdmonProc.RecibirTraspaso(eParam1, eParam2, eParam3, eParam4);

            return(this.Json(oRes));
        }
        private bool AccionAceptar()
        {
            // Cargando.Mostrar();

            decimal mFaltante         = 0;
            int     iClienteID        = 0;
            int     iCobroVentaID     = 0;
            bool    bUsarCascosAFavor = false;
            bool    bCrearVale        = false;
            bool    bCascoAFavor      = false;

            int iCascoRecibido   = Util.Entero(this.cmbCascoRecibido.SelectedValue);
            int iSucursalID      = GlobalClass.SucursalID;
            int iCascoRegistroID = this.oCascoRegistro.CascoRegistroID;
            int iParteID         = this.oCascoRegistro.ParteID;
            var oParte           = Datos.GetEntity <Parte>(c => c.ParteID == iParteID && c.Estatus);
            var oVenta           = Datos.GetEntity <Venta>(c => c.VentaID == this.oCascoRegistro.VentaID && c.Estatus);

            iClienteID = oVenta.ClienteID;
            var oCliente = Datos.GetEntity <Cliente>(c => c.ClienteID == oVenta.ClienteID && c.Estatus);

            if (iCascoRecibido != oParte.RequiereCascoDe)
            {
                // Si se recibió algún casco
                if (iCascoRecibido > 0)
                {
                    // Se obtienen el importe requerido
                    var oPrecioReq = Datos.GetEntity <PartePrecio>(c => c.ParteID == oParte.RequiereCascoDe && c.Estatus);
                    var oPrecioRec = Datos.GetEntity <PartePrecio>(c => c.ParteID == iCascoRecibido && c.Estatus);
                    if (oPrecioReq == null || oPrecioRec == null)
                    {
                        UtilLocal.MensajeAdvertencia("Hubo un error al obtener el Casco requerido.");
                        return(false);
                    }

                    // Se calcula el importe faltante
                    decimal?[] aPreciosReq = new decimal?[5] {
                        oPrecioReq.PrecioUno, oPrecioReq.PrecioDos, oPrecioReq.PrecioTres, oPrecioReq.PrecioCuatro, oPrecioReq.PrecioCinco
                    };
                    decimal?[] aPreciosRec = new decimal?[5] {
                        oPrecioRec.PrecioUno, oPrecioRec.PrecioDos, oPrecioRec.PrecioTres, oPrecioRec.PrecioCuatro, oPrecioRec.PrecioCinco
                    };
                    mFaltante = (aPreciosReq[oCliente.ListaDePrecios - 1] - aPreciosRec[oCliente.ListaDePrecios - 1]).Valor();

                    // Se evalúa el importe faltante, para tomar alguna acción
                    if (mFaltante != 0)
                    {
                        // Si el casco recibido es menor que el casco esperado
                        if (mFaltante > 0)
                        {
                            // Se busca por folio de cobro o por cascos a favor, según sea el caso
                            if (this.txtFolioDeCobro.Text == "")
                            {
                                decimal mTotalAFavor = Util.Decimal(this.lblTotalAFavor.Text);
                                if (mTotalAFavor != mFaltante)
                                {
                                    UtilLocal.MensajeAdvertencia("El importe seleccionado con los Cascos a favor debe ser de " + mFaltante.ToString(GlobalClass.FormatoMoneda));
                                    return(false);
                                }
                                bUsarCascosAFavor = true;
                            }
                            else
                            {
                                // Se obtiene el importe de la venta
                                var oVentaCobroV = Datos.GetEntity <VentasView>(c => c.Folio == this.txtFolioDeCobro.Text && c.SucursalID == GlobalClass.SucursalID &&
                                                                                (c.VentaEstatusID == Cat.VentasEstatus.Cobrada || c.VentaEstatusID == Cat.VentasEstatus.Completada));
                                if (oVentaCobroV == null)
                                {
                                    UtilLocal.MensajeAdvertencia("La venta específicada no existe, no es de esta sucursal o no ha sido cobrada.");
                                    return(false);
                                }
                                iCobroVentaID = oVentaCobroV.VentaID;

                                // Se valida que la parte de la venta sea una "diferencia de casco"
                                if (!Datos.Exists <VentaDetalle>(c => c.VentaID == iCobroVentaID && c.ParteID == Cat.Partes.DiferenciaDeCascos && c.Estatus))
                                {
                                    UtilLocal.MensajeAdvertencia("La venta especificada no corresponde a una Diferencia de Casco.");
                                    return(false);
                                }
                                // Se valida que el importe cobrado sea el correspondiente
                                if (oVentaCobroV.Total != mFaltante)
                                {
                                    UtilLocal.MensajeAdvertencia("El cobro por la diferencia debe de ser de " + mFaltante.ToString(GlobalClass.FormatoMoneda));
                                    return(false);
                                }
                            }
                        }
                        // Si el casco recibido es mayor que el casco esperado
                        else if (mFaltante < 0)
                        {
                            var oRes = UtilLocal.MensajePreguntaCancelar("El importe del casco recibido es mayor al esperado. ¿Deseas crear un Vale a favor del Cliente?");
                            if (oRes == DialogResult.Cancel)
                            {
                                return(false);
                            }
                            bCrearVale   = (oRes == DialogResult.Yes);
                            bCascoAFavor = !bCrearVale;
                        }
                    }
                }
                else  // Si no se recibió ningún casco, se evalúa la venta
                {
                    // Se obtiene la VentaID
                    var oVentaCobro = Datos.GetEntity <Venta>(c => c.Folio == this.txtFolioDeCobro.Text && c.SucursalID == GlobalClass.SucursalID &&
                                                              (c.VentaEstatusID == Cat.VentasEstatus.Cobrada || c.VentaEstatusID == Cat.VentasEstatus.Completada) && c.Estatus);
                    if (oVentaCobro == null)
                    {
                        UtilLocal.MensajeAdvertencia("La venta específicada no existe, no es de esta sucursal o no ha sido cobrada.");
                        return(false);
                    }
                    iCobroVentaID = oVentaCobro.VentaID;

                    // Se valida que la venta tenga la Parte correspondiente al casco
                    if (!Datos.Exists <VentaDetalle>(c => c.VentaID == iCobroVentaID && c.ParteID == oParte.RequiereDepositoDe && c.Estatus))
                    {
                        UtilLocal.MensajeAdvertencia("El cobro del Casco no corresonde al Artículo.");
                        return(false);
                    }
                }
            }

            // Cargando.Cerrar();
            // Se solicita la contraseña
            var oResU = UtilLocal.ValidarObtenerUsuario("Ventas.ControlDeCascos.Completar");

            if (oResU.Error)
            {
                return(false);
            }
            Cargando.Mostrar();

            // Se completa el registro de casco
            DateTime dAhora = DateTime.Now;

            // Se registran y modifican los Cascos a favor usados, si aplica
            if (bUsarCascosAFavor)
            {
                foreach (DataGridViewRow oFila in this.dgvImportesAFavor.Rows)
                {
                    if (Util.Logico(oFila.Cells["Sel"].Value))
                    {
                        // Se registra el importe usado para el CascoImporte
                        int     iCascoImporteID = Util.Entero(oFila.Cells["CascoImporteID"].Value);
                        decimal mAUsar          = Util.Decimal(oFila.Cells["ImporteAUsar"].Value);
                        var     oCascoImporte   = Datos.GetEntity <CascoImporte>(c => c.CascoImporteID == iCascoImporteID);
                        oCascoImporte.ImporteUsado += mAUsar;
                        Datos.Guardar <CascoImporte>(oCascoImporte);
                        // Se registra la relación entre el CascoRegistro y el CascoImporte
                        var oCascoRegImp = new CascoRegistroImporte()
                        {
                            CascoRegistroID = this.oCascoRegistro.CascoRegistroID,
                            CascoImporteID  = oCascoImporte.CascoImporteID,
                            Importe         = mAUsar
                        };
                        Datos.Guardar <CascoRegistroImporte>(oCascoRegImp);
                    }
                }
            }
            // Se crea el vale, si aplica
            if (bCrearVale)
            {
                var oRes = VentasProc.GenerarNotaDeCredito(iClienteID, (mFaltante * -1), "", Cat.OrigenesNotaDeCredito.CascoDeMayorValor
                                                           , this.oCascoRegistro.CascoRegistroID);
                // Se crea la póliza contable (AfeConta)
                ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.ValeDirecto, oRes.Respuesta, oCliente.Nombre, "POR CASCO MAYOR");
                // Se manda a imprimir el ticket
                VentasLoc.GenerarTicketNotaDeCredito(oRes.Respuesta);
            }
            // Se registra el casco a favor, si aplica
            if (bCascoAFavor)
            {
                var oCascoImporte = new CascoImporte()
                {
                    Fecha    = dAhora,
                    OrigenID = this.oCascoRegistro.CascoRegistroID,
                    Importe  = (mFaltante * -1)
                };
                Datos.Guardar <CascoImporte>(oCascoImporte);
            }
            // Se afecta la existencia y el kárdex del casco recibido
            if (iCascoRecibido > 0)
            {
                var oSucursal  = Datos.GetEntity <Sucursal>(c => c.SucursalID == iSucursalID && c.Estatus);
                var oPrecioRec = Datos.GetEntity <PartePrecio>(c => c.ParteID == iCascoRecibido && c.Estatus);
                AdmonProc.AfectarExistenciaYKardex(iCascoRecibido, GlobalClass.SucursalID, Cat.OperacionesKardex.EntradaInventario, iCascoRegistroID.ToString()
                                                   , oResU.Respuesta.UsuarioID, oCliente.Nombre, "CONTROL DE CASCOS", oSucursal.NombreSucursal, 1, oPrecioRec.Costo.Valor()
                                                   , Cat.Tablas.CascoRegistro, iCascoRegistroID);
            }

            // Se guardan los datos del registro de casco
            this.oCascoRegistro.RecibidoCascoID  = (iCascoRecibido > 0 ? (int?)iCascoRecibido : null);
            this.oCascoRegistro.RealizoUsuarioID = oResU.Respuesta.UsuarioID;
            this.oCascoRegistro.CobroVentaID     = (iCobroVentaID > 0 ? (int?)iCobroVentaID : null);
            Datos.Guardar <CascoRegistro>(this.oCascoRegistro);

            // Se manda a imprimir el ticket correspondiente
            var oCascoRegV = Datos.GetEntity <CascosRegistrosView>(c => c.CascoRegistroID == iCascoRegistroID);
            var oRep       = new Report();

            oRep.Load(GlobalClass.ConfiguracionGlobal.pathReportes + "ControlDeCascos.frx");
            VentasLoc.TicketAgregarLeyendas(ref oRep);
            oRep.RegisterData(new List <CascosRegistrosView>()
            {
                oCascoRegV
            }, "ControlDeCasco");
            UtilLocal.EnviarReporteASalida("Reportes.ControlDeCascos.Completar.Salida", oRep);

            Cargando.Cerrar();
            UtilLocal.MostrarNotificacion("Control de casco completado correctamente.");

            return(true);
        }
Exemple #7
0
        private void DevolverControlCasco(int iDevolucionDetalleID, int iUsuarioID)
        {
            // Se obtiene el registro del control de casco
            var oDevDet = Datos.GetEntity <VentaDevolucionDetalle>(c => c.VentaDevolucionDetalleID == iDevolucionDetalleID && c.Estatus);
            var oDev    = Datos.GetEntity <VentaDevolucion>(c => c.VentaDevolucionID == oDevDet.VentaDevolucionID && c.Estatus);

            for (int i = 0; i < oDevDet.Cantidad; i++)
            {
                int iCancelarVentaID = 0;
                var oCascoReg        = Datos.GetEntity <CascoRegistro>(c => c.VentaID == oDev.VentaID && c.ParteID == oDevDet.ParteID);
                // Acción si no se recibió ningún casco
                if (oCascoReg.RecibidoCascoID == null)
                {
                    iCancelarVentaID = oCascoReg.CobroVentaID.Valor();
                }
                else
                {
                    var oParte = Datos.GetEntity <Parte>(c => c.ParteID == oCascoReg.ParteID && c.Estatus);

                    // Se registra la salida del inventario
                    var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == oDev.VentaID);
                    var oCascoRecibidoPrecio = Datos.GetEntity <PartePrecio>(c => c.ParteID == oCascoReg.RecibidoCascoID.Value && c.Estatus);
                    AdmonProc.AfectarExistenciaYKardex(oCascoReg.RecibidoCascoID.Valor(), GlobalClass.SucursalID, Cat.OperacionesKardex.SalidaInventario
                                                       , oCascoReg.CascoRegistroID.ToString(), iUsuarioID, oVentaV.Cliente, "CONTROL DE CASCOS", oVentaV.Sucursal, -1, oCascoRecibidoPrecio.Costo.Valor()
                                                       , Cat.Tablas.CascoRegistro, oCascoReg.CascoRegistroID);

                    // Acciones si no se recibió el casco adecuado
                    if (oCascoReg.RecibidoCascoID != oParte.RequiereCascoDe)
                    {
                        // Acción si hubo diferencia de importe entre el casco recibido y el esperado
                        iCancelarVentaID = oCascoReg.CobroVentaID.Valor();  // Por si se realizó un cobro
                        // Por si se generó un vale
                        var oVale = Datos.GetEntity <NotaDeCredito>(c => c.OrigenID == Cat.OrigenesNotaDeCredito.CascoDeMayorValor &&
                                                                    c.RelacionID == oCascoReg.CascoRegistroID);
                        if (oVale != null)
                        {
                            VentasProc.CancelarNotaDeCredito(oVale.NotaDeCreditoID, "POR CANCELACIÓN DE VENTA CON CASCO");
                        }
                        // Si se utilizarn importes de caso a favor, se liberan
                        var oUsados = Datos.GetListOf <CascoRegistroImporte>(c => c.CascoRegistroID == oCascoReg.CascoRegistroID);
                        foreach (var oReg in oUsados)
                        {
                            var oCascoImp = Datos.GetEntity <CascoImporte>(c => c.CascoImporteID == oReg.CascoImporteID);
                            oCascoImp.ImporteUsado -= oReg.Importe.Valor();
                            Datos.Guardar <CascoImporte>(oCascoImp);
                            Datos.Eliminar <CascoRegistroImporte>(oReg);
                        }
                        // Si se creó un importe de caso a favor, se cancela
                        var oCascoImporte = Datos.GetEntity <CascoImporte>(c => c.OrigenID == oCascoReg.CascoRegistroID && c.Importe > 0);
                        if (oCascoImporte != null)
                        {
                            // Se verifica si ha sido usado
                            if (Datos.Exists <CascoRegistroImporte>(c => c.CascoImporteID == oCascoImporte.CascoImporteID))
                            {
                                // Se mete un Casco Importe negativo, porque ya fue usado
                                Datos.Guardar <CascoImporte>(new CascoImporte()
                                {
                                    Fecha    = DateTime.Now,
                                    OrigenID = oCascoReg.CascoRegistroID,
                                    Importe  = (oCascoImporte.Importe * -1)
                                });
                            }
                            else
                            {
                                // Se elimina el importe a favor
                                Datos.Eliminar <CascoImporte>(oCascoImporte);
                            }
                        }
                    }
                }

                // Se cancela la venta del cobro de la diferencia (sólo lo correspondiente al cobro), si aplica
                if (iCancelarVentaID > 0)
                {
                    int iDevParteID = Cat.Partes.DiferenciaDeCascos;
                    if (oCascoReg.RecibidoCascoID == null)
                    {
                        var oParte = Datos.GetEntity <Parte>(c => c.ParteID == oCascoReg.ParteID && c.Estatus);
                        iDevParteID = oParte.RequiereDepositoDe.Valor();
                        if (iDevParteID <= 0)
                        {
                            UtilLocal.MensajeError("El Artículo registrado en Control de Cascos no tiene un depósito asignado.");
                            break;
                        }
                    }

                    var oVentaDet = Datos.GetListOf <VentaDetalle>(c => c.VentaID == iCancelarVentaID && c.Estatus);
                    if (oVentaDet.Count > 0)
                    {
                        var oParteDet = oVentaDet.FirstOrDefault(c => c.ParteID == iDevParteID);
                        // Se obtiene la forma de pago
                        var oPagoDetV      = Datos.GetEntity <VentasPagosDetalleView>(c => c.VentaID == iCancelarVentaID);
                        int iFormaDePagoID = (oPagoDetV.Fecha.Valor().Date == DateTime.Now.Date ? oPagoDetV.FormaDePagoID : Cat.FormasDePago.Efectivo);
                        // Se general el registro de devolución
                        var oDevolucion = new VentaDevolucion()
                        {
                            VentaID          = iCancelarVentaID,
                            Fecha            = DateTime.Now,
                            SucursalID       = GlobalClass.SucursalID,
                            MotivoID         = Cat.VentaDevolucionMotivos.Otro,
                            Observacion      = "POR CANCELACIÓN DE VENTA CON CASCO",
                            RealizoUsuarioID = iUsuarioID,
                            TipoFormaPagoID  = iFormaDePagoID,
                            EsCancelacion    = (oVentaDet.Count == 1)
                        };
                        // Se genera el detalle de la devolución
                        var oDetDev = new VentaDevolucionDetalle()
                        {
                            ParteID           = iDevParteID,
                            Cantidad          = oParteDet.Cantidad,
                            PrecioUnitario    = oParteDet.PrecioUnitario,
                            Iva               = oParteDet.Iva,
                            Costo             = oParteDet.Costo,
                            CostoConDescuento = oParteDet.CostoConDescuento
                        };
                        // Se guarda la devolución
                        int iValeClienteID = 0;
                        if (iFormaDePagoID == Cat.FormasDePago.Vale)
                        {
                            var oVale = Datos.GetEntity <NotaDeCredito>(c => c.NotaDeCreditoID == oPagoDetV.NotaDeCreditoID && c.Estatus);
                            iValeClienteID = oVale.ClienteID;
                        }
                        this.GuardarDevolucion(oDevolucion, new List <VentaDevolucionDetalle>()
                        {
                            oDetDev
                        }, iValeClienteID);
                    }
                }
            }
        }
Exemple #8
0
        public JsonResult RecibirConteo(int eParam1, List <modConteoInventario> eParam2)
        {
            var oRes = AdmonProc.RecibirConteoInventario(eParam1, eParam2);

            return(this.Json(oRes));
        }
Exemple #9
0
        protected override void btnGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                if (!Validaciones())
                {
                    return;
                }

                if (EsNuevo)
                {
                }
                else
                {
                    int iAutorizoID = 0;
                    var ResU        = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
                    if (ResU.Exito)
                    {
                        iAutorizoID = ResU.Respuesta.UsuarioID;
                    }
                    else
                    {
                        Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
                        return;
                    }

                    SplashScreen.Show(new Splash());
                    this.btnGuardar.Enabled = false;

                    var ContingenciaCompleta = Datos.GetEntity <MovimientoInventarioContingenciasView>(c => c.MovimientoInventarioTraspasoContingenciaID == Contingencia.MovimientoInventarioTraspasoContingenciaID);
                    if (null == ContingenciaCompleta)
                    {
                        return;
                    }

                    //Actualiza la contingencia
                    Contingencia.FechaModificacion = DateTime.Now;
                    Contingencia.MovimientoInventarioEstatusContingenciaID = 1;
                    Contingencia.UsuarioID               = GlobalClass.UsuarioGlobal.UsuarioID;
                    Contingencia.UsuarioSolucionoID      = GlobalClass.UsuarioGlobal.UsuarioID;
                    Contingencia.FechaSoluciono          = DateTime.Now;
                    Contingencia.TipoOperacionID         = Util.Entero(this.cboTipoOperacion.SelectedValue);
                    Contingencia.TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue);
                    Contingencia.ObservacionSolucion     = this.txtObservacion.Text;
                    if (Util.Entero(this.cboTipoOperacion.SelectedValue) == Cat.TiposDeOperacionMovimientos.SalidaInventario)
                    {
                        Contingencia.ObservacionSolucion += (" - SE CREA UNA ENTRADA PARA DEVOLVER EL TRASPASO A LA TIENDA ORIGEN Y EN EL SEGUNDO MOVIMIENTO UNA SALIDA PARA PODER HACER LA SALIDA DEL INVENTARIO");
                    }
                    Contingencia.FechaModificacion = DateTime.Now;
                    Datos.SaveOrUpdate <MovimientoInventarioTraspasoContingencia>(Contingencia);

                    int    iSucursalID = ContingenciaCompleta.SucursalOrigenID.Valor();
                    string sOrigen     = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalOrigenID.Valor());
                    string sDestino    = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalDestinoID.Valor());
                    var    oPrecio     = Datos.GetEntity <PartePrecio>(c => c.ParteID == ContingenciaCompleta.ParteID && c.Estatus);

                    switch (Util.Entero(cboTipoOperacion.SelectedValue))
                    {
                    case 2:

                        #region [ Entrada Inventario ]

                        //Insertar Movimiento
                        var movimientoEntradaI = new MovimientoInventario()
                        {
                            TipoOperacionID   = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID        = 1,
                            ProveedorID       = 1,
                            SucursalOrigenID  = ContingenciaCompleta.SucursalOrigenID,
                            SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                            FechaFactura      = DateTime.Now,
                            FechaRecepcion    = DateTime.Now,
                            FolioFactura      = null,
                            Subtotal          = null,
                            IVA                      = null,
                            ImporteTotal             = 0,
                            FueLiquidado             = false,
                            TipoConceptoOperacionID  = ContingenciaCompleta.TipoConceptoOperacionID,
                            Observacion              = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
                            Articulos                = null,
                            Unidades                 = null,
                            Seguro                   = null,
                            ImporteTotalSinDescuento = null
                        };
                        Datos.Guardar <MovimientoInventario>(movimientoEntradaI);

                        if (movimientoEntradaI.MovimientoInventarioID < 1)
                        {
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        var detalleMovimiento = new MovimientoInventarioDetalle()
                        {
                            MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
                            ParteID        = ContingenciaCompleta.ParteID,
                            Cantidad       = Util.Decimal(ContingenciaCompleta.Diferencia),
                            PrecioUnitario = 0,
                            Importe        = 0,
                            FueDevolucion  = false,
                            FechaRegistro  = DateTime.Now,
                            Estatus        = true
                        };
                        Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimiento);

                        //Actualizar ParteExistencia

                        /* var sucursalId = ContingenciaCompleta.SucursalOrigenID;
                         * var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == ContingenciaCompleta.ParteID && p.SucursalID == sucursalId);
                         * if (existencia != null)
                         * {
                         *  existencia.Existencia += Util.ConvertirDecimal(ContingenciaCompleta.Diferencia);
                         *  Datos.Guardar<ParteExistencia>(existencia);//dmod
                         * }
                         */
                        // AdmonProc.AgregarExistencia(ContingenciaCompleta.ParteID, sucursalId.Valor(), ContingenciaCompleta.Diferencia.Valor()
                        //     , Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                        // Se modifica la existencia y el kardex
                        AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
                                                           , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Entrada"
                                                           , sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
                                                           , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);

                        #endregion

                        break;

                    case 3:

                        #region [ Salida Inventario ]

                        //Insertar Movimiento
                        var movimientoSalida = new MovimientoInventario()
                        {
                            TipoOperacionID   = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            TipoPagoID        = 1,
                            ProveedorID       = 1,
                            SucursalOrigenID  = ContingenciaCompleta.SucursalOrigenID,
                            SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
                            FechaFactura      = DateTime.Now,
                            FechaRecepcion    = DateTime.Now,
                            FolioFactura      = null,
                            Subtotal          = null,
                            IVA                      = null,
                            ImporteTotal             = 0,
                            FueLiquidado             = false,
                            TipoConceptoOperacionID  = Util.Entero(this.cboConceptoOperacion.SelectedValue),
                            Observacion              = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
                            Articulos                = null,
                            Unidades                 = null,
                            Seguro                   = null,
                            ImporteTotalSinDescuento = null
                        };
                        Datos.Guardar <MovimientoInventario>(movimientoSalida);

                        if (movimientoSalida.MovimientoInventarioID < 1)
                        {
                            new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
                            return;
                        }

                        //Insertar MovimientoDetalle
                        var detalleMovimientoS = new MovimientoInventarioDetalle()
                        {
                            MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
                            ParteID        = ContingenciaCompleta.ParteID,
                            Cantidad       = Util.Decimal(ContingenciaCompleta.Diferencia),
                            PrecioUnitario = 0,
                            Importe        = 0,
                            FueDevolucion  = false,
                            FechaRegistro  = DateTime.Now,
                            Estatus        = true
                        };
                        Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimientoS);

                        //No se descuenta por que ya se habia descontado en el traspaso anterior
                        // Ahora sí se generan dos registros en kardex, uno de entrada y luego uno de salida, para que al final quede igual
                        // Se hace así para mantener un registro de la operación
                        // Se hace primero la entrada
                        AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
                                                           , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
                                                           , sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
                                                           , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
                        // Luego la salida
                        AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.SalidaTraspaso
                                                           , Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
                                                           , sOrigen, sDestino, (ContingenciaCompleta.Diferencia.Valor() * -1)
                                                           , oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);

                        #endregion

                        break;

                    case 5:

                        #region [ Traspaso ]

                        //Almacenar traspaso
                        var traspaso = new MovimientoInventario()
                        {
                            TipoOperacionID           = Util.Entero(this.cboTipoOperacion.SelectedValue),
                            SucursalOrigenID          = ContingenciaCompleta.SucursalOrigenID,
                            SucursalDestinoID         = ContingenciaCompleta.SucursalDestinoID,
                            ImporteTotal              = 0,
                            FueLiquidado              = false,
                            UsuarioSolicitoTraspasoID = Contingencia.UsuarioSolucionoID,
                            ExisteContingencia        = false,
                            Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID)
                        };
                        Datos.Guardar <MovimientoInventario>(traspaso);

                        //Almacenar el detalle del traspaso
                        if (traspaso.MovimientoInventarioID > 0)
                        {
                            var detalleTraspaso = new MovimientoInventarioDetalle()
                            {
                                MovimientoInventarioID = traspaso.MovimientoInventarioID,
                                ParteID        = ContingenciaCompleta.ParteID,
                                Cantidad       = Util.Decimal(ContingenciaCompleta.Diferencia),
                                PrecioUnitario = 0,
                                Importe        = 0,
                                FueDevolucion  = false,
                                FechaRegistro  = DateTime.Now,
                                Estatus        = true
                            };
                            Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleTraspaso);

                            //No se descuenta por que ya se habia descontado en el primer traspaso
                        }

                        #endregion

                        break;

                    default:
                        break;
                    }
                }
                SplashScreen.Close();
                this.btnGuardar.Enabled = true;
                new Notificacion("Conflicto Resuelto exitosamente", 2 * 1000).Mostrar(Principal.Instance);
                catalogosTraspasos.Instance.CustomInvoke <catalogosTraspasos>(m => m.ActualizarListadoConflictos());
            }
            catch (Exception ex)
            {
                SplashScreen.Close();
                this.btnGuardar.Enabled = true;
                Util.MensajeError(ex.Message, GlobalClass.NombreApp);
            }
            this.Close();
        }
Exemple #10
0
        private bool AgregarGarantia()
        {
            // Se valida la parte de detalle
            if (!this.ctlDetalle.Validar())
            {
                return(false);
            }
            // Se valida la parte de búsqueda
            if (!this.ctlBusqueda.Validar())
            {
                return(false);
            }
            // Se valida que sólo esté seleccionada una parte
            if (this.ctlDetalle.ProductosSel().Count > 1)
            {
                UtilLocal.MensajeAdvertencia("Debes seleccionar sólo un producto al hacer una garantía.");
                return(false);
            }

            // Se verifica si se creará vale, para pedir el cliente en caso de que no haya
            var oGarantia      = this.ctlBusqueda.GenerarGarantia();
            int iVentaID       = this.ctlBusqueda.VentaID;
            var oVentaV        = Datos.GetEntity <VentasView>(q => q.VentaID == iVentaID);
            int iValeClienteID = oVentaV.ClienteID;

            if ((oGarantia.AccionID == Cat.VentasGarantiasAcciones.ArticuloNuevo || oGarantia.AccionID == Cat.VentasGarantiasAcciones.NotaDeCredito) &&
                iValeClienteID == Cat.Clientes.Mostrador)
            {
                iValeClienteID = VentasLoc.ObtenerClienteID("Selecciona el cliente para crear el Vale:", false);
                if (iValeClienteID == 0)
                {
                    return(false);
                }
            }

            // Se pregunta el usuario que realiza la devolución
            int iUsuarioID = 0;
            var ResU       = UtilLocal.ValidarObtenerUsuario("Ventas.Garantia.Agregar");

            if (ResU.Error)
            {
                return(false);
            }
            iUsuarioID = ResU.Respuesta.UsuarioID;

            // Se solicita la autorización
            int iAutorizoID = 0;

            ResU = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.Garantia.Agregar", "Autorización");
            if (ResU.Exito)
            {
                iAutorizoID = ResU.Respuesta.UsuarioID;
            }

            // Se procede a guardar los cambios
            DateTime dAhora = DateTime.Now;

            // Se genera la garantía
            oGarantia.Fecha             = dAhora;
            oGarantia.RealizoUsuarioID  = iUsuarioID;
            oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Recibido;
            // Se llenan los datos de la parte
            var oProducto = this.ctlDetalle.ProductosSel()[0];

            oGarantia.ParteID           = oProducto.ParteID;
            oGarantia.Costo             = oProducto.Costo;
            oGarantia.CostoConDescuento = oProducto.CostoConDescuento;
            oGarantia.PrecioUnitario    = oProducto.PrecioUnitario;
            oGarantia.Iva = oProducto.Iva;

            // Se guarda la garantía
            Guardar.VentaGarantia(oGarantia);

            // Si queda a revisión del proveedor, ya no se hace nada más que mandar el ticket
            if (oGarantia.AccionID != Cat.VentasGarantiasAcciones.RevisionDeProveedor)
            {
                this.CompletarAccionGarantia(oGarantia.VentaGarantiaID, iValeClienteID);
            }

            // Se mete un registro en kárdex, en cero, sólo para mantener historial de la operación
            var oKardex = new ParteKardex()
            {
                ParteID          = oGarantia.ParteID,
                OperacionID      = Cat.OperacionesKardex.VentaCancelada,
                SucursalID       = oGarantia.SucursalID,
                Folio            = oVentaV.Folio,
                Fecha            = dAhora,
                RealizoUsuarioID = iUsuarioID,
                Entidad          = oVentaV.Cliente,
                Origen           = oVentaV.Sucursal,
                Destino          = "GARANTÍA RECIBIDA",
                Cantidad         = 0,
                Importe          = (oGarantia.PrecioUnitario + oGarantia.Iva),
                RelacionTabla    = Cat.Tablas.VentaGarantia,
                RelacionID       = oGarantia.VentaGarantiaID
            };

            AdmonProc.RegistrarKardex(oKardex);

            // Se guarda la autorización, si aplica
            VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.Garantia, Cat.Tablas.VentaGarantia, oGarantia.VentaGarantiaID, iAutorizoID);
            // Se genera el ticket correspondiente
            VentasLoc.GenerarTicketGarantia(oGarantia.VentaGarantiaID);

            return(true);
        }