/// <summary>
/// Método para insertar un resistro a la tabla TBL_rol
/// </summary>
/// <param name="id_rol"></param>
/// <param name="nombre_rol"></param>
/// <param name="fecha_creacion"></param>
/// <param name="fecha_actualizacion"></param>
/// <returns>Retorna cero, si hay error.</returns>
public int SetRol(int id_rol, string nombre_rol, DateTime fecha_creacion, DateTime fecha_actualizacion)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Se crea un objeto de tipo usuarios, el cual se va agregar a la tabla
TBL_ROL rol = new TBL_ROL();
//Se asiganan los valores.
//rol.ID_ROL=id_rol;
rol.NOMBRE_ROL = nombre_rol;
rol.FECHA_CREACION = fecha_creacion;
rol.FECHA_ACTUALIZACION = fecha_actualizacion;
//Agrega el objeto a la tabla.
Conexion.TBL_ROL.Add(rol);
//Se guardan los cambios
Conexion.SaveChanges();
//Retorna el código del usuario insertado
return(rol.ID_ROL);
}
}
catch (Exception)
{
//Si hay error regresa una cadena vacía.
return(0);
}
}
/// <summary>
///
/// </summary>
/// <param name="id_bloqueo"></param>
/// <param name="fecha_inicio"></param>
/// <param name="fecha_fin"></param>
/// <param name="estado"></param>
/// <returns></returns>
public int UpdateBloqueo(int id_bloqueo, DateTime fecha_inicio, DateTime fecha_fin, string observaciones)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Creacion del objeto archivo
TBL_BLOQUEO obj = Conexion.TBL_BLOQUEO.Where(x => x.ID_BLOQUEO == id_bloqueo).FirstOrDefault();
//Asignamos los valores
obj.FECHA_INICIO = fecha_inicio;
obj.FECHA_FIN = fecha_fin;
obj.OBSERVACIONES = observaciones;
//Guardamos las modificaciones
Conexion.Entry(obj).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
return(0);
}
}
/// <summary>
/// Obtenemos un registro que tenga el estado de bloqueado
/// </summary>
/// <returns></returns>
public IList GetBloqueo()
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, si hay algún estado en bloqueado
var Lista = (from b in Conexion.TBL_BLOQUEO
where b.ESTADO == true
select new
{
b.ID_BLOQUEO,
b.FECHA_FIN,
b.FECHA_INICIO,
b.OBSERVACIONES,
b.ESTADO
}).ToList();
//Retornamos la lista
return(Lista);
}
}
catch (Exception)
{
//Si hay error, retornamos nulo
return(null);
}
}
/// <summary>
/// Método que obtiene el archivo de un documento en especifico
/// </summary>
/// <param name="id_documento"></param>
/// <returns></returns>
public IList GetArchivo(int id_documento)
{
try
{
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y el resultado lo guardamos en una lista
var Lista = (from d in Conexion.TBL_DOCUMENTO_ELIMINADO
where d.ID_ELIMINADO == id_documento
select new
{
d.ARCHIVO,
d.EXT,
NOMBRE = d.NUM_DOCUMENTO + d.NO_VERSION,
d.FECHA_ELIMINO
}).ToList();
//retorna la lista
return(Lista);
}
}
catch (Exception)
{
//si hay error, retorna nulo
return(null);
}
}
/// <summary>
/// Método para obtener los registros de la tabla.
/// </summary>
/// <returns>Si encuentra un error, retorna cero.</returns>
public IList GetTipo()
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, para retornar el resultado.
var Lista = (from t in Conexion.TBL_TIPO_DOCUMENTO
orderby t.TIPO_DOCUMENTO ascending
select new
{
t.ID_TIPO_DOCUMENTO,
t.TIPO_DOCUMENTO,
t.ABREBIATURA,
t.FECHA_CREACION,
t.FECHA_ACTUALIZACION,
t.NUMERO_MATRIZ
}).ToList();
//se retorna la lista
return(Lista);
}
}
catch (Exception)
{
//Si hay algún error, se retorna un nulo.
return(null);
}
}
/// <summary>
/// Método para actualizar la contraseña de un usuario.
/// </summary>
/// <param name="usuario"></param>
/// <param name="password"></param>
/// <returns></returns>
public int UpdatePass(string usuario, string password)
{
try
{
//Se establece la conexión a la base de datos.
using (var Conexion = new EntitiesControlDocumentos())
{
//creación del objeto tipo Usuarios.
Usuarios user = Conexion.Usuarios.Where(x => x.Usuario == usuario).FirstOrDefault();
//Asignamos los parámetros recibidos a cada uno de los valores de los objetos.
user.Password = password;
//Se cambia el estado de registro a modificado.
Conexion.Entry(user).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
//Si encuentra error devuelve cero.
return(0);
}
}
public int Insert(int idVersion, string idUsuario, int idClasificationLevel)
{
try
{
using (var Conexion = new EntitiesControlDocumentos())
{
TBL_SOLICITUD_ETIQUETADO tBL_SOLICITUD_ETIQUETADO = new TBL_SOLICITUD_ETIQUETADO();
tBL_SOLICITUD_ETIQUETADO.ID_VERSION = idVersion;
tBL_SOLICITUD_ETIQUETADO.ID_NUEVO_USUARIO = idUsuario;
tBL_SOLICITUD_ETIQUETADO.ID_CLASIFICATION_LEVEL = idClasificationLevel;
tBL_SOLICITUD_ETIQUETADO.FECHA_SOLICITUD = DateTime.Now;
tBL_SOLICITUD_ETIQUETADO.ESTATUS = 0;
Conexion.TBL_SOLICITUD_ETIQUETADO.Add(tBL_SOLICITUD_ETIQUETADO);
Conexion.SaveChanges();
return(tBL_SOLICITUD_ETIQUETADO.ID_SOLICITUD_ETIQUETADO);
}
}
catch (Exception)
{
return(0);
}
}
/// <summary>
/// Método para obetener el id del usuario del id que elaboró y autorizó de la version.
/// </summary>
/// <param name="id_version"></param>
/// <returns></returns>
public IList GetUsuario(int id_version)
{
try
{
//Relizamos la conexión a través de Entity Framework.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y e resultado lo guardamos en una variable local.
var usuario = (from v in Conexion.TBL_VERSION
join u in Conexion.Usuarios on v.ID_USUARIO_AUTORIZO equals u.Usuario
join us in Conexion.Usuarios on v.ID_USUARIO_ELABORO equals us.Usuario
where v.ID_VERSION == id_version
select new {
v.ID_USUARIO_ELABORO,
v.ID_USUARIO_AUTORIZO,
USUARIO_AUTORIZO = u.Nombre + " " + u.APaterno,
USUARIO_ELABORO = us.Nombre + " " + us.APaterno
}).ToList();
//Retornamos el resultado de la consulta.
return(usuario);
}
}
catch (Exception)
{
//Si se genera un error retornamos un cero.
return(null);
}
}
/// <summary>
/// Método para obtener el id de la versión anterior de la la versión actual
/// </summary>
/// <param name="id_documento"></param>
/// <returns></returns>
public int GetLastVersion_Id(int id_documento, int idVersion)
{
//Declaramos una variable, que retornara el último código agregado
int id_version;
try
{
//Se establece la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Se ordena de mayor a menor el código para obtener el primer valor,
//en este caso la última versión del documento correspondiente.
var last = (from v in Conexion.TBL_VERSION
join d in Conexion.TBL_DOCUMENTO on v.ID_DOCUMENTO equals d.ID_DOCUMENTO
where v.ID_DOCUMENTO == id_documento & v.ID_VERSION != idVersion
orderby v.ID_VERSION descending
select v.ID_VERSION).First();
//Asignamos el resultado obtenido a la variable local.
id_version = last;
}
}
catch (Exception)
{
//Si hubo algún error retornamos una cadena vacía.
return(0);
}
//Retornamos el valor.
return(id_version);
}
///// <summary>
///// Método que obtiene todos los regsitros de una version
///// </summary>
///// <param name="Id_Documento"></param>
///// <returns></returns>
//public IList GetVersionesDocumento(int Id_Documento)
//{
// try
// {
// using (var conexion = new EntitiesControlDocumentos())
// {
// var Lista = (from v in conexion.TBL_VERSION
// join u in conexion.Usuarios on v.ID_USUARIO_AUTORIZO equals u.Usuario
// select new
// {
// u.Nombre,
// u.APaterno,
// v.No_VERSION,
// v.FECHA_VERSION,
// }
// ).ToList();
// return Lista;
// }
// }
// catch (Exception)
// {
// return null;
// }
//}
/// <summary>
///
/// </summary>
/// <param name="id_documento"></param>
/// <returns></returns>
public int GetVersionDocumento(int id_documento)
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, para retornar el resultado.
int id_version = Convert.ToInt32((from v in Conexion.TBL_VERSION
join d in Conexion.TBL_DOCUMENTO on v.ID_DOCUMENTO equals d.ID_DOCUMENTO
join u in Conexion.Usuarios on v.ID_USUARIO_ELABORO equals u.Usuario
join us in Conexion.Usuarios on v.ID_USUARIO_AUTORIZO equals us.Usuario
where v.ID_DOCUMENTO == id_documento && v.ID_ESTATUS_VERSION == 5
select v.ID_VERSION).First());
//se retorna la lista
return(id_version);
}
}
catch (Exception)
{
//Si hay algún error, se retorna un nulo.
return(0);
}
}
/// <summary>
/// Método para obetener todos los registros de la tabla TBL_Version
/// </summary>
/// <returns>Retorna null, si hay error.</returns>
public IList GetVersion()
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, para retornar el resultado.
var Lista = (from v in Conexion.TBL_VERSION
join d in Conexion.TBL_DOCUMENTO on v.ID_DOCUMENTO equals d.ID_DOCUMENTO
join u in Conexion.Usuarios on v.ID_USUARIO_ELABORO equals u.Usuario
join us in Conexion.Usuarios on v.ID_USUARIO_AUTORIZO equals us.Usuario
select new
{
v.ID_VERSION,
ID_USUARIO_ELABORO = u.Usuario,
ID_USUARIO_AUTORIZO = us.Usuario,
ID_DOCUMENTO = d.ID_DOCUMENTO,
v.No_VERSION,
v.FECHA_VERSION,
v.NO_COPIAS
}).ToList();
//se retorna la lista
return(Lista);
}
}
catch (Exception)
{
//Si hay algún error, se retorna un nulo.
return(null);
}
}
/// <summary>
/// Método que inserta un registro en la tabla de historial versión.
/// </summary>
/// <param name="idVersion"></param>
/// <param name="fecha"></param>
/// <param name="descripcion"></param>
/// <param name="nombreUsuario"></param>
/// <param name="nombreDocumento"></param>
/// <param name="version"></param>
/// <returns></returns>
public int Insert(int idVersion, DateTime fecha, string descripcion, string nombreUsuario, string nombreDocumento, string version)
{
try
{
//Creamos la conexion
using (var Conexion = new EntitiesControlDocumentos())
{
//Creamos un objeto el cual será el que insertemos.
TBL_HISTORIAL_VERSION registro = new TBL_HISTORIAL_VERSION();
//Mapeamos los valores a las propiedades correspondientes.
registro.NOMBRE_DOCUMENTO = nombreDocumento;
registro.NO_VERSION = version;
registro.FECHA = fecha;
registro.DESCRIPCION = descripcion;
registro.NOMBRE_USUARIO = nombreUsuario;
//Agregamos el registro.
Conexion.TBL_HISTORIAL_VERSION.Add(registro);
//Guardamos los cambios y retornamos el resultado.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
//Si ocurre un error retornamos un cero.
return(0);
}
}
/// <summary>
/// Método que obtiene el historial de la version de un documento
/// </summary>
/// <param name="nombre"></param>
/// <param name="no_version"></param>
/// <returns></returns>
public IList GetHistorial_version(string nombre, string no_version)
{
try
{
//establecemos la conexion
using (var Conexion = new EntitiesControlDocumentos())
{
//Ejecutamos el metodo que obtiene el historial de la version
var Lista = (from h in Conexion.TBL_HISTORIAL_VERSION
where h.NOMBRE_DOCUMENTO.Equals(nombre) && h.NO_VERSION.Equals(no_version)
select new
{
h.ID_HISTORIAL_VERSION,
h.FECHA,
h.DESCRIPCION,
h.NOMBRE_USUARIO
}).OrderBy(x => x.ID_HISTORIAL_VERSION).ToList();
//Retornamos la lita
return(Lista);
}
}
catch (Exception)
{
//Si hay error, retornamos nulo
return(null);
}
}
/// <summary>
/// Método para modificar los registros de la tabla.
/// </summary>
/// <param name="id_rol"></param>
/// <param name="nombre_rol"></param>
/// <param name="fecha_creacion"></param>
/// <param name="fecha_actualizacion"></param>
/// <returns>Retorna cero si hay error.</returns>
public int UpdateRol(int id_rol, string nombre_rol, DateTime fecha_creacion, DateTime fecha_actualizacion)
{
try
{
//Se establece la conexión a la base de datos.
using (var Conexion = new EntitiesControlDocumentos())
{
//creación del objeto tipo TBL_archivo.
TBL_ROL rol = Conexion.TBL_ROL.Where(x => x.ID_ROL == id_rol).FirstOrDefault();
//Asignamos los parámetros recibidos a cada uno de los valores de los objetos.
rol.NOMBRE_ROL = nombre_rol;
rol.FECHA_CREACION = fecha_creacion;
rol.FECHA_ACTUALIZACION = fecha_actualizacion;
//Se cambia el estado de registro a modificado.
Conexion.Entry(rol).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
//Si encuentra error devuelve cero.
return(0);
}
}
/// <summary>
/// Método que actualiza los valores de un registro en la tabla Usuarios.
/// </summary>
/// <param name="usuario"></param>
/// <param name="password"></param>
/// <param name="nombre"></param>
/// <param name="APaterno"></param>
/// <param name="AMaterno"></param>
/// <param name="estado"></param>
/// <param name="usql"></param>
/// <param name="psql"></param>
/// <param name="bloqueado"></param>
/// <param name="id_departartemento"></param>
/// <returns></returns>
public int UpdateUsuarios(string usuario, string password, string nombre, string APaterno, string AMaterno,
int estado, string usql, string psql, bool bloqueado, string correo, string pathnsf)
{
try
{
//Se establece la conexión a la base de datos.
using (var Conexion = new EntitiesControlDocumentos())
{
//creación del objeto tipo Usuarios.
Usuarios user = Conexion.Usuarios.Where(x => x.Usuario == usuario).FirstOrDefault();
//Asignamos los parámetros recibidos a cada uno de los valores de los objetos.
user.Password = password;
user.Nombre = nombre;
user.APaterno = APaterno;
user.AMaterno = AMaterno;
user.Estado = estado;
user.Usql = usql;
user.Psql = psql;
user.Bloqueado = bloqueado;
user.Correo = correo;
user.Pathnsf = pathnsf;
//Se cambia el estado de registro a modificado.
Conexion.Entry(user).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
//Si encuentra error devuelve cero.
return(0);
}
}
/// <summary>
/// Método que retorna el id de todas las versiones de un documento.
/// </summary>
/// <param name="id_documento"></param>
/// <returns></returns>
public IList Versiones(int id_documento)
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, para retornar el resultado.
var Lista = (from v in Conexion.TBL_VERSION
where v.ID_DOCUMENTO == id_documento
select new
{
v.ID_VERSION,
v.No_VERSION,
v.ID_ESTATUS_VERSION
}).ToList();
//se retorna la lista
return(Lista);
}
}
catch (Exception)
{
//Si hay algún error, se retorna un nulo.
return(null);
}
}
/// <summary>
/// Método que obtiene los roles de un usuario en específico.
/// </summary>
/// <param name="idUsuario"></param>
/// <returns></returns>
public IList GetRolesUsuario(string idUsuario)
{
try
{
//Establecemos la conexión a través de Entity Framework.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta.
var ListaRoles = (from a in Conexion.TR_ROL_USUARIOS
join b in Conexion.TBL_ROL on a.ID_ROL equals b.ID_ROL
where a.ID_USUARIO == idUsuario
select new
{
a.ID_ROL,
b.NOMBRE_ROL
}).ToList();
//Retornamos el resultado de la consulta.
return(ListaRoles);
}
}
catch (Exception)
{
//Si se generó algún error, retornamos un nulo.
return(null);
}
}
/// <summary>
/// Método para obtener los archivos de una versión
/// </summary>
/// <param name="id_version"></param>
/// <returns></returns>
public IList GetArchivos(int id_version)
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, para retornar el resultado.
var Lista = (from a in Conexion.TBL_ARCHIVO
where a.ID_VERSION == id_version
select new
{
a.ID_ARCHIVO,
a.NOMBRE_ARCHIVO,
a.EXT,
a.ARCHIVO,
a.ID_VERSION,
a.PATH_FILE
}).ToList();
//se retorna la lista
return(Lista);
}
}
catch (Exception)
{
//Si hay algún error, se retorna un nulo.
return(null);
}
}
public IList Get(int estatus, int idVersion = 0)
{
try
{
using (var Conexion = new EntitiesControlDocumentos())
{
if (idVersion == 0)
{
var list = (from a in Conexion.TBL_SOLICITUD_ETIQUETADO
where a.ESTATUS == estatus
select a).ToList();
return(list);
}
else
{
var list = (from a in Conexion.TBL_SOLICITUD_ETIQUETADO
where a.ESTATUS == estatus && a.ID_VERSION == idVersion
select a).ToList();
return(list);
}
}
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// M+etodo para obtener la versión de un documento que no esté liberado u obsoleto
/// </summary>
/// <param name="id_documento"></param>
/// <returns></returns>
public IList GetStatus(int id_documento)
{
try
{
//Se inician los servicios de Entity Control Documento
using (var Conexion = new EntitiesControlDocumentos())
{
//Se realiza la consulta, el resultado se guarda en una lista
var version = (from v in Conexion.TBL_VERSION
join e in Conexion.TBL_ESTATUS_VERSION on v.ID_ESTATUS_VERSION equals e.ID_ESTATUS_VERSION
where v.ID_DOCUMENTO == id_documento & v.ID_ESTATUS_VERSION != 1 & v.ID_ESTATUS_VERSION != 2
select new
{
v.ID_VERSION,
v.No_VERSION,
e.ESTATUS_VERSION
}).ToList();
//Retornamos la lista
return(version);
}
}
catch (Exception)
{
//Si hay error, se regresa nulo
return(null);
}
}
/// <summary>
/// Método que obtiene todos los registros de la tabla,o los filtra por numero de documento
/// </summary>
/// <param name="numeroBusqueda"></param>
/// <returns></returns>
public IList GetAllDocumento_Eliminado(string numeroBusqueda)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Ejecutamos el método
var Lista = (from d in Conexion.TBL_DOCUMENTO_ELIMINADO
where d.NUM_DOCUMENTO.Contains(numeroBusqueda)
select new
{
d.ID_ELIMINADO,
d.NUM_DOCUMENTO,
d.NO_VERSION,
d.FECHA_ELIMINO,
d.ARCHIVO,
d.EXT
}).OrderBy(x => x.NUM_DOCUMENTO).ToList();
//Retornamos la lista
return(Lista);
}
}
catch (Exception)
{
//si hay error, retornamos nulo
return(null);
}
}
/// <summary>
/// Método para actualizar el estatus de una versión.
/// </summary>
/// <param name="id_version"></param>
/// <param name="id_estatus"></param>
/// <returns></returns>
public int UpdateEstatus_Version(int id_version, int id_estatus)
{
try
{
//Se establece la conexión a la base de datos.
using (var Conexion = new EntitiesControlDocumentos())
{
//creación del objeto tipo TBL_archivo.
TBL_VERSION obj = Conexion.TBL_VERSION.Where(x => x.ID_VERSION == id_version).FirstOrDefault();
//Asignamos los parámetros recibidos a cada uno de los valores de los objetos.
obj.ID_ESTATUS_VERSION = id_estatus;
//Se cambia el estado de registro a modificado.
Conexion.Entry(obj).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
//Si encuentra error devuelve cero.
return(0);
}
}
/// <summary>
/// Método para modificar un registro de la tabla TBL_tipo
/// </summary>
/// <param name="id_tipo"></param>
/// <param name="tipo_documento"></param>
/// <param name="abreviatura"></param>
/// <param name="fecha_creacion"></param>
/// <param name="fecha_actualizacion"></param>
/// <returns>si hay error, retorna cero,</returns>
public int UpdateTipo(int id_tipo, string tipo_documento, string abreviatura, DateTime fecha_creacion, DateTime fecha_actualizacion)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Se crea un objeto de tipo usuarios, el cual se va agregar a la tabla
TBL_TIPO_DOCUMENTO obj = Conexion.TBL_TIPO_DOCUMENTO.Where(x => x.ID_TIPO_DOCUMENTO == id_tipo).FirstOrDefault();
//Se asiganan los valores.
obj.TIPO_DOCUMENTO = tipo_documento;
obj.ABREBIATURA = abreviatura;
obj.FECHA_ACTUALIZACION = fecha_actualizacion;
obj.FECHA_CREACION = fecha_creacion;
//Se cambia el estado de registro a modificado.
Conexion.Entry(obj).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());;
}
}
catch (Exception)
{
//Si hay error regresa una cadena vacía.
return(0);
}
}
/// <summary>
/// Método que obtiene una lista de las versiones liberadas de un documento correspondiente
/// </summary>
/// <param name="id_doc"></param>
/// <returns></returns>
public IList GetVersionesXDocumento(int id_doc, int No_Tomar)
{
try
{
//Se establece la conexion
using (var Conexion = new EntitiesControlDocumentos())
{
//Se realiza la consulta, el resultado se guarda en una lista
var ListaVersion = (from d in Conexion.TBL_DOCUMENTO
join v in Conexion.TBL_VERSION on d.ID_DOCUMENTO equals v.ID_DOCUMENTO
join u in Conexion.Usuarios on v.ID_USUARIO_AUTORIZO equals u.Usuario
join us in Conexion.Usuarios on v.ID_USUARIO_ELABORO equals us.Usuario
where d.ID_DOCUMENTO == id_doc && (v.ID_ESTATUS_VERSION == 1 || v.ID_ESTATUS_VERSION == 2)
orderby v.ID_VERSION descending
select new
{
v.ID_VERSION,
v.No_VERSION,
v.FECHA_VERSION,
v.NO_COPIAS,
v.DESCRIPCION,
USUARIO_AUTORIZO = u.Nombre.Substring(0, 1) + "." + u.APaterno,
USUARIO_ELABORO = us.Nombre.Substring(0, 1) + "." + us.APaterno,
}).Take(No_Tomar).ToList();
//Retornamos la lista
return(ListaVersion);
}
}
catch (Exception)
{
//Si hay error, se regresa nulo
return(null);
}
}
/// <summary>
/// Método para insertar un registro a la tabla tipo.
/// </summary>
/// <param name="id_tipo"></param>
/// <param name="tipo_documento"></param>
/// <param name="abreviatura"></param>
/// <param name="fecha_creacion"></param>
/// <param name="fecha_actualizacion"></param>
/// <returns>Si encuentra un error, retorna cero.</returns>
public int SetTipo(int id_tipo, string tipo_documento, string abreviatura, DateTime fecha_creacion, DateTime fecha_actualizacion, string num_matriz)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Se crea un objeto de tipo usuarios, el cual se va agregar a la tabla
TBL_TIPO_DOCUMENTO obj = new TBL_TIPO_DOCUMENTO();
//Se asiganan los valores.
obj.ID_TIPO_DOCUMENTO = id_tipo;
obj.TIPO_DOCUMENTO = tipo_documento;
obj.ABREBIATURA = abreviatura;
obj.FECHA_ACTUALIZACION = fecha_actualizacion;
obj.FECHA_CREACION = fecha_creacion;
obj.NUMERO_MATRIZ = num_matriz;
//Agrega el objeto a la tabla.
Conexion.TBL_TIPO_DOCUMENTO.Add(obj);
//Se guardan los cambios
Conexion.SaveChanges();
//Retorna el código del usuario insertado
return(obj.ID_TIPO_DOCUMENTO);
}
}
catch (Exception)
{
//Si hay error regresa una cadena vacía.
return(0);
}
}
// Consulta que elimina registros de la TR_USUARIO_NOTIFICACION_VERSION por ID_VERSION, una vez que el documento ha sido liberado
public int DeleteRegistroVersion(int id_version)
{
try
{
// Realizamos la conexión a través de EntityFramework
using (var Conexion = new EntitiesControlDocumentos())
{
// Declaramos la lista
List <TR_USUARIO_NOTIFICACION_VERSION> List = Conexion.TR_USUARIO_NOTIFICACION_VERSION.Where(x => x.ID_VERSION == id_version).ToList();
foreach (var Registro in List)
{
// Eliminamos los registros
Conexion.Entry(Registro).State = System.Data.Entity.EntityState.Deleted;
}
// Guardamos los cambios
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
// Si hay error retornamos 0
return(0);
}
}
/// <summary>
/// Método que modifica el estado a desbloqueado
/// </summary>
/// <param name="id_bloqueo"></param>
/// <param name="estado"></param>
/// <returns></returns>
public int UpdateEstado(int id_bloqueo)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Creacion del objeto archivo
TBL_BLOQUEO obj = Conexion.TBL_BLOQUEO.Where(x => x.ID_BLOQUEO == id_bloqueo).FirstOrDefault();
//Asignamos los valores
obj.ESTADO = false;
//Guardamos las modificaciones
Conexion.Entry(obj).State = EntityState.Modified;
//Se guardan los cambios y se retorna el número de registros afectados.
return(Conexion.SaveChanges());
}
}
catch (Exception)
{
//Retorna cero
return(0);
}
}
public IList GetUsuarioF(string nombre)
{
try
{
//Establecemos la conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Realizamos la consulta y se guardan en una lista, para retornar el resultado.
var Lista = (from u in Conexion.Usuarios
where u.Bloqueado == false && u.Usuario.Contains(nombre)
orderby u.Nombre ascending
select new
{
u.Usuario,
u.Password,
u.Nombre,
u.APaterno,
u.AMaterno,
u.Estado,
u.Usql,
u.Psql,
u.Bloqueado,
u.Correo,
u.Pathnsf
}).ToList();
//se retorna la lista
return(Lista);
}
}
catch (Exception)
{
//Si hay algún error, se retorna un nulo.
return(null);
}
}
/// <summary>
/// Método que inserta un nuevo registro de bloqueo a la base de datos
/// </summary>
/// <param name="fecha_inicio"></param>
/// <param name="fecha_fin"></param>
/// <param name="estado"></param>
/// <param name="observaciones"></param>
/// <returns></returns>
public int SetBloqueo(DateTime fecha_inicio, DateTime fecha_fin, string observaciones)
{
try
{
//Se establece conexión a la BD.
using (var Conexion = new EntitiesControlDocumentos())
{
//Se crea un objeto de tipo bloqueo, el cual va agregar a la lista
TBL_BLOQUEO obj = new TBL_BLOQUEO();
//Se asiganan los valores.
obj.FECHA_INICIO = fecha_inicio;
obj.FECHA_FIN = fecha_fin;
obj.ESTADO = true;
obj.OBSERVACIONES = observaciones;
//Agrega el objeto a la tabla.
Conexion.TBL_BLOQUEO.Add(obj);
//Guardamos los cambios
Conexion.SaveChanges();
//Retorna el id del archivo agregado
return(obj.ID_BLOQUEO);
}
}
catch (Exception)
{
//Si hay error retorna cero
return(0);
}
}
/// <summary>
/// metodo para eliminar todos los roles que tenga un usuario
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public int DeleteRolUsuario(string id_usuario)
{
try
{
using (var conexion = new EntitiesControlDocumentos())
{
//obtenemos todos los registros que sean del id_usuario
var rows = from o in conexion.TR_ROL_USUARIOS
where o.ID_USUARIO == id_usuario
select o;
//cada registro lo vamos a eliminar
foreach (var row in rows)
{
//conexion.TR_ROL_USUARIOS.Remove(row);
conexion.Entry(row).State = EntityState.Deleted;
}
//guardamos los cambios
return(conexion.SaveChanges());
}
}
catch (Exception)
{
return(0);
}
}