/// <summary>
        /// Evento generado al Solicitar un Depósito
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void wucAsigancionDeposito_ClickSolicitar(object sender, EventArgs e)
        {
            //Declaramos Objeto resultado
            RetornoOperacion resultado = new RetornoOperacion();

            //Declaramos Objeto Resultado
            resultado = ucDepositos.SolicitaDeposito();
            //Instanciando Deposito
            using (SAT_CL.EgresoServicio.Deposito dep = new SAT_CL.EgresoServicio.Deposito(resultado.IdRegistro))
            {
                //Validamos Resultado
                if (resultado.OperacionExitosa)
                {
                    //Validamos que el Deppósito se se encuentre Registrado
                    if (dep.id_estatus != 1)
                    {
                        //Mostramos Reporte Anticipos
                        mtvAnticipos.ActiveViewIndex = 2;
                        //cargamos Anticipos
                        cargaAnticipos();
                    }
                }
            }

            //Mostrando resultado
            ScriptServer.MuestraNotificacion(this.Page, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
        }
        /// <summary>
        /// Evento generado al Crear un Depósito
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void wucAsigancionDeposito_ClickRegistrar(object sender, EventArgs e)
        {
            //Declaramos Objeto resultado
            RetornoOperacion resultado = new RetornoOperacion();

            //Declaramos Objeto Resultado
            resultado = ucDepositos.RegistraDeposito();

            //Instanciando Deposito
            using (SAT_CL.EgresoServicio.Deposito dep = new SAT_CL.EgresoServicio.Deposito(resultado.IdRegistro))
            {
                //Instanciando Concepto de Deposito
                using (SAT_CL.EgresoServicio.ConceptoDeposito cd = new SAT_CL.EgresoServicio.ConceptoDeposito(dep.id_concepto))
                {
                    //Validando que existan los Registros
                    if (dep.habilitar && cd.habilitar)
                    {
                        //Validando que
                        if (!cd.descripcion.Equals("Anticipo Proveedor"))
                        {
                            //Validamos que el Deppósito se se encuentre Registrado
                            if (dep.id_estatus != 1)
                            {
                                //Mostramos Reporte Anticipos
                                mtvAnticipos.ActiveViewIndex = 2;
                                //cargamos Anticipos
                                cargaAnticipos();
                            }
                        }
                    }
                }
            }
            //Mostrando resultado
            ScriptServer.MuestraNotificacion(this.Page, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
        }
        /// <summary>
        /// Evento producido al pulsar el link Anticipos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lkbAnticipos_OnClick(object sender, EventArgs e)
        {
            //Validamos Existencia de Anticipos
            if (gvAnticipos.DataKeys.Count > 0)
            {
                //Seleccionando la fila actual
                Controles.SeleccionaFila(gvAnticipos, sender, "lnk", false);
                //Instanciamos Servicio
                using (SAT_CL.Documentacion.Servicio objServicio = new SAT_CL.Documentacion.Servicio(ucHistorialMovimiento.idServicio))
                {
                    //Si el tipo de operaciòn es Depòsito
                    if (gvAnticipos.SelectedDataKey["Tipo"].ToString() == "Deposito")
                    {
                        //Intsanciamos Antcipo
                        using (SAT_CL.EgresoServicio.Deposito objDeposito = new SAT_CL.EgresoServicio.Deposito(Convert.ToInt32(gvAnticipos.SelectedValue)))
                        {
                            //Instanciamos Detalle Liquidacion
                            using (SAT_CL.EgresoServicio.DetalleLiquidacion objDetalleLiquidacion = new SAT_CL.EgresoServicio.DetalleLiquidacion(objDeposito.id_deposito, 51))
                            {
                                //De acuerdo al Tipo de Asignación
                                SAT_CL.Despacho.MovimientoAsignacionRecurso.Tipo tipo = SAT_CL.Despacho.MovimientoAsignacionRecurso.Tipo.Operador;
                                int id_recurso = objDetalleLiquidacion.id_operador;
                                //Deacuerdo a la Asignación Actual
                                if (objDetalleLiquidacion.id_unidad != 0)
                                {
                                    //Asignamos Tipo Unidad
                                    tipo       = SAT_CL.Despacho.MovimientoAsignacionRecurso.Tipo.Unidad;
                                    id_recurso = objDetalleLiquidacion.id_unidad;
                                }
                                //Si la Asignación es Tercero
                                else if (objDetalleLiquidacion.id_operador != 0)
                                {
                                    //Asignamos Tercero
                                    tipo       = SAT_CL.Despacho.MovimientoAsignacionRecurso.Tipo.Tercero;
                                    id_recurso = objDetalleLiquidacion.id_proveedor_compania;
                                }
                                //Mostramos Vista Depòsito
                                mtvAnticipos.ActiveViewIndex = 0;
                                ucDepositos.HabilitaConcepto = false;
                                ucDepositos.MuestraSolicitar = true;

                                //Inicializamos Control Depòsito en Ediciòn
                                ucDepositos.InicializaControl(Convert.ToInt32(gvAnticipos.SelectedValue), objDetalleLiquidacion.id_unidad, objDetalleLiquidacion.id_operador, objDetalleLiquidacion.id_proveedor_compania,
                                                              objServicio.id_servicio, objDetalleLiquidacion.id_movimiento, SAT_CL.Despacho.MovimientoAsignacionRecurso.ObtieneAsignacionIniciadaTerminada(objDetalleLiquidacion.id_movimiento, tipo, id_recurso),
                                                              objServicio.id_cliente_receptor);
                            }
                        }
                    }
                    else
                    {
                        //Mostramos Vista Vale
                        mtvAnticipos.ActiveViewIndex = 1;
                        //Inicializando control de edición de vales
                        ucAsignacionDiesel.InicializaControlUsuario(Convert.ToInt32(gvAnticipos.SelectedValue));
                    }
                }
            }
        }
Exemple #4
0
        /// <summary>
        /// Realiza el cambio de operador
        /// </summary>
        public RetornoOperacion CambiaOperador()
        {
            RetornoOperacion retorno = new RetornoOperacion();
            //Creamos lita de registros
            List <KeyValuePair <string, byte[]> > registros = new List <KeyValuePair <string, byte[]> >();
            //Creamos lista de errores
            List <string> errores = new List <string>();

            //Verificando que el GridView contiene registros
            if (gvMovimientos.DataKeys.Count > 0)
            {
                //Obtiene filas seleccionadas
                GridViewRow[] selected_rows = Controles.ObtenerFilasSeleccionadas(gvMovimientos, "chkVarios");
                //Verificando que existan filas seleccionadas
                if (selected_rows.Length != 0)
                {
                    foreach (GridViewRow row in selected_rows)
                    {
                        gvMovimientos.SelectedIndex = row.RowIndex;
                        using (DataTable dtAsignaciones = SAT_CL.Despacho.MovimientoAsignacionRecurso.CargaAsignaciones(Convert.ToInt32(gvMovimientos.SelectedDataKey["NoMovimiento"]), MovimientoAsignacionRecurso.Estatus.Terminado))
                        {
                            if (Validacion.ValidaOrigenDatos(dtAsignaciones))
                            {
                                List <DataRow> operadores = (from DataRow op in dtAsignaciones.AsEnumerable()
                                                             where Convert.ToInt32(op["IdTipoAsignacion"]) == 2
                                                             select op).ToList();
                                if (operadores.Count > 0)
                                {
                                    using (TransactionScope trans = TSDK.Datos.Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
                                    {
                                        foreach (DataRow dr in operadores)
                                        {
                                            using (SAT_CL.Despacho.MovimientoAsignacionRecurso mar = new SAT_CL.Despacho.MovimientoAsignacionRecurso(Convert.ToInt32(dr["Id"])))
                                            {
                                                if (mar.habilitar)
                                                {
                                                    retorno = mar.ActualizaOperadorMovimientoAsignacionRecurso(Convert.ToInt32((Cadena.RegresaCadenaSeparada(txtNuevoOpe.Text, "ID:", 1, "1"))), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                    if (retorno.OperacionExitosa)
                                                    {
                                                        using (DataTable dtAnticipos = SAT_CL.EgresoServicio.DetalleLiquidacion.CargaAnticipos(Convert.ToInt32(gvMovimientos.SelectedDataKey["NoMovimiento"])))
                                                        {
                                                            if (dtAnticipos != null)
                                                            {
                                                                if (Validacion.ValidaOrigenDatos(dtAnticipos))
                                                                {
                                                                    List <DataRow> depositos = (from DataRow dep in dtAnticipos.AsEnumerable()
                                                                                                where Convert.ToInt32(dep["IdTabla"]) == 51
                                                                                                select dep).ToList();
                                                                    if (depositos.Count > 0)
                                                                    {
                                                                        foreach (DataRow de in depositos)
                                                                        {
                                                                            using (SAT_CL.EgresoServicio.Deposito d = new SAT_CL.EgresoServicio.Deposito(Convert.ToInt32(de["IdRegistro"])))
                                                                            {
                                                                                if (d.habilitar && d.objDetalleLiquidacion.habilitar)
                                                                                {
                                                                                    retorno = d.objDetalleLiquidacion.ActualizaOperadorDetalleLiquidacion(Convert.ToInt32((Cadena.RegresaCadenaSeparada(txtNuevoOpe.Text, "ID:", 1, "1"))), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                                                    if (retorno.OperacionExitosa)
                                                                                    {
                                                                                        if (!d.bit_efectivo)
                                                                                        {
                                                                                            using (CuentaBancos objCuentaBancos = CuentaBancos.ObtieneCuentaBanco(76, Convert.ToInt32((Cadena.RegresaCadenaSeparada(txtNuevoOpe.Text, "ID:", 1, "1"))), CuentaBancos.TipoCuenta.Default))
                                                                                            {
                                                                                                retorno = d.EditaDepositoCuentaDestino(objCuentaBancos.id_cuenta_bancos, ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                                                                if (retorno.OperacionExitosa)
                                                                                                {
                                                                                                    using (SAT_CL.Bancos.EgresoIngreso ei = new SAT_CL.Bancos.EgresoIngreso(51, Convert.ToInt32(de["IdRegistro"])))
                                                                                                    {
                                                                                                        if (ei.habilitar)
                                                                                                        {
                                                                                                            retorno = ei.EditaCuentaDestino(objCuentaBancos.id_cuenta_bancos, ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                                else
                                                                                {
                                                                                    retorno = new RetornoOperacion("No hay depositos para este movimiento");
                                                                                    break;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    List <DataRow> vales = (from DataRow val in dtAnticipos.AsEnumerable()
                                                                                            where Convert.ToInt32(val["IdTabla"]) == 69
                                                                                            select val).ToList();
                                                                    if (vales.Count > 0)
                                                                    {
                                                                        foreach (DataRow va in vales)
                                                                        {
                                                                            using (SAT_CL.EgresoServicio.DetalleLiquidacion dl = new SAT_CL.EgresoServicio.DetalleLiquidacion(Convert.ToInt32(va["IdRegistro"]), 69))
                                                                            {
                                                                                if (dl.habilitar)
                                                                                {
                                                                                    retorno = dl.ActualizaOperadorDetalleLiquidacion(Convert.ToInt32((Cadena.RegresaCadenaSeparada(txtNuevoOpe.Text, "ID:", 1, "1"))), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                                                    if (retorno.OperacionExitosa)
                                                                                    {
                                                                                        using (CuentaBancos objCuentaBancos = CuentaBancos.ObtieneCuentaBanco(76, Convert.ToInt32((Cadena.RegresaCadenaSeparada(txtNuevoOpe.Text, "ID:", 1, "1"))), CuentaBancos.TipoCuenta.Default))
                                                                                        {
                                                                                            //    retorno = d.EditaDepositoCuentaDestino(objCuentaBancos.id_cuenta_bancos, ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                                                            //if (retorno.OperacionExitosa)
                                                                                            //{
                                                                                            using (SAT_CL.Bancos.EgresoIngreso ei = new SAT_CL.Bancos.EgresoIngreso(51, Convert.ToInt32(va["IdRegistro"])))
                                                                                            {
                                                                                                if (ei.habilitar)
                                                                                                {
                                                                                                    retorno = ei.EditaCuentaDestino(objCuentaBancos.id_cuenta_bancos, ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        // }
                                                                                        //}
                                                                                    }
                                                                                }
                                                                                else
                                                                                {
                                                                                    retorno = new RetornoOperacion("No hay vales para este movimiento");
                                                                                    break;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    retorno = new RetornoOperacion("No hay anticipos para este movimiento");
                                                                    break;
                                                                }
                                                            }
                                                            //(retorno.OperacionExitosa)
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    retorno = new RetornoOperacion("No se puede recuperar la asignacion");
                                                    break;
                                                }
                                            }
                                        }
                                        if (retorno.OperacionExitosa)
                                        {
                                            trans.Complete();
                                        }
                                    }
                                }
                                else
                                {
                                    retorno = new RetornoOperacion("No hay operadores para este movimiento");
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            return(retorno);
        }