/// <summary>
        /// Evento de clic del botón Guardar
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void imgbtnGuardar_Click(object sender, DirectEventArgs e)
        {
            //1. Obtener datos de la Forma y saber si es edición o nuevo
            string strVolumetriaForma        = e.ExtraParams["VolumetriaForma"];
            string strVolumetria             = e.ExtraParams["Volumetria"];
            string strSucursal               = e.ExtraParams["Sucursal"];
            string strVolumetriaD            = e.ExtraParams["VolumetriaD"];
            string strcookieEditarVolumetria = Cookies.GetCookie("cookieEditarVolumetria").Value;

            //2. Serializar el encabezado y el detalle
            Dictionary <string, string> dRegistro = JSON.Deserialize <Dictionary <string, string> >(strVolumetriaForma);
            Volumetria         oFormaVolumetria   = ObtenerObjetoDesdeForma(dRegistro, strSucursal);
            Volumetria         oVolumetria        = JSON.Deserialize <List <Volumetria> >(strVolumetria).FirstOrDefault();
            List <VolumetriaD> lVolumetriaD       = JSON.Deserialize <List <VolumetriaD> >(strVolumetriaD);

            //3. Guardar o Actuaizar el Movimiento
            string strAccion = GuardarMovimiento(ref oFormaVolumetria, oVolumetria, lVolumetriaD);

            //4. Validar que efecto realizará para Guardar o Afectar
            switch (strAccion)
            {
            case "insertar":
                e.ExtraParamsResponse.Add(new Ext.Net.Parameter("accion", "insertar", ParameterMode.Value));
                break;

            case "modificar":
                e.ExtraParamsResponse.Add(new Ext.Net.Parameter("accion", "modificar", ParameterMode.Value));
                break;
            }
        }
