public Tramites Del(int Id)
        {
            SqlCommand cmd        = new SqlCommand();
            Tramites   vResultado = new Tramites();
            int        vControl   = -1;

            try
            {
                cmd = CrearComando("SGRC_SP_Tramite_Delete");
                cmd.Parameters.AddWithValue("@TramiteId", Id);

                AbrirConexion();
                vControl = Ejecuta_Accion(ref cmd);

                if (vControl > 0)
                {
                    vResultado.Accion    = 1;
                    vResultado.Mensaje   = "Se eliminó con exito el trámite!";
                    vResultado.TramiteId = Id;
                }
            }
            catch (Exception ex)
            {
                vResultado.Accion    = 1;
                vResultado.Mensaje   = ex.Message.ToString();
                vResultado.TramiteId = Id;
                throw new Exception("No se pudo eliminar el registro por el siguiente error: " + ex.Message, ex);
            }
            finally
            {
                cmd.Dispose();
                CerrarConexion();
            }
            return(vResultado);
        }
Exemple #2
0
        public static Tramites BuscarCodigoTramite(int CodigoT)
        {
            Tramites      CT = null;
            SqlDataReader _Reader;

            SqlConnection cnn = new SqlConnection(Conexion._Cnn);
            SqlCommand    cmd = new SqlCommand("Exec BuscarTramites " + CodigoT, cnn);

            cmd.CommandType = CommandType.StoredProcedure;


            try
            {
                cnn.Open();
                _Reader = cmd.ExecuteReader();

                if (_Reader.Read())
                {
                    //***************************COMO HICE QUE HEREDE TUVE QUE AGREGAR LAS ULTIMAS 3 VARIABLES PERO NO QUIERO QUE SE MUESTREN, IGUAL QUEDA ASI?? LO MISMO SUCEDE CON PERSISTENCIA SOLICITUDES QUE HEREDA DE TRAMITES!!
                    CT = new Tramites(_Reader["TipoTramite"].ToString(), _Reader["DescripcionT"].ToString(), Convert.ToInt32(_Reader["CodigoT"]), _Reader["NEntidad"].ToString(), _Reader["Direccion"].ToString(), (List <string>)_Reader["Telefonos"]);
                }

                _Reader.Close();
            }

            catch (Exception ex)
            {
                throw new ApplicationException("algo salio mal con la base de datos" + ex.Message);
            }
            finally
            {
                cnn.Close();
            }
            return(CT);
        }
        public JsonResult delete(int id)
        {
            Tramites          obj        = new Tramites();
            TramiteRepository TramiteRep = new TramiteRepository();

            try
            {
                if (id > 0)
                {
                    obj = TramiteRep.Del(id);
                }
                else
                {
                    obj.Accion  = 0;
                    obj.Mensaje = "El parámetro tiene un valor incorrecto!";
                }
            }
            catch (Exception ex)
            {
                //throw;

                obj.Accion  = 0;
                obj.Mensaje = ex.Message.ToString();
                //return Json(list, JsonRequestBehavior.AllowGet);
            }

            return(Json(obj, JsonRequestBehavior.AllowGet));
        }
