Esempio n. 1
0
        /// <summary>
        /// Borra físicamente un registro de a tabla: Alertas
        /// </summary>
        /// <param name="p_dbcAccess">Conexion a la base de datos</param>
        /// <param name="p_iNroconfig">Nro Config Alerta</param>
        /// <param name="p_iNroalerta">Nro Alerta</param>
        /// <param name="p_iFxdVersion">Versión del registro a borrar</param>
        /// <param name="p_smResult">Estado final de la operacion</param>
        internal static void AleDrop(DBConn p_dbcAccess,
                                     int p_iNroconfig,
                                     int p_iNroalerta,
                                     int p_iFxdVersion,
                                     StatMsg p_smResult)
        {
            try {
                // Verificamos la clave a borrar
                AleVKey(p_dbcAccess,
                        p_iNroconfig,
                        p_iNroalerta,
                        p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // El registro tiene que existir
                if (p_smResult.ICodeEs(BllCodes.KeyDsntFound))
                {
                    // Error. La clave no existe
                    p_smResult.BllWarning("El ítem (Alerta) que intenta borrar no existe en el sistema.", "");
                    return;
                }

                // Debe coincidir el número de version
                AleVVer(p_dbcAccess,
                        p_iNroconfig,
                        p_iNroalerta,
                        p_iFxdVersion,
                        p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // Borramos físicamente el registro
                Dal.Alertas.Drop(p_dbcAccess,
                                 p_iNroconfig,
                                 p_iNroalerta,
                                 p_smResult);
            }
            catch (Exception l_expData) {
                // Error en la operacion Remove
                p_smResult.BllError(l_expData);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Agrega o modifica un registro de la tabla: Servicios
        /// </summary>
        /// <param name="p_dbcAccess">Conexion a la base de datos</param>
        /// <param name="p_entServicio">Entidad con los datos a procesar</param>
        /// <param name="p_smResult">Estado final de la operacion</param>
        internal static void SSav(DBConn p_dbcAccess,
                                  EServicio p_entServicio,
                                  StatMsg p_smResult)
        {
            try {
                // Procesamos codigo fijo
                Save_f(p_dbcAccess, ref p_entServicio, p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // Verificamos la clave a grabar
                VKey(p_dbcAccess,
                     p_entServicio.Cod,
                     p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // Si es una entidad nueva
                if (p_entServicio.EsNueva)
                {
                    // Es un alta. La clave no debe existir
                    if (!p_smResult.ICodeEs(BllCodes.KeyDsntFound))
                    {
                        // Error. La clave ya existe
                        p_smResult.BllWarning("El ítem (Servicio) que intenta agregar ya existe en el sistema.", "");
                        return;
                    }

                    // Agregamos el registro
                    Insr(p_dbcAccess, p_entServicio, p_smResult);
                    return;
                }

                // Es un update. La clave debe existir y estar habilitada
                if (!p_smResult.ICodeEs(BllCodes.KeyExists))
                {
                    // Error. La clave no existe o no está habilitada
                    p_smResult.BllWarning("El ítem (Servicio) que intenta modificar no existe en el sistema o no está habilitado.", "");
                    return;
                }

                // Debe coincidir el número de version
                VVer(p_dbcAccess,
                     p_entServicio.Cod,
                     p_entServicio.FxdVersion,
                     p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // Actualizamos el registro
                Updt(p_dbcAccess, p_entServicio, p_smResult);
            }
            catch (Exception l_expData) {
                // Error en la operacion SSav
                p_smResult.BllError(l_expData);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Habilita/Deshabilita un registro de la tabla: Servicios
        /// </summary>
        /// <param name="p_bEnable">Tipo de operacion</param>
        /// <param name="p_strCod">Código</param>
        /// <param name="p_smResult">Estado final de la operacion</param>
        public static void Enabled(bool p_bEnable,
                                   string p_strCod,
                                   int p_iFxdVersion,
                                   StatMsg p_smResult)
        {
            // No hay errores aun
            DBConn l_dbcAccess = null;

            // Ajustamos codigos alineados a derecha
            p_strCod = EServicio.FrmtCod(p_strCod);

            try {
                // Obtenemos una conexion
                l_dbcAccess = DBRuts.GetConection(Connections.Dat);
                l_dbcAccess.BeginTransaction();

                // Procesamos codigo fijo
                Enabled_f(l_dbcAccess,
                          p_bEnable,
                          p_strCod,
                          ref p_iFxdVersion,
                          p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // Verificamos la clave a modificar
                VKey(l_dbcAccess,
                     p_strCod,
                     p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // El registro tiene que existir
                if (p_smResult.ICodeEs(BllCodes.KeyDsntFound))
                {
                    // Error. La clave no existe
                    p_smResult.BllWarning("El ítem (Servicio) que intenta modificar no existe en el sistema.", "");
                    return;
                }

                // Debe coincidir el número de version
                VVer(l_dbcAccess,
                     p_strCod,
                     p_iFxdVersion,
                     p_smResult);
                if (p_smResult.NOk)
                {
                    return;
                }

                // Segun el modo
                if (p_bEnable)
                {
                    // Hay que habilitar el registro
                    Dal.Servicios.Recall(l_dbcAccess,
                                         p_strCod,
                                         p_smResult);
                }
                else
                {
                    // Hay que deshabilitar el registro
                    Dal.Servicios.Delete(l_dbcAccess,
                                         p_strCod,
                                         p_smResult);
                }
            }
            catch (Exception l_expData) {
                // Error en la operacion Enabled
                p_smResult.BllError(l_expData);
            }
            finally {
                // Si pude abrir la conexion
                if (l_dbcAccess != null)
                {
                    // Finalizo la transacción y la cierro
                    l_dbcAccess.EndTransaction(p_smResult);
                    l_dbcAccess.Close();
                }
            }
        }