示例#2
0
        public ViewResult VolumetriaResumo( )
        {
            Volumetria modelo = new Volumetria();

            modelo = sqlData.RetornaVolumetriaResumo(contexto.idOrganizacao);
            return(View(modelo));
        }
        /// <summary>
        /// Obtener un registro de Volumetrias por su ID
        /// </summary>
        /// <param name="iID"></param>
        /// <returns></returns>
        public static Volumetria ObtenerVolumetriaPorID(int iID)
        {
            //1. Inicializar objeto, complementarlo con la Sucursal
            Volumetria oVolumetria = VolumetriaDataAccess.ObtenerVolumetriaPorID(iID);

            oVolumetria.RSucursal  = SucursalBusiness.ObtenerSucursalPorID(oVolumetria.Sucursal);
            oVolumetria.RPreciario = PreciarioBusiness.ObtenerPreciarioPorID(oVolumetria.Preciario);
            if (oVolumetria.Cliente != null)
            {
                oVolumetria.RCliente = ClienteBusiness.ObtenerClientePorID(oVolumetria.Cliente);
            }
            return(oVolumetria);
        }
 /// <summary>
 /// Evento que Guarda el detalle de Volumetrias
 /// </summary>
 /// <param name="lRevisionD"></param>
 /// <param name="oRevisionForma"></param>
 private void GuardarDetalleVolumetria(List <VolumetriaD> lVolumetriaD, Volumetria oVolumetriaForma)
 {
     //1. Insertar los datos del detalle
     foreach (VolumetriaD sd in lVolumetriaD)
     {
         //2. Validar que el objeto no venga en blanco
         if (sd.ConceptoID.Equals(string.Empty) || sd.Cantidad.Equals(string.Empty) || sd.Utilizada == 0)
         {
             continue;
         }
         else
         {
             sd.Volumetria = oVolumetriaForma.ID;
             VolumetriaDBusiness.Insertar(sd);
             PreciarioConceptoBusiness.Actualizar(sd.ConceptoID, sd.Utilizada, sd.Volumetria);
         }
     }
 }
        /// <summary>
        /// Evento de clic del botón Afectar
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void imgbtnAfectar_Click(object sender, DirectEventArgs e)
        {
            //1. Obtener datos de la Forma y saber si es edición o nuevo
            string strVolumetriaForma        = e.ExtraParams["VolumetriaForma"];
            string strVolumetria             = e.ExtraParams["Volumetria"];
            string strSucursal               = e.ExtraParams["sucursal"];
            string strVolumetriaD            = e.ExtraParams["VolumetriaD"];
            string strcookieEditarVolumetria = Cookies.GetCookie("cookieEditarVolumetria").Value;

            //2. Serializar el encabezado y el detalle
            Dictionary <string, string> dRegistro = JSON.Deserialize <Dictionary <string, string> >(strVolumetriaForma);
            Volumetria         oVolumetriaForma   = ObtenerObjetoDesdeForma(dRegistro, strSucursal);
            Volumetria         oVolumetria        = JSON.Deserialize <List <Volumetria> >(strVolumetria).FirstOrDefault();
            List <VolumetriaD> lVolumetriaD       = JSON.Deserialize <List <VolumetriaD> >(strVolumetriaD);

            //3. Guardar o Actuaizar el Movimiento
            string strAccion = GuardarMovimiento(ref oVolumetriaForma, oVolumetria, lVolumetriaD);

            //4. Validar que efecto realizará para Guardar o Afectar
            switch (strAccion)
            {
            case "insertar":
                e.ExtraParamsResponse.Add(new Ext.Net.Parameter("accion", "insertar", ParameterMode.Value));
                break;

            case "modificar":
                e.ExtraParamsResponse.Add(new Ext.Net.Parameter("accion", "modificar", ParameterMode.Value));
                break;
            }

            //4. Lanzar la afectación del Movimiento
            VolumetriaBusiness.AfectarVolumetriaPorID(oVolumetriaForma);

            //Actualiza las cantidades despues de afectar
            foreach (VolumetriaD sd in lVolumetriaD)
            {
                PreciarioConceptoBusiness.Actualizar(sd.ConceptoID, sd.Utilizada, sd.Volumetria);
            }

            oVolumetria = VolumetriaBusiness.ObtenerVolumetriaPorID(oVolumetriaForma.ID);
            //7. Actualizar store de Revision
            sVolumetria.GetAt(0).Set("MovID", oVolumetria.MovID);
            sVolumetria.GetAt(0).Set("Estatus", oVolumetria.Estatus);
        }
        /// <summary>
        /// Método que transforma los datos Control-Valor a objeto Volumetria
        /// </summary>
        /// <param name="dRegistro"></param>
        /// <returns></returns>
        private Volumetria ObtenerObjetoDesdeForma(Dictionary <string, string> dRegistro, string strSucursal)
        {
            //1. Declarar objeto Volumetria donde se guardarán los valores
            Volumetria oVolumetriaForma = new Volumetria();

            //2. Por cada elemento del submit de la Forma detectar el campo y asignarlo al objeto correspondiente
            foreach (KeyValuePair <string, string> sd in dRegistro)
            {
                switch (sd.Key)
                {
                //4. Datos de la revisión
                case "cmbMov":
                    oVolumetriaForma.Mov = sd.Value;
                    break;

                case "cmbPreciario":
                    oVolumetriaForma.Preciario = sd.Value;
                    break;

                case "dfFechaEmision":
                    oVolumetriaForma.FechaEmision = Convert.ToDateTime(sd.Value);
                    break;

                case "txtfObservaciones":
                    oVolumetriaForma.Observaciones = sd.Value;
                    break;

                case "IdCliente":
                    oVolumetriaForma.RCliente = ClienteBusiness.ObtenerClientePorID(sd.Value);
                    break;

                case "txtCliente":
                    oVolumetriaForma.Cliente = sd.Value;
                    break;
                }
            }
            oVolumetriaForma.Estatus  = "BORRADOR";
            oVolumetriaForma.Sucursal = strSucursal;
            //3. Regresar la Revision
            return(oVolumetriaForma);
        }
        /// <summary>
        /// Obtener un registro de Volumetrias por su ID
        /// </summary>
        /// <param name="iID"></param>
        /// <returns></returns>
        public static Volumetria ObtenerVolumetriaPorID(int iID)
        {
            try
            {
                //1. Configurar la conexión y el tipo de comando
                SqlConnection sqlcConectar = new SqlConnection(ConfigurationManager.ConnectionStrings["OSEF"].ConnectionString);
                SqlCommand    sqlcComando  = new SqlCommand();
                sqlcComando.Connection  = sqlcConectar;
                sqlcComando.CommandType = CommandType.StoredProcedure;
                sqlcComando.CommandText = "web_spS_ObtenerVolumetriasPorID";

                //2. Declarar los parametros
                SqlParameter sqlpID = new SqlParameter();
                sqlpID.ParameterName = "@ID";
                sqlpID.SqlDbType     = SqlDbType.Int;
                sqlpID.Value         = iID;

                //3. Agregar los parametros al comando
                sqlcComando.Parameters.Add(sqlpID);

                //4. Abrir la conexión
                sqlcComando.Connection.Open();

                //5. Ejecutar la instrucción SELECT que regresa filas
                SqlDataReader reader = sqlcComando.ExecuteReader();

                //6. Asignar la lista de Clientes
                Volumetria result = LibraryGenerics <Volumetria> .ConvertDataSetToList(reader).FirstOrDefault();

                //7. Cerrar la conexión
                sqlcComando.Connection.Close();

                //8. Regresar el resultado
                return(result);
            }
            catch (Exception ex)
            {
                throw new Exception("Error capa de datos (public static Volumetria ObtenerVolumetriaPorID(int " + iID + ")): " + ex.Message);
            }
        }
        /// <summary>
        /// Método que Afecta un registro de Volumetria
        /// </summary>
        /// <param name="aVolumetria"></param>
        public static int AfectarVolumetriaPorID(Volumetria aVolumetria)
        {
            try
            {
                //1. Configurar la conexión y el tipo de comando
                SqlConnection sqlcConectar = new SqlConnection(ConfigurationManager.ConnectionStrings["OSEF"].ConnectionString);
                SqlCommand    sqlcComando  = new SqlCommand();
                sqlcComando.Connection  = sqlcConectar;
                sqlcComando.CommandType = CommandType.StoredProcedure;
                sqlcComando.CommandText = "web_spS_AfectarVolumetriaPorID";

                //2. Declarar los parametros
                SqlParameter sqlpID = new SqlParameter();
                sqlpID.ParameterName = "@ID";
                sqlpID.SqlDbType     = SqlDbType.Int;
                sqlpID.Value         = aVolumetria.ID;

                //3. Agregar los parametros al comando
                sqlcComando.Parameters.Add(sqlpID);

                //4. Abrir la conexión
                sqlcComando.Connection.Open();

                //5. Ejecutar la instrucción UPDATE que no regresa filas
                int result = sqlcComando.ExecuteNonQuery();

                //6. Cerrar la conexión
                sqlcComando.Connection.Close();

                //7. Regresar el resultado
                return(result);
            }
            catch (Exception ex)
            {
                throw new Exception("Error capa de datos (public static int AfectarVolumetriaPorID(Volumetria " + aVolumetria + ")): " + ex.Message);
            }
        }
        public void sVolumetria_Load()
        {
            //Obtener la cookie al cargar
            string strcookieEditarVolumetria = Cookies.GetCookie("cookieEditarVolumetria").Value;

            //Validar si es diferente de Nuevo
            if (!strcookieEditarVolumetria.Equals("Nuevo"))
            {
                //Cargar el encabezado del movimiento
                Volumetria oVolumetria = VolumetriaBusiness.ObtenerVolumetriaPorID(Convert.ToInt32(strcookieEditarVolumetria));

                //Cargar el detalle del movimiento
                //Cargar el detalle del movimiento
                sConceptos.DataSource = VolumetriaDBusiness.ObtenerVolumetriaDPorVolumetria(oVolumetria.ID);
                sConceptos.DataBind();

                sVolumetria.Add(new
                {
                    ID            = oVolumetria.ID,
                    Mov           = oVolumetria.Mov,
                    MovID         = oVolumetria.MovID,
                    Sucursal      = oVolumetria.Sucursal,
                    FechaEmision  = oVolumetria.FechaEmision,
                    Observaciones = oVolumetria.Observaciones,
                    Estatus       = oVolumetria.Estatus,
                    Usuario       = oVolumetria.Usuario,
                    Preciario     = oVolumetria.Preciario,
                    RPreciario    = oVolumetria.RPreciario,
                    RSucursal     = oVolumetria.RSucursal,
                    Origen        = oVolumetria.Origen,
                    OrigenID      = oVolumetria.Origenid,
                    Cliente       = oVolumetria.Cliente,
                    RCliente      = oVolumetria.RCliente
                });
            }
        }
        /// <summary>
        /// Evento que Guarda o actualiza un Movimiento
        /// </summary>
        /// <param name="oVolumetriaForma"></param>
        /// <param name="oVolumetria"></param>
        /// <param name="lVolumetriaD"></param>
        private string GuardarMovimiento(ref Volumetria oVolumetriaForma, Volumetria oVolumetria, List <VolumetriaD> lVolumetriaD)
        {
            //1. Lo que sucede cuando es nuevo y no se habia guardado
            if (oVolumetria == null)
            {
                //Checar ticket de autenticación
                UsuarioBusiness.checkValidSession(this);
                //2. Traemeos el objeto de sesion para llenr el objeto con los datos de usuario
                Usuario oUsuario = (Usuario)Session["Usuario"];
                oVolumetriaForma.Usuario = oUsuario.ID;

                //3. Actualizamos el Estatus e Insertar en la base de datos
                oVolumetriaForma.Estatus = "BORRADOR";
                oVolumetriaForma.ID      = VolumetriaBusiness.insertarVolumetria(oVolumetriaForma);

                //4. Agregar el objeto al Store de Revisión
                sVolumetria.Add(new
                {
                    ID            = oVolumetriaForma.ID,
                    Mov           = oVolumetriaForma.Mov,
                    MovID         = oVolumetriaForma.MovID,
                    Sucursal      = oVolumetriaForma.Sucursal,
                    FechaEmision  = oVolumetriaForma.FechaEmision,
                    Observaciones = oVolumetriaForma.Observaciones,
                    Preciario     = oVolumetriaForma.Preciario,
                    RPreciario    = oVolumetriaForma.RPreciario,
                    RSucursal     = oVolumetriaForma.RSucursal,
                    Estatus       = oVolumetriaForma.Estatus,
                    Usuario       = oVolumetriaForma.Usuario,
                    //Cliente = oVolumetriaForma.Cliente,
                    RCliente = oVolumetriaForma.RCliente
                });

                //5. Guardar Detalle y regresar valor
                GuardarDetalleVolumetria(lVolumetriaD, oVolumetriaForma);
                return("insertar");
            }
            else
            {
                //6. Complementar datos y actualizar encabezado

                oVolumetriaForma.ID = oVolumetria.ID;
                //if (oVolumetriaForma.Cliente == null)
                //{
                //    oVolumetriaForma.Cliente = "";
                //    oVolumetria.RCliente.ID = "";
                //}
                VolumetriaBusiness.actualizarVolumetria(oVolumetriaForma);

                //7. Actualizar store de Revision
                sVolumetria.GetAt(0).Set("Mov", oVolumetriaForma.Mov);
                sVolumetria.GetAt(0).Set("Sucursal", oVolumetriaForma.Sucursal);
                sVolumetria.GetAt(0).Set("Preciario", oVolumetriaForma.Preciario);
                sVolumetria.GetAt(0).Set("FechaEmision", oVolumetriaForma.FechaEmision);
                sVolumetria.GetAt(0).Set("Observaciones", oVolumetriaForma.Observaciones);
                //sVolumetria.GetAt(0).Set("Cliente", oVolumetriaForma.Cliente);

                //8. Borrar todo el detalle e insertarlo de nuevo
                VolumetriaDBusiness.BorrarPorVolumetria(oVolumetriaForma.ID);
                GuardarDetalleVolumetria(lVolumetriaD, oVolumetriaForma);

                //9. Regresar valor
                return("modificar");
            }
        }