Exemple #4
0
        //HACER!!!
        //LISTAR POR nombre de entidad
        public static List <Tramites> ListarTramites(string NEntidad)
        {
            int    codigoT;
            string TipoTramite  = null;
            string DescripcionT = null;
            //string NomEntidad = null;

            List <N_EntidadesCompartidas.Tramites> _ListarTramites = new List <N_EntidadesCompartidas.Tramites>();

            N_EntidadesCompartidas.Tramites CT = null;
            SqlDataReader _Reader;
            //CONEXION CON BD
            SqlConnection cnn = new SqlConnection(Conexion._Cnn);
            SqlCommand    cmd = new SqlCommand("ListarTramites ", cnn);

            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@NEntidad", NEntidad);


            try
            {
                cnn.Open();
                _Reader = cmd.ExecuteReader();
                while (_Reader.Read())//El read siempre me devuelve true or false, pude leer algo o no
                {
                    codigoT      = (int)_Reader["CodigoT"];
                    TipoTramite  = (string)_Reader["TipoTramite"];
                    DescripcionT = (string)_Reader["DescripcionT"];
                    //NomEntidad = (string)_Reader["NEntidad"];

                    CT = new Tramites(TipoTramite, DescripcionT, codigoT);//****xqe no trae la info de la bd de telefonos???????????
                    _ListarTramites.Add(CT);
                    //_ListarEntidades.Add(new Entidades() { pNombreEntidad  = NEntidad });
                }



                // if (_Reader.Read())
                //CARGO LAS VARIABLES CON LA INFORMACION DE LA BD
                //***************************COMO HICE QUE HEREDE TUVE QUE AGREGAR LAS ULTIMAS 3 VARIABLES PERO NO QUIERO QUE SE MUESTREN, IGUAL QUEDA ASI?? LO MISMO SUCEDE CON PERSISTENCIA SOLICITUDES QUE HEREDA DE TRAMITES!!
                ////   CT = new Tramites(_Reader["TipoTramite"].ToString(), _Reader["DescripcionT"].ToString(), Convert.ToInt32(_Reader["CodigoT"]), null);

                //  _Reader.Close();
            }

            catch (Exception ex)
            {
                throw new ApplicationException("algo salio mal con la base de datos" + ex.Message);
            }
            finally
            {
                cnn.Close();
            }
            //VARIABLE CON VALORES CARGADOS
            return(_ListarTramites);

            #endregion
        }
        public List <Tramites> GetTramites()
        {
            List <Tramites> TramitesList = new List <Tramites>();

            try
            {
                //"CrearComando" esta definido en la libreria AccesoDatos.dll
                SqlCommand     cmd = CrearComando("SGRC_SP_Tramite_Get"); //Pasamos el procedimiento almacenado.
                SqlDataAdapter da  = new SqlDataAdapter(cmd);
                DataTable      dt  = new DataTable();
                AbrirConexion();
                da.Fill(dt);
                CerrarConexion();

                //Bind EmpModel generic list using LINQ
                TramitesList = (from DataRow dr in dt.Rows
                                select new Tramites()
                {
                    TramiteId = Convert.ToInt32(dr["TramiteId"]),
                    TramiteDescripcion = Convert.ToString(dr["TramiteDescripcion"]),
                    TramiteAbreviatura = Convert.ToString(dr["TramiteAbreviatura"]),
                    TramiteDuracion = Convert.ToInt32(dr["TramiteDuracion"]),
                    TramiteAlertaPrevia = Convert.ToInt32(dr["TramiteAlertaPrevia"]),
                    TramiteToleranciaAlCliente = Convert.ToInt32(dr["TramiteToleranciaAlCliente"]),
                    TramiteToleranciaDelCliente = Convert.ToInt32(dr["TramiteToleranciaDelCliente"]),
                    TramiteToleranciaFinalizacion = Convert.ToInt32(dr["TramiteToleranciaFinalizacion"]),
                    TramiteTiempoMuerto = Convert.ToInt32(dr["TramiteTiempoMuerto"]),
                    Accion = 1,
                    Mensaje = "Se cargó correctamente la información del trámite."
                }).ToList();
                if (TramitesList.Count == 0)
                {
                    Tramites ss = new Tramites();
                    ss.Accion  = 0;
                    ss.Mensaje = "No se encontraron registros de los Tramites!";
                    TramitesList.Add(ss);
                }
            }
            catch (Exception ex)
            {
                Tramites oTramite = new Tramites();
                oTramite.Accion  = 0;
                oTramite.Mensaje = ex.Message.ToString();
                TramitesList.Add(oTramite);
                throw new Exception("Error Obteniendo todos los registros " + ex.Message, ex);
            }
            return(TramitesList);
        }
        public Tramites GetTramite(int Id)
        {
            Tramites   vResultado = new Tramites(); //Se crea una variable que contendra los datos del trámite.
            SqlCommand cmd        = new SqlCommand();

            try
            {
                cmd = CrearComando("SGRC_SP_Tramite_Get");      //Pasamos el nombre del procedimiento almacenado.
                cmd.Parameters.AddWithValue("@TramiteId", Id);  //Agregamos los parametros.

                AbrirConexion();                                //Se abre la conexion a la BD.
                SqlDataReader consulta = Ejecuta_Consulta(cmd); //Enviamos el comando con los paramentros agregados.

                if (consulta.Read())
                {
                    if (consulta.HasRows)
                    {
                        //Obtenemos el valor de cada campo
                        vResultado.TramiteId                     = (int)consulta["TramiteId"];
                        vResultado.TramiteDescripcion            = (string)consulta["TramiteDescripcion"];
                        vResultado.TramiteAbreviatura            = (string)consulta["TramiteAbreviatura"];
                        vResultado.TramiteDuracion               = (int)consulta["TramiteDuracion"];
                        vResultado.TramiteAlertaPrevia           = (int)consulta["TramiteAlertaPrevia"];
                        vResultado.TramiteToleranciaAlCliente    = (int)consulta["TramiteToleranciaAlCliente"];
                        vResultado.TramiteToleranciaDelCliente   = (int)consulta["TramiteToleranciaDelCliente"];
                        vResultado.TramiteToleranciaFinalizacion = (int)consulta["TramiteToleranciaFinalizacion"];
                        vResultado.TramiteTiempoMuerto           = (int)consulta["TramiteTiempoMuerto"];
                        vResultado.Accion  = 1;
                        vResultado.Mensaje = "Se cargó correctamente el Trámite!";

                        //Si los campos admiten valores nulos convertir explicitamente
                        //ej: vResultado.Nombre = Convert.ToString(consulta["Nombre"]);
                    }
                }
            }
            catch (Exception Ex)
            {
                vResultado.Accion  = 0;
                vResultado.Mensaje = Ex.Message.ToString();
                throw new Exception("Hubo un inconveniente al cargar la información: " + Ex.Message, Ex);
            }
            finally
            {
                cmd.Dispose();
                CerrarConexion();
            }
            return(vResultado);
        }
        public Tramites Save(Tramites pTramite)
        {
            SqlCommand cmd        = new SqlCommand();
            int        vResultado = -1;

            try
            {
                AbrirConexion();
                //connection();
                cmd = CrearComando("SGRC_SP_Tramite_Save");
                cmd.Parameters.AddWithValue("@TramiteId", pTramite.TramiteId);
                cmd.Parameters["@TramiteId"].Direction = ParameterDirection.InputOutput; //Se indica que el TramiteId sera un parametro de Entrada/Salida.
                cmd.Parameters.AddWithValue("@TramiteDescripcion", pTramite.TramiteDescripcion);
                cmd.Parameters.AddWithValue("@TramiteAbreviatura", pTramite.TramiteAbreviatura);
                cmd.Parameters.AddWithValue("@TramiteDuracion", pTramite.TramiteDuracion);
                cmd.Parameters.AddWithValue("@TramiteAlertaPrevia", pTramite.TramiteAlertaPrevia);
                cmd.Parameters.AddWithValue("@TramiteToleranciaAlCliente", pTramite.TramiteToleranciaAlCliente);
                cmd.Parameters.AddWithValue("@TramiteToleranciaDelCliente", pTramite.TramiteToleranciaDelCliente);
                cmd.Parameters.AddWithValue("@TramiteToleranciaFinalizacion", pTramite.TramiteToleranciaFinalizacion);
                cmd.Parameters.AddWithValue("@TramiteTiempoMuerto", pTramite.TramiteTiempoMuerto);
                //con.Open();
                vResultado = Ejecuta_Accion(ref cmd);
                vResultado = Convert.ToInt32(cmd.Parameters["@TramiteId"].Value);
                //con.Close();
            }
            catch (Exception Ex)
            {
                pTramite.Mensaje = Ex.Message;
                throw new Exception("Hubo un inconveniente al intentar guardar el trámite.");
            }
            finally
            {
                cmd.Dispose();
                CerrarConexion();
            }
            pTramite.Accion = vResultado;
            if (vResultado == 0)
            {
                pTramite.Mensaje = "Hubo un inconveniente al intentar guardar la información!";
            }
            else
            {
                pTramite.Mensaje = "Trámite ingresado correctamente!";
            }
            return(pTramite);
        }
        public JsonResult GetAllTramites()
        {
            TramiteRepository TramiteRep = new TramiteRepository();

            try
            {
                return(Json(TramiteRep.GetTramites(), JsonRequestBehavior.AllowGet));
            }
            catch (Exception ex)
            {
                //throw;
                List <Tramites> list = new List <Tramites>();
                Tramites        obj  = new Tramites();
                obj.Accion  = 0;
                obj.Mensaje = ex.Message.ToString();
                list.Add(obj);
                return(Json(list, JsonRequestBehavior.AllowGet));
            }
        }
 public JsonResult SaveData(Tramites tramite)
 {
     try
     {
         TramiteRepository TramiteRep = new TramiteRepository();
         if (ModelState.IsValid)
         {
             TramiteRep.Save(tramite);
             //db.Tramite.Add(tramite);
             //db.SaveChanges();
         }
         return(Json(tramite, JsonRequestBehavior.AllowGet));
     }
     catch (Exception)
     {
         //throw;
         return(Json(tramite, JsonRequestBehavior.AllowGet));
     }
 }
