/// <summary>
/// Agrega una instancia de riesgos_probabilidad
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Agregar(riesgos_probabilidad entidad)
{
try
{
string mess = "";
if (Exist(entidad.nombre))
{
mess = "Ya existe un impacto llamado: " + entidad.nombre;
}
else
{
riesgos_probabilidad impacto = new riesgos_probabilidad
{
nombre = entidad.nombre,
valor = entidad.valor,
activo = true,
usuario = entidad.usuario.ToUpper(),
fecha = DateTime.Now
};
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
context.riesgos_probabilidad.Add(impacto);
context.SaveChanges();
}
return(mess);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
public string Agregar(int id_proyecto, int id_proyecto_rol, string usuario, string usuario_registro)
{
try
{
if (Exists(id_proyecto, usuario))
{
return("El proyecto ya tiene como integrante al usuario: " + usuario);
}
else
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
string mess = "";
proyectos_empleados empleado = new proyectos_empleados
{
id_proyecto = id_proyecto,
usuario = usuario,
id_proyecto_rol = id_proyecto_rol,
usuario_registro = usuario_registro,
fecha_registro = DateTime.Now,
activo = true
};
context.proyectos_empleados.Add(empleado);
context.SaveChanges();
return(mess);
}
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Devuelve una tabla con los proyectos_tecnologias
/// </summary>
/// <returns></returns>
public DataTable SelectAll()
{
DataTable dt = new DataTable();
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.proyectos_tecnologias
.Where(s => s.activo)
.Select(u => new
{
u.id_proyecto_tecnologia,
u.nombre,
u.activo,
u.fecha,
u.usuario
})
.OrderBy(u => u.nombre);
dt = To.DataTable(query.ToList());
return(dt);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(new DataTable());
}
}
/// <summary>
/// Regresa la fecha de la siguiente evaluacion
/// </summary>
/// <param name="id_proyecto"></param>
/// <param name="dias"></param>
/// <returns></returns>
public DateTime fecha_siguiente_Evaluacion(int id_proyecto, int dias)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.proyectos_evaluaciones
.Where(s => s.usuario_borrado == null && s.id_proyecto == id_proyecto)
.Select(u => new
{
u.id_proyecto_evaluacion,
u.id_proyecto,
u.fecha_evaluacion
})
.OrderBy(u => u.fecha_evaluacion);
DataTable dt = To.DataTable(query.ToList());
DateTime fecha_ultima_evaluacion = dt.Rows.Count > 0 ? Convert.ToDateTime(dt.Rows[dt.Rows.Count - 1]["fecha_evaluacion"]).AddDays(dias) :
DateTime.Now;
return(fecha_ultima_evaluacion);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(DateTime.Now);
}
}
public string Agregar(documentos entidad)
{
try
{
string mess = "";
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
documentos documento = new documentos();
documento.id_actividad = entidad.id_actividad;
documento.id_proyecto = entidad.id_proyecto;
documento.path = entidad.path;
documento.comentarios = entidad.comentarios;
documento.nombre = entidad.nombre;
documento.tamaño = entidad.tamaño;
documento.publico = true;
documento.extension = entidad.extension;
documento.contentType = entidad.contentType;
documento.fecha = DateTime.Now;
documento.usuario = entidad.usuario;
documento.id_documento_tipo = entidad.id_documento_tipo;
context.documentos.Add(documento);
context.SaveChanges();
return("");
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Agrega una instancia de proyectos_evaluaciones
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public int Agregar(proyectos_evaluaciones entidad)
{
try
{
int id_proyecto_evaluacion_anterior = get_id_proyecto_evaluacion(entidad.id_proyecto);
proyectos_evaluaciones evaluacion = new proyectos_evaluaciones
{
id_proyecto = entidad.id_proyecto,
fecha_evaluacion = entidad.fecha_evaluacion,
usuario = entidad.usuario,
fecha = DateTime.Now,
riesgo_costo = 0,
riesgo_tiempo = 0,
p_riesgo_costo = 0,
p_riesgo_tiempo = 0
};
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
context.proyectos_evaluaciones.Add(evaluacion);
context.SaveChanges();
if (id_proyecto_evaluacion_anterior > 0)
{
proyectos_evaluaciones pevaluacion = context.proyectos_evaluaciones
.First(i => i.id_proyecto_evaluacion == id_proyecto_evaluacion_anterior);
List <riesgos> riesgos = pevaluacion.riesgos.ToList();
foreach (riesgos riesgo in riesgos)
{
if (riesgo.id_riesgos_estatus == 1 && riesgo.usuario_borrado == null)
{
riesgos new_riesgo = new riesgos
{
id_proyecto_evaluacion = evaluacion.id_proyecto_evaluacion,
riesgo = riesgo.riesgo,
usuario = entidad.usuario,
fecha_registro = DateTime.Now,
id_riesgos_estatus = 1,
valor = riesgo.valor,
estrategia = riesgo.estrategia,
id_riesgo_probabilidad = riesgo.id_riesgo_probabilidad,
id_riesgo_impacto = riesgo.id_riesgo_impacto,
id_riesgo_estrategia = riesgo.id_riesgo_estrategia,
usuario_resp = riesgo.usuario_resp
};
context.riesgos.Add(new_riesgo);
context.SaveChanges();
}
}
}
return(evaluacion.id_proyecto_evaluacion);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(0);
}
}
public bool ProyectoTerminado(int id_proyecto)
{
DataTable dt = new DataTable();
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.proyectos
.Where(s => s.id_proyecto == id_proyecto && s.id_proyecto_estatus == 2)
.Select(u => new
{
u.id_proyecto
})
.OrderBy(u => u.id_proyecto);
dt = To.DataTable(query.ToList());
return(dt.Rows.Count > 0);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(false);
}
}
public string Cerrar(int id_proyecto, string usuario, documentos documento)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
proyectos proyecto = context.proyectos
.First(i => i.id_proyecto == id_proyecto);
proyecto.usuario_edicion = usuario.ToUpper();
proyecto.fecha_edicion = DateTime.Now;
proyecto.terminado = true;
proyecto.id_proyecto_estatus = 2;
DocumentosCOM documentos = new DocumentosCOM();
documento.id_documento_tipo = 2;
string vmensaje = documentos.Agregar(documento);
if (vmensaje == "")
{
context.SaveChanges();
return("");
}
else
{
return("Error al anexar documento, " + vmensaje);
}
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
public Boolean Exists(string riesgo, int id_proyecto_evaluacion)
{
try
{
DataTable dt = new DataTable();
Proyectos_ConnextEntities db = new Proyectos_ConnextEntities();
var riesgos = (from r in db.riesgos
where (r.riesgo.ToUpper() == riesgo && r.id_proyecto_evaluacion == id_proyecto_evaluacion &&
r.usuario_borrado == null)
select new
{
r.id_riesgo
});
dt = To.DataTable(riesgos.ToList());
return(dt.Rows.Count > 0);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(false);
}
}
/// <summary>
/// Agrega una instancia de riesgos_estatus
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Agregar(riesgos_estatus entidad)
{
try
{
string mess = "";
if (Exist(entidad.estatus))
{
mess = "Ya existe un estatus llamado: " + entidad.estatus;
}
else
{
riesgos_estatus estatus = new riesgos_estatus
{
estatus = entidad.estatus,
activo = true,
usuario = entidad.usuario.ToUpper(),
fecha = DateTime.Now
};
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
context.riesgos_estatus.Add(estatus);
context.SaveChanges();
}
return(mess);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Elimina una instancia de actividades
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Eliminar(int id_actividad, string usuario)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
actividades actividad = context.actividades
.First(i => i.id_actividad == id_actividad);
actividad.usuario_borrado = usuario;
actividad.fecha_borrado = DateTime.Now;
actividad.comentarios_borrado = "Borrado por usuario:" + usuario;
ICollection <documentos> documentos_por_borrar = actividad.documentos;
foreach (documentos documento in documentos_por_borrar)
{
documento.usuario_borrado = usuario;
documento.fecha_borrado = DateTime.Now;
documento.comentarios_borrado = "Borrado por usuario:" + usuario;
}
context.SaveChanges();
return("");
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Regresa el id de la evaluacion mas reciente
/// </summary>
/// <param name="id_proyecto"></param>
/// <param name="dias"></param>
/// <returns></returns>
public int get_id_proyecto_evaluacion(int id_proyecto)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.proyectos_evaluaciones
.Where(s => s.usuario_borrado == null && s.id_proyecto == id_proyecto)
.Select(u => new
{
u.id_proyecto_evaluacion,
u.id_proyecto,
u.fecha_evaluacion
})
.OrderBy(u => u.id_proyecto_evaluacion);
DataTable dt = To.DataTable(query.ToList());
return(dt.Rows.Count > 0 ? Convert.ToInt32(dt.Rows[dt.Rows.Count - 1]["id_proyecto_evaluacion"]):0);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(0);
}
}
/// <summary>
/// Devuelve un valor booleano si existe un impacto con el mismo nombre
/// </summary>
/// <param name="titulo"></param>
/// <returns></returns>
public bool Exist(string nombre)
{
DataTable dt = new DataTable();
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.proyectos_tecnologias
.Where(s => s.nombre.ToUpper() == nombre.ToUpper() && s.activo)
.Select(u => new
{
u.id_proyecto_tecnologia
})
.OrderBy(u => u.id_proyecto_tecnologia);
dt = To.DataTable(query.ToList());
return(dt.Rows.Count > 0);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(false);
}
}
public bool Exist(int id_actividad, int id_riesgo)
{
DataTable dt = new DataTable();
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.actividades
.Where(s => s.id_actividad == id_actividad && s.id_riesgo == id_riesgo)
.Select(u => new
{
u.id_actividad
})
.OrderBy(u => u.id_actividad);
dt = To.DataTable(query.ToList());
return(dt.Rows.Count > 0);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(false);
}
}
/// <summary>
/// Agrega una instancia de proyectos_tecnologias
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Agregar(proyectos_tecnologias entidad)
{
try
{
string mess = "";
if (Exist(entidad.nombre))
{
mess = "Ya existe una tecnologia llamado: " + entidad.nombre;
}
else
{
proyectos_tecnologias tecnologia = new proyectos_tecnologias
{
nombre = entidad.nombre,
activo = true,
usuario = entidad.usuario.ToUpper(),
fecha = DateTime.Now
};
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
context.proyectos_tecnologias.Add(tecnologia);
context.SaveChanges();
}
return(mess);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
public DataTable SelectAll()
{
try
{
DataTable dt = new DataTable();
Proyectos_ConnextEntities db = new Proyectos_ConnextEntities();
var riesgos = (from ta in db.actividades_tipos
where (ta.activo)
orderby(ta.tipo)
select new
{
ta.id_actividad_tipo,
ta.tipo
});
dt = To.DataTable(riesgos.ToList());
return(dt);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
/// <summary>
/// Devuelve un listado de instancias de la clase evaluaciones por proyectos
/// </summary>
/// <param name="id_proyecto_perido"></param>
/// <returns></returns>
public DataTable evaluaciones(int id_proyecto)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
var query = context.proyectos_evaluaciones
.Where(s => s.usuario_borrado == null && s.id_proyecto == id_proyecto)
.Select(u => new
{
u.id_proyecto_evaluacion,
u.id_proyecto,
u.fecha_evaluacion,
u.riesgo_costo,
u.riesgo_tiempo,
u.p_riesgo_costo,
u.p_riesgo_tiempo
})
.OrderBy(u => u.fecha_evaluacion);
DataTable dt = To.DataTable(query.ToList());
dt.Columns.Add("fecha_evaluacion_str");
foreach (DataRow row in dt.Rows)
{
row["fecha_evaluacion_str"] = Convert.ToDateTime(row["fecha_evaluacion"]).ToString("dd MMM yyyy", CultureInfo.CreateSpecificCulture("es-MX"));
}
return(dt);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
/// <summary>
/// Agrega una instancia de proyectos
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Agregar(proyectos entidad, List <proyectos_historial_tecnologias> tecnologias)
{
try
{
string mess = "";
if (Exist(entidad.proyecto))
{
mess = "Ya existe un proyecto llamado: " + entidad.proyecto;
}
else
{
proyectos proyecto = new proyectos
{
id_proyecto_periodo = entidad.id_proyecto_periodo,
id_proyecto_estatus = entidad.id_proyecto_estatus,
proyecto = entidad.proyecto,
usuario_resp = entidad.usuario_resp,
descripcion = entidad.descripcion,
folio_op = entidad.folio_op,
folio_pmt = entidad.folio_pmt,
id_cliente = entidad.id_cliente,
duración = entidad.duración,
avance = entidad.avance,
terminado = false,
correo_bienvenida = false,
fecha_inicio = entidad.fecha_inicio,
fecha_fin = entidad.fecha_fin,
costo_mn = entidad.costo_mn,
costo_usd = entidad.costo_usd,
usuario = entidad.usuario.ToUpper(),
fecha_registro = DateTime.Now,
cped = entidad.cped,
tipo_moneda = entidad.tipo_moneda
};
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
context.proyectos.Add(proyecto);
context.SaveChanges();
foreach (proyectos_historial_tecnologias tecnologia in tecnologias)
{
tecnologia.id_proyecto = proyecto.id_proyecto;
tecnologia.activo = true;
context.proyectos_historial_tecnologias.Add(tecnologia);
}
context.SaveChanges();
ProyectosEmpleadosCOM empleados = new ProyectosEmpleadosCOM();
empleados.Agregar(proyecto.id_proyecto, 1, proyecto.usuario_resp, proyecto.usuario);
}
return(mess);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Edita una instancia de proyectos
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Editar(proyectos entidad, List <proyectos_historial_tecnologias> tecnologias)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
proyectos proyecto = context.proyectos
.First(i => i.id_proyecto == entidad.id_proyecto);
proyecto.proyecto = entidad.proyecto;
proyecto.id_proyecto_periodo = entidad.id_proyecto_periodo;
proyecto.id_proyecto_estatus = entidad.id_proyecto_estatus;
proyecto.proyecto = entidad.proyecto;
proyecto.descripcion = entidad.descripcion;
proyecto.folio_op = entidad.folio_op;
proyecto.folio_pmt = entidad.folio_pmt;
proyecto.id_cliente = entidad.id_cliente;
proyecto.duración = entidad.duración;
proyecto.avance = entidad.avance;
proyecto.terminado = false;
proyecto.correo_bienvenida = false;
proyecto.fecha_inicio = entidad.fecha_inicio;
proyecto.fecha_fin = entidad.fecha_fin;
proyecto.usuario_edicion = entidad.usuario_edicion.ToUpper();
proyecto.fecha_edicion = DateTime.Now;
proyecto.usuario_resp = entidad.usuario_resp;
proyecto.cped = entidad.cped;
proyecto.costo_usd = entidad.costo_usd;
proyecto.costo_mn = entidad.costo_mn;
proyecto.tipo_moneda = entidad.tipo_moneda;
context.SaveChanges();
List <proyectos_historial_tecnologias> tecnologias_historial = proyecto.proyectos_historial_tecnologias.ToList();
foreach (proyectos_historial_tecnologias ptecno in tecnologias_historial)
{
context.proyectos_historial_tecnologias.Remove(ptecno);
}
context.SaveChanges();
foreach (proyectos_historial_tecnologias tecnologia in tecnologias)
{
tecnologia.id_proyecto = proyecto.id_proyecto;
tecnologia.activo = true;
context.proyectos_historial_tecnologias.Add(tecnologia);
}
context.SaveChanges();
return("");
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Eliminar una instancia de evaluaciones
/// </summary>
/// <param name="entidad"></param>
/// <returns></returns>
public string Eliminar(proyectos_evaluaciones entidad)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
proyectos_evaluaciones evaluacion = context.proyectos_evaluaciones
.First(i => i.id_proyecto_evaluacion == entidad.id_proyecto_evaluacion);
evaluacion.usuario_borrado = entidad.usuario_borrado.ToUpper();
evaluacion.fecha_borrado = DateTime.Now;
evaluacion.comentarios_borrado = entidad.comentarios_borrado;
ICollection <riesgos> riesgos = evaluacion.riesgos;
//borramos riesgos
foreach (riesgos riesgo in riesgos)
{
riesgo.usuario_borrado = entidad.usuario_borrado.ToUpper();
riesgo.fecha_borrado = DateTime.Now;
riesgo.comentarios_borrado = entidad.comentarios_borrado;
//borramos actividades
ICollection <actividades> actividades = riesgo.actividades;
foreach (actividades actividad in actividades)
{
actividad.usuario_borrado = entidad.usuario_borrado.ToUpper();
actividad.fecha_borrado = DateTime.Now;
actividad.comentarios_borrado = entidad.comentarios_borrado;
//borramos documentos
ICollection <documentos> documentos = actividad.documentos;
foreach (documentos documento in documentos)
{
documento.usuario_borrado = entidad.usuario_borrado.ToUpper();
documento.fecha_borrado = DateTime.Now;
documento.comentarios_borrado = entidad.comentarios_borrado;
}
}
}
context.SaveChanges();
return("");
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
/// <summary>
/// Devuelve una instancia de la clase riesgos
/// </summary>
/// <param name="id_proyecto_perido"></param>
/// <returns></returns>
public DataTable riesgo(int id_riesgo)
{
try
{
DataTable dt = new DataTable();
Proyectos_ConnextEntities db = new Proyectos_ConnextEntities();
var riesgos = (from r in db.riesgos
join re in db.riesgos_estatus on r.id_riesgos_estatus equals re.id_riesgos_estatus
join rp in db.riesgos_probabilidad on r.id_riesgo_probabilidad equals rp.id_riesgo_probabilidad
join ric in db.riesgos_impactos on r.id_riesgo_impacto equals ric.id_riesgo_impacto
join rs in db.riesgos_estrategia on r.id_riesgo_estrategia equals rs.id_riesgo_estrategia
join pe in db.proyectos_evaluaciones on r.id_proyecto_evaluacion equals pe.id_proyecto_evaluacion
join p in db.proyectos on pe.id_proyecto equals p.id_proyecto
join pht in db.proyectos_historial_tecnologias on p.id_proyecto equals pht.id_proyecto
join pt in db.proyectos_tecnologias on pht.id_proyecto_tecnologia equals pt.id_proyecto_tecnologia
where (r.id_riesgo == id_riesgo)
select new
{
pt.id_proyecto_tecnologia,
tecnologia = pt.nombre,
r.id_riesgo,
r.riesgo,
r.id_riesgos_estatus,
re.estatus,
r.id_riesgo_probabilidad,
probabilidad = rp.nombre,
estrategia_detalle = r.estrategia,
impacto_costo = ric.nombre,
r.id_riesgo_impacto,
r.id_riesgo_estrategia,
estrategia = rs.nombre,
fecha_evaluacion = pe.fecha_evaluacion,
proyecto = p.proyecto
});
dt = To.DataTable(riesgos.ToList());
return(dt);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
public string GuardarResultado(actividades entidad, List <documentos> lstdocumento)
{
try
{
string mess = "";
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
actividades actividad = context.actividades
.First(i => i.id_actividad == entidad.id_actividad);
actividad.fecha_ejecucion = DateTime.Now;
actividad.fecha_edicion = DateTime.Now;
actividad.usuario_edicion = entidad.usuario_edicion;
actividad.resultado = entidad.resultado;
actividad.recomendada = entidad.recomendada;
actividad.terminada = true;
int id_actividad = actividad.id_actividad;
List <documentos> lstdocumentos = actividad.documentos.ToList();
foreach (documentos document in lstdocumentos)
{
document.usuario_borrado = entidad.usuario_edicion;
document.fecha_borrado = DateTime.Now;
document.comentarios_borrado = "BORRADO POR ACTUALIZACIÓN";
}
foreach (documentos documento in lstdocumento)
{
if (documento.id_actividad == entidad.id_actividad)
{
documento.id_documento_tipo = 1;
documento.id_actividad = id_actividad;
context.documentos.Add(documento);
}
}
context.SaveChanges();
context.SaveChanges();
return("");
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
public int Agregar(actividades entidad, List <documentos> lstdocumento)
{
try
{
string mess = "";
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
actividades actividad = new actividades
{
id_proyecto = entidad.id_proyecto,
id_riesgo = entidad.id_riesgo,
nombre = entidad.nombre,
id_actividad_tipo = entidad.id_actividad_tipo,
empleado_resp = entidad.empleado_resp,
usuario_resp = entidad.usuario_resp,
fecha_ejecucion = entidad.fecha_ejecucion,
fecha_asignacion = entidad.fecha_asignacion,
usuario = entidad.usuario,
fecha_registro = DateTime.Now,
resultado = entidad.resultado,
recomendada = entidad.recomendada,
terminada = false
};
context.actividades.Add(actividad);
context.SaveChanges();
int id_actividad = actividad.id_actividad;
foreach (documentos documento in lstdocumento)
{
if (documento.id_actividad == entidad.id_actividad)
{
documento.id_documento_tipo = 1;
documento.id_actividad = id_actividad;
context.documentos.Add(documento);
}
}
context.SaveChanges();
return(id_actividad);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(0);
}
}
public string EditarImpacto(int id_riesgo, int id_impacto, string usuario)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
riesgos riesgo = context.riesgos
.First(i => i.id_riesgo == id_riesgo);
int id_probabilidad = Convert.ToInt32(riesgo.id_riesgo_probabilidad);
if (id_impacto > 0 && id_probabilidad > 0)
{
RiesgosProbabilidadCOM probabilidades = new RiesgosProbabilidadCOM();
riesgos_probabilidad probabilidad = probabilidades.impacto(id_probabilidad);
RiesgosImpactoCostosCOM impactos = new RiesgosImpactoCostosCOM();
riesgos_impactos impacto = impactos.impacto(id_impacto);
int valor = impacto.valor * probabilidad.valor;
RiesgosEstrategiaCOM estrategias = new RiesgosEstrategiaCOM();
DataTable dt = estrategias.SelectAll();
foreach (DataRow estrategia in dt.Rows)
{
int value_min = Convert.ToInt16(estrategia["valor_min"]);
int value_max = Convert.ToInt16(estrategia["valor_max"]);
if (valor >= value_min && valor <= value_max)
{
riesgo.usuario_edicion = usuario;
riesgo.fecha_edicion = DateTime.Now;
riesgo.valor = Convert.ToByte(valor);
riesgo.id_riesgo_estrategia = Convert.ToInt32(estrategia["id_riesgo_estrategia"]);
riesgo.id_riesgo_impacto = id_impacto;
break;
}
}
}
context.SaveChanges();
return("");
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(fullErrorMessage.ToString());
}
}
public List <proyectos_roles> list_proyectos_roles()
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
List <proyectos_roles> list = context.proyectos_roles
.Where(i => i.activo).ToList();
return(list);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
/// <summary>
/// Devuelve una instancia de la clase riesgos_estrategia
/// </summary>
/// <param name="id_proyecto_perido"></param>
/// <returns></returns>
public riesgos_estrategia estrategia(int id_riesgo_estrategia)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
riesgos_estrategia impacto = context.riesgos_estrategia
.First(i => i.id_riesgo_estrategia == id_riesgo_estrategia);
return(impacto);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
/// <summary>
/// Devuelve una instancia de la clase proyectos_tecnologias
/// </summary>
/// <param name="id_proyecto_perido"></param>
/// <returns></returns>
public proyectos_tecnologias tecnologia(int id_proyecto_tecnologia)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
proyectos_tecnologias impacto = context.proyectos_tecnologias
.First(i => i.id_proyecto_tecnologia == id_proyecto_tecnologia);
return(impacto);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
/// <summary>
/// Devuelve una instancia de la clase proyectos_periodos
/// </summary>
/// <param name="id_proyecto_periodo"></param>
/// <returns></returns>
public proyectos_periodos proyectos_periodo(int id_proyecto_periodo)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
proyectos_periodos proyectos_periodo = context.proyectos_periodos
.First(i => i.id_proyecto_periodo == id_proyecto_periodo);
return(proyectos_periodo);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
public actividades actividad(int id_actividad)
{
try
{
Proyectos_ConnextEntities context = new Proyectos_ConnextEntities();
actividades actividad = context.actividades
.First(i => i.id_actividad == id_actividad);
return(actividad);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}
/// <summary>
/// Devuelve una instancia de la clase riesgos
/// </summary>
/// <param name="id_proyecto_perido"></param>
/// <returns></returns>
public riesgos getriesgo(string riesgostr)
{
try
{
Proyectos_ConnextEntities db = new Proyectos_ConnextEntities();
riesgos riesgo = db.riesgos
.First(i => i.riesgo.Trim().ToUpper() == riesgostr.ToUpper().Trim());
return(riesgo);
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
var fullErrorMessage = string.Join("; ", errorMessages);
return(null);
}
}