示例#11
0
 /// <summary>
 /// Método que actualiza un registro en la tabla de Volumetrias
 /// </summary>
 /// <param name="iRevision"></param>
 public static int actualizarVolumetria(Volumetria uVolumetria)
 {
     return(VolumetriaDataAccess.Actualizar(uVolumetria));
 }
示例#12
0
 /// <summary>
 /// Método que inserta un nuevo registro a la tabla de Volumetrias
 /// </summary>
 /// <param name="iRevision"></param>
 public static int insertarVolumetria(Volumetria iVolumetria)
 {
     return(VolumetriaDataAccess.Insertar(iVolumetria));
 }
示例#13
0
 /// <summary>
 /// Método que Afecta un registro de Volumetrias
 /// </summary>
 /// <param name="aVolumetria"></param>
 public static int AfectarVolumetriaPorID(Volumetria aVolumetria)
 {
     return(VolumetriaDataAccess.AfectarVolumetriaPorID(aVolumetria));
 }
        /// <summary>
        /// Método que inserta un nuevo registro a la tabla de Volumetrias
        /// </summary>
        /// <param name="iVolumetria"></param>
        public static int Insertar(Volumetria iVolumetria)
        {
            try
            {
                //1. Configurar la conexión y el tipo de comando
                SqlConnection sqlcConectar = new SqlConnection(ConfigurationManager.ConnectionStrings["OSEF"].ConnectionString);
                SqlCommand    sqlcComando  = new SqlCommand();
                sqlcComando.Connection  = sqlcConectar;
                sqlcComando.CommandType = CommandType.StoredProcedure;
                sqlcComando.CommandText = "web_spI_InsertarVolumetria";

                //2. Declarar los parametros
                SqlParameter sqlpID = new SqlParameter();
                sqlpID.ParameterName = "@ID";
                sqlpID.SqlDbType     = SqlDbType.Int;
                sqlpID.Direction     = ParameterDirection.Output;

                SqlParameter sqlpMov = new SqlParameter();
                sqlpMov.ParameterName = "@Mov";
                sqlpMov.SqlDbType     = SqlDbType.VarChar;
                sqlpMov.Value         = iVolumetria.Mov;

                SqlParameter sqlpMovID = new SqlParameter();
                sqlpMovID.ParameterName = "@MovID";
                sqlpMovID.SqlDbType     = SqlDbType.VarChar;
                if (iVolumetria.MovID == null)
                {
                    sqlpMovID.Value = DBNull.Value;
                }
                else
                {
                    sqlpMovID.Value = iVolumetria.MovID;
                }

                SqlParameter sqlpSucursal = new SqlParameter();
                sqlpSucursal.ParameterName = "@Sucursal";
                sqlpSucursal.SqlDbType     = SqlDbType.Char;
                sqlpSucursal.Size          = 10;
                sqlpSucursal.Value         = iVolumetria.Sucursal;

                SqlParameter sqlpFechaEmision = new SqlParameter();
                sqlpFechaEmision.ParameterName = "@FechaEmision";
                sqlpFechaEmision.SqlDbType     = SqlDbType.SmallDateTime;
                sqlpFechaEmision.Value         = iVolumetria.FechaEmision;

                SqlParameter sqlpObservaciones = new SqlParameter();
                sqlpObservaciones.ParameterName = "@Observaciones";
                sqlpObservaciones.SqlDbType     = SqlDbType.VarChar;
                sqlpObservaciones.Value         = iVolumetria.Observaciones;

                SqlParameter sqlpEstatus = new SqlParameter();
                sqlpEstatus.ParameterName = "@Estatus";
                sqlpEstatus.SqlDbType     = SqlDbType.VarChar;
                sqlpEstatus.Value         = iVolumetria.Estatus;

                SqlParameter sqlpUsuario = new SqlParameter();
                sqlpUsuario.ParameterName = "@Usuario";
                sqlpUsuario.SqlDbType     = SqlDbType.VarChar;
                sqlpUsuario.Value         = iVolumetria.Usuario;

                SqlParameter sqlpPreciario = new SqlParameter();
                sqlpPreciario.ParameterName = "@Preciario";
                sqlpPreciario.SqlDbType     = SqlDbType.Char;
                sqlpPreciario.Size          = 7;
                sqlpPreciario.Value         = iVolumetria.Preciario;

                SqlParameter sqlpCliente = new SqlParameter();
                sqlpCliente.ParameterName = "@Cliente";
                sqlpCliente.SqlDbType     = SqlDbType.Char;
                sqlpCliente.Size          = 8;
                sqlpCliente.Value         = iVolumetria.RCliente.ID;

                //3. Agregar los parametros al comando
                sqlcComando.Parameters.Add(sqlpID);
                sqlcComando.Parameters.Add(sqlpMov);
                sqlcComando.Parameters.Add(sqlpMovID);
                sqlcComando.Parameters.Add(sqlpSucursal);
                sqlcComando.Parameters.Add(sqlpFechaEmision);
                sqlcComando.Parameters.Add(sqlpObservaciones);
                sqlcComando.Parameters.Add(sqlpEstatus);
                sqlcComando.Parameters.Add(sqlpUsuario);
                sqlcComando.Parameters.Add(sqlpPreciario);
                sqlcComando.Parameters.Add(sqlpCliente);

                //4. Abrir la conexión
                sqlcComando.Connection.Open();

                //5. Ejecutar la instrucción INSERT que regresa un dato que es el ID
                int result = Convert.ToInt32(sqlcComando.ExecuteScalar());

                //6. Cerrar la conexión
                sqlcComando.Connection.Close();

                //7. Regresar el resultado
                return(Convert.ToInt32(sqlcComando.Parameters["@ID"].Value));
            }
            catch (Exception ex)
            {
                throw new Exception("Error capa de datos (public static int Insertar(Volumetria " + iVolumetria.Mov + ")): " + ex.Message);
            }
        }
        /// <summary>
        /// Método que actualiza un nuevo registro a la tabla de Volumetrias
        /// </summary>
        /// <param name="uVolumetria"></param>
        public static int Actualizar(Volumetria uVolumetria)
        {
            try
            {
                //1. Configurar la conexión y el tipo de comando
                SqlConnection sqlcConectar = new SqlConnection(ConfigurationManager.ConnectionStrings["OSEF"].ConnectionString);
                SqlCommand    sqlcComando  = new SqlCommand();
                sqlcComando.Connection  = sqlcConectar;
                sqlcComando.CommandType = CommandType.StoredProcedure;
                sqlcComando.CommandText = "web_spU_ActualizarVolumetria";

                //2. Declarar los parametros
                SqlParameter sqlpID = new SqlParameter();
                sqlpID.ParameterName = "@ID";
                sqlpID.SqlDbType     = SqlDbType.Int;
                sqlpID.Value         = uVolumetria.ID;

                SqlParameter sqlpMov = new SqlParameter();
                sqlpMov.ParameterName = "@Mov";
                sqlpMov.SqlDbType     = SqlDbType.VarChar;
                sqlpMov.Value         = uVolumetria.Mov;

                SqlParameter sqlpMovID = new SqlParameter();
                sqlpMovID.ParameterName = "@MovID";
                sqlpMovID.SqlDbType     = SqlDbType.VarChar;
                if (uVolumetria.MovID == null)
                {
                    sqlpMovID.Value = DBNull.Value;
                }
                else
                {
                    sqlpMovID.Value = uVolumetria.MovID;
                }

                SqlParameter sqlpSucursal = new SqlParameter();
                sqlpSucursal.ParameterName = "@Sucursal";
                sqlpSucursal.SqlDbType     = SqlDbType.VarChar;
                sqlpSucursal.Value         = uVolumetria.Sucursal;

                SqlParameter sqlpObservaciones = new SqlParameter();
                sqlpObservaciones.ParameterName = "@Observaciones";
                sqlpObservaciones.SqlDbType     = SqlDbType.VarChar;
                sqlpObservaciones.Value         = uVolumetria.Observaciones;

                SqlParameter sqlpEstatus = new SqlParameter();
                sqlpEstatus.ParameterName = "@Estatus";
                sqlpEstatus.SqlDbType     = SqlDbType.VarChar;
                sqlpEstatus.Value         = uVolumetria.Estatus;

                SqlParameter sqlpPreciario = new SqlParameter();
                sqlpPreciario.ParameterName = "@Preciario";
                sqlpPreciario.SqlDbType     = SqlDbType.Char;
                sqlpPreciario.Size          = 7;
                sqlpPreciario.Value         = uVolumetria.Preciario;

                SqlParameter sqlpCliente = new SqlParameter();
                sqlpCliente.ParameterName = "@Cliente";
                sqlpCliente.SqlDbType     = SqlDbType.Char;
                if (uVolumetria.Cliente == null || uVolumetria.Cliente.Trim().Equals(""))
                {
                    sqlpCliente.Value = DBNull.Value;
                }
                else
                {
                    sqlpCliente.Value = uVolumetria.RCliente.ID;
                }

                //3. Agregar los parametros al comando
                sqlcComando.Parameters.Add(sqlpID);
                sqlcComando.Parameters.Add(sqlpMov);
                sqlcComando.Parameters.Add(sqlpMovID);
                sqlcComando.Parameters.Add(sqlpSucursal);
                sqlcComando.Parameters.Add(sqlpObservaciones);
                sqlcComando.Parameters.Add(sqlpEstatus);
                sqlcComando.Parameters.Add(sqlpPreciario);
                sqlcComando.Parameters.Add(sqlpCliente);

                //4. Abrir la conexión
                sqlcComando.Connection.Open();

                //5. Ejecutar la instrucción UPDATE que no regresa filas
                int result = sqlcComando.ExecuteNonQuery();

                //6. Cerrar la conexión
                sqlcComando.Connection.Close();

                //7. Regresar el resultado
                return(result);
            }
            catch (Exception ex)
            {
                throw new Exception("Error capa de datos (public static int Actualizar(Volumetría " + uVolumetria.ID + ")): " + ex.Message);
            }
        }