Exemple #10
0
        public static void EliminarTramites(Tramites pSolicitudes)
        {
            //Comando a ejecutar
            SqlConnection _Conexion = new SqlConnection(Conexion._Cnn);
            SqlCommand    _Comando  = new SqlCommand("EliminarTramites", _Conexion);

            _Comando.CommandType = CommandType.StoredProcedure;

            SqlParameter NEntidad = new SqlParameter("@NEntidad", pSolicitudes.NombreEntidad);
            SqlParameter codigoT  = new SqlParameter("@codigoT", pSolicitudes.CodigoT);
            SqlParameter oRetorno = new SqlParameter("@Retorno", SqlDbType.Int);

            oRetorno.Direction = ParameterDirection.ReturnValue;

            _Comando.Parameters.Add(NEntidad);
            _Comando.Parameters.Add(codigoT);
            _Comando.Parameters.Add(oRetorno);

            try
            {
                _Conexion.Open();
                _Comando.ExecuteNonQuery();
                //_Valor TIENE EL VALOR DE RETORNO DE LA BD
                int _Valorr = (int)_Comando.Parameters["@Retorno"].Value;
                if (_Valorr == -1)
                {
                    throw new Exception("Hay solicitudes Asociados - No se Elimina");
                }
                else if (_Valorr == 0)
                {
                    throw new Exception("No existe entidad- No se Elimina");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                _Conexion.Close();
            }
        }
Exemple #11
0
        public static void AgregarTramites(Tramites Nentidad)
        {
            SqlConnection _Conexion = new SqlConnection(Conexion._Cnn);
            SqlCommand    _Comando  = new SqlCommand("AgregarTramites", _Conexion);

            _Comando.CommandType = CommandType.StoredProcedure;

            _Comando.Parameters.AddWithValue("@CodigoT", Nentidad.CodigoT);
            _Comando.Parameters.AddWithValue("@NEntidades", Nentidad.NombreEntidad);
            _Comando.Parameters.AddWithValue("@TipoT", Nentidad.TipoTramite);
            _Comando.Parameters.AddWithValue("@Descripcion", Nentidad.DescripcionT);

            SqlParameter oRetorno = new SqlParameter("@Retorno", SqlDbType.Int);

            oRetorno.Direction = ParameterDirection.ReturnValue;
            _Comando.Parameters.Add(oRetorno);

            try
            {
                //checar que significa cada return de la bd para poner el control
                _Conexion.Open();
                _Comando.ExecuteNonQuery();
                int _Valor = (int)_Comando.Parameters["@Retorno"].Value;
                if (_Valor == 0)
                {
                    throw new Exception("Error inAggregar in BD");
                }
                else if (_Valor == -2)
                {
                    throw new Exception("Error");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                _Conexion.Close();
            }
        }
Exemple #12
0
        public static void ModificarTramites(Tramites tramites)
        {
            SqlConnection _Conexion = new SqlConnection(Conexion._Cnn);
            SqlCommand    _Comando  = new SqlCommand("ModificarEntidades", _Conexion);

            _Comando.CommandType = CommandType.StoredProcedure;
            _Comando.Parameters.AddWithValue("@NEntidades", tramites.NombreEntidad); //si la el procedimiento en la BD esta bn entonces tengo algo mal en las entidades compartidas
            _Comando.Parameters.AddWithValue("@CodigoT", tramites.CodigoT);
            //no tendria que ser modificable el tipo de tramite y descripcion del mismo tambien? en BD no esta

            SqlParameter _Retorno = new SqlParameter("@Retorno", SqlDbType.Int);

            _Retorno.Direction = ParameterDirection.ReturnValue;
            _Comando.Parameters.Add(_Retorno);

            try
            {
                _Conexion.Open();
                _Comando.ExecuteNonQuery();

                int _Valor = (int)_Comando.Parameters["@Retorno"].Value;
                //VERIFICAR LUEGO QUE ESTE CULMINADA LA BD PARA CHECAR EL IF QUE SE AGREGUE
                if (_Valor == -1)
                {
                    throw new Exception("No Existe  - No se Modifico");
                }
                else if (_Valor == -2)
                {
                    throw new Exception("Error");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                _Conexion.Close();
            }
        }
        public JsonResult CheckOne(string descripcion, string abreviatura)
        {
            Tramites          obj        = new Tramites();
            TramiteRepository TramiteRep = new TramiteRepository();

            try
            {
                if (descripcion != "" || abreviatura != "")
                {
                    obj = TramiteRep.CheckTramite(descripcion, abreviatura);
                }
                else
                {
                    obj.Accion  = 0;
                    obj.Mensaje = "El parámetro tiene un valor incorrecto!";
                }
            }
            catch (Exception ex)
            {
                obj.Accion  = 0;
                obj.Mensaje = ex.Message.ToString();
            }
            return(Json(obj, JsonRequestBehavior.AllowGet));
        }