public static SUBPROYECTO UpdateSubproyecto(SUBPROYECTO subproyecto)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.SUBPROYECTOes
where s.id_subproyecto == subproyecto.id_subproyecto
select s).Single();
sub.asignacion_automatica = subproyecto.asignacion_automatica;
sub.fecha_fin_estimada = subproyecto.fecha_fin_estimada;
sub.fecha_fin_real = subproyecto.fecha_fin_real;
sub.fecha_inicio_estimada = subproyecto.fecha_inicio_estimada;
sub.fecha_inicio_real = subproyecto.fecha_inicio_real;
sub.forzada_fecha_fin_estimada = subproyecto.forzada_fecha_fin_estimada;
sub.forzada_fecha_inicio_estimada = subproyecto.forzada_fecha_inicio_estimada;
sub.genera_ot = subproyecto.genera_ot;
sub.horas_estimadas = subproyecto.horas_estimadas;
sub.id_estado_proyecto = subproyecto.id_estado_proyecto;
sub.id_hora_tipo_subproyecto = subproyecto.id_hora_tipo_subproyecto;
sub.id_prioridad = subproyecto.id_prioridad;
sub.id_proyecto = subproyecto.id_proyecto;
sub.id_proyecto_padre_viejo = subproyecto.id_proyecto_padre_viejo;
sub.id_proyecto_viejo = subproyecto.id_proyecto_viejo;
sub.id_subproyecto_padre = subproyecto.id_subproyecto_padre;
sub.id_tipo_subproyecto = subproyecto.id_tipo_subproyecto;
sub.nombre = subproyecto.nombre;
sub.observaciones = subproyecto.observaciones;
sub.orden = subproyecto.orden;
sub.ot = subproyecto.ot;
sub.ot_cliente = subproyecto.ot_cliente;
sub.horas_orden_compra = subproyecto.horas_orden_compra;
bd.SaveChanges();
}
return(subproyecto);
}
/// <summary>
/// Busca por OT del subproyecto
/// </summary>
/// <param name="ot"></param>
/// <returns></returns>
public static SUBPROYECTO BuscarPorOT(int ot, int idUsuario, bool validarMiembro)
{
SUBPROYECTO subp = null;
using (var bd = new DescarEntity())
{
if (!validarMiembro)
{
var sub = (from s in bd.SUBPROYECTOes
join orden in bd.ORDEN_TRABAJO on s.ot.Value equals orden.id_orden_trabajo
where orden.nro_orden_trabajo == ot
select s);
subp = sub.Any() ? sub.First() : null;
}
else
{
var sub = (from s in bd.SUBPROYECTOes
join up in bd.Usuario_Proyecto on s.id_proyecto equals up.id_proyecto
join orden in bd.ORDEN_TRABAJO on s.ot.Value equals orden.id_orden_trabajo
where orden.nro_orden_trabajo == ot
& up.id_usuario == idUsuario
select s);
subp = sub.Any() ? sub.First() : null;
}
return(subp);
}
}
public static SUBPROYECTO BuscarPorOTCliente(string ot, int idUsuario, bool validarMiembro)
{
SUBPROYECTO subp = null;
using (var bd = new DescarEntity())
{
if (!validarMiembro)
{
var sub = (from s in bd.SUBPROYECTOes
where s.ot_cliente.Contains(ot)
select s);
subp = sub.Any() ? sub.First() : null;
}
else
{
var sub = (from s in bd.SUBPROYECTOes
join up in bd.Usuario_Proyecto on s.id_proyecto equals up.id_proyecto
where s.ot_cliente.Contains(ot)
& up.id_usuario == idUsuario
select s);
subp = sub.Any() ? sub.First() : null;
}
return(subp);
}
}
/// <summary>
/// Actualiza la hora del subproyecto para que la suma sea igual a las horas de las actividades
/// incluyendo los subproyectos hijos.
/// </summary>
/// <param name="subproyecto">Subproyecto a actualizar, incluyendo sus hijos</param>
/// <returns></returns>
public static decimal ActualizarHorasSubproyecto(SUBPROYECTO subproyecto)
{
List <SUBPROYECTO> subproyectos = ObtenerSubproyectosHijos(subproyecto);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subproyecto);
List <SUBPROYECTO> hijos;
decimal total = 0;
//Función recursiva para calcular las horas de los subproyectos hijos
foreach (var subpro in subproyectos)
{
total += ActualizarHorasSubproyecto(subpro);
}
//Recorre las actividades y suma sus horas
foreach (var item in actividades)
{
item.cantidad_hora = (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
ControladorActividades.ActualizarActividadProyecto(item);
total += (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
}
subproyecto.horas_estimadas = total;
ActualizarSubproyecto(subproyecto);
return(total);
}
public static bool EliminarSubproyecto(SUBPROYECTO subproyecto)
{
var lista = new List <Tuple <SUBPROYECTO, int> >();
var subpHijos = ObtenerEstructuraSubproyectos(lista, subproyecto, 1);
foreach (var subp in subpHijos)
{
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subp.Item1);
foreach (var item in actividades)
{
if (ControladorActividades.TieneHorasLogueadas(item))
{
return(false);
}
}
}
foreach (var subp in subpHijos)
{
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subp.Item1);
foreach (var item in actividades)
{
ControladorActividades.EliminarActividad(item);
}
SubproyectoBD.EliminarSubproyecto(subp.Item1);
}
return(true);
}
public static List <AvanceSubproyecto> ObtenerAvanceConcepto(SUBPROYECTO subpr, Tipo_actividad tipo_actividad)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.SUBPROYECTOes
join ap in bd.Actividad_proyecto on s.id_subproyecto equals ap.id_subproyecto
join a in bd.Actividads on ap.id_actividad equals a.id_actividad
join mv in bd.Movimiento_voz on ap.id_actividad_proyecto equals mv.id_actividad_proyecto
join u_prod in bd.USUARIOs on mv.id_usuario_1 equals u_prod.id_usuario
join u_ctrl in bd.USUARIOs on mv.id_usuario_2 equals u_ctrl.id_usuario
join u_corr in bd.USUARIOs on mv.id_usuario_3 equals u_corr.id_usuario
where s.id_subproyecto == subpr.id_subproyecto
& a.id_tipo_actividad == tipo_actividad.id_tipo_actividad
select new AvanceSubproyecto()
{
subproyecto = s,
completado = mv.completado.Value,
completado_control = mv.control_1.Value,
completado_correccion_1 = mv.control_corr_1.Value,
completado_produccion = mv.control_prod.Value,
responsableCalidad = u_ctrl,
responsableProduccion = u_prod,
actividad_proyecto = ap,
responsableCorreccion = u_corr
});
return(sub.ToList());
}
}
private void GenerarEstructuraCATIA(Product product, int id_proyecto, int id_subproyecto, bool esProyecto)
{
var controladorSubproyecto = new ControladorSubproyecto();
var controladorProyecto = new ControladorProyecto();
var subproyectosHijos = new List <SUBPROYECTO>();
//Verifica que la raiz del arbol sea un proyecto, o un subroyecto, y si es este ultimo
//verifica si es unidad o no.
if (esProyecto)
{
if (id_subproyecto != null & id_subproyecto > 1)
{
SUBPROYECTO subproyecto = ControladorSubproyecto.BuscarPorId(id_subproyecto);
{
product = CreateProduct(null, subproyecto.nombre);
}
}
else
{
Proyecto proyecto = ControladorProyecto.ObtenerPorID(id_proyecto);
product = CreateProduct(null, ((Proyecto)proyecto).nombre_proyecto);
}
}
subproyectosHijos = ControladorSubproyecto.ObtenerPorProyecto(id_proyecto, id_subproyecto);
if (subproyectosHijos.Count > 0)
{
foreach (var subproyecto in subproyectosHijos)
{
Product prod = CreateProduct(product, subproyecto.nombre);
GenerarEstructuraCATIA(prod, id_proyecto, subproyecto.id_subproyecto, false);
}
}
}
public static TIPO_SUBPROYECTO ObtenerTipoSubproyecto(SUBPROYECTO subproyecto)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.TIPO_SUBPROYECTO
where s.id_tipo_subproyecto == subproyecto.id_tipo_subproyecto
select s);
return(sub.Any() ? sub.Single() : null);
}
}
public static List <Actividad_proyecto> ObtenerActividades(SUBPROYECTO subproyecto)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.Actividad_proyecto
where s.id_subproyecto == subproyecto.id_subproyecto
select s);
return(sub.Any() ? sub.ToList().OrderBy(x => x.orden).ToList() : new List <Actividad_proyecto>());
}
}
public static SUBPROYECTO ObtenerSubproyectoPadre(SUBPROYECTO subpro)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.SUBPROYECTOes
where s.id_subproyecto == subpro.id_subproyecto_padre
select s);
return(sub.Any() ? sub.Single() : null);
}
}
public static List <SUBPROYECTO> ObtenerSubproyectosHijos(SUBPROYECTO subpro)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.SUBPROYECTOes
where s.id_subproyecto_padre == subpro.id_subproyecto &&
s.id_proyecto == subpro.id_proyecto
select s);
return(sub.OrderBy(x => x.orden).ToList());
}
}
/// <summary>
/// Actualiza el valor de asignacion automatica al subproyecto indicado y sus hijos.
/// </summary>
/// <param name="subproyecto"></param>
/// <param name="nuevoValor"></param>
public static void ActualizarAsignacionAutomatica(SUBPROYECTO subproyecto, bool nuevoValor)
{
SUBPROYECTO sub = subproyecto;
List <SUBPROYECTO> subHijos = ObtenerSubproyectosHijos(sub);
foreach (var item in subHijos)
{
SubproyectoBD.ActualizarAsignacionAutomatica(item, nuevoValor);
ActualizarAsignacionAutomatica(item, nuevoValor);
}
}
public static void EliminarSubproyecto(SUBPROYECTO item1)
{
using (var bd = new DescarEntity())
{
var sub = (from ap in bd.SUBPROYECTOes
where ap.id_subproyecto == item1.id_subproyecto
select ap);
bd.SUBPROYECTOes.RemoveRange(sub);
bd.SaveChanges();
}
}
public static List <USUARIO> ObtenerMiembrosDirectos(SUBPROYECTO subproyecto)
{
using (var bd = new DescarEntity())
{
var subs = (from s in bd.USUARIOs
join us in bd.Usuario_Proyecto on s.id_usuario equals us.id_usuario
where us.id_subproyecto == subproyecto.id_subproyecto
select s);
return(subs.ToList());
}
}
public static void ActualizarHorasOrdenCompraHijos(SUBPROYECTO subpr)
{
if (subpr.horas_orden_compra.HasValue)
{
List <SUBPROYECTO> hijos = ObtenerSubproyectosHijos(subpr);
foreach (var item in hijos)
{
item.horas_orden_compra = (decimal)CalcularHorasOrdenCompra(item);
ActualizarSubproyecto(item);
}
}
}
public static List <Actividad> ObtenerActividadesDeSubproyecto(SUBPROYECTO subpro)
{
using (var bd = new DescarEntity())
{
var act = (from ap in bd.Actividad_proyecto
join a in bd.Actividads on ap.id_actividad equals a.id_actividad
where ap.id_subproyecto == subpro.id_subproyecto
select a);
return(act.ToList());
}
}
public static bool AsignarSubproyecto(SUBPROYECTO subproyecto, double cantidad_horas_solapamiento)
{
bool salida = true;
if (subproyecto != null && subproyecto.asignacion_automatica)
{
ControladorActividades.ActualizarOrdenActividades(subproyecto);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subproyecto).OrderBy(x => x.orden).ToList();
Proyecto proyecto = ControladorProyecto.ObtenerPorID(subproyecto.id_proyecto.Value);
if (!proyecto.activo.Value)
{
return(false);
}
foreach (var actividad in actividades)
{
if (!ControladorActividades.EstaCompletada(actividad) && ObtenerPorActividad(actividad) == null)
{
if (!AsignarActividadProyecto(actividad, cantidad_horas_solapamiento))
{
//La actividad no pudo ser asignada
salida = false;
}
}
else if (ObtenerPorActividad(actividad) != null)
{
//TODO si la actividad ya esta logueada, verificar el tema de las horas, calcular hora fin, etc
}
}
return(salida);
}
return(salida);
/*
* Consideraciones:
* - El subproyecto tiene que tener los miembros asignados, o el proyecto.
* - El proyecto tiene que estar activo
* - Las actividades no tienen que estar completadas (recordar que pasa con el primer control)
* - Las actividades no tienen que tener una tarea asignada, ya que los correspondtientes fueron borrados, sino
* hay que respetar la tarea a ese usuario o esta forzada.
* - Solo los usuarios miembros para esa actividad pueden realizarla
* - Primero las actividades mas largas
* - Ordenar la lista de usuarios por el que tiene menos calificaciones primero.
* - Tener en cuenta que a futuro se agregan prioridades.
*
* Como ordenar por fecha?. SI erdeno la lista por usuarios, pero otro que está mas alto en la lista
* puede empezarlo antes.
*/
}
/// <summary>
/// Para que sean compatibles el orden que se usaba anteriormente de numeros impares al nuevo por 1,2,3,4..
/// </summary>
/// <param name="sub"></param>
public static void ActualizarOrdenActividades(SUBPROYECTO sub)
{
List <Actividad_proyecto> actividades = ObtenerActividadesProyectoDeSubproyecto(sub).OrderBy(x => x.orden).ToList();
foreach (var act in actividades)
{
if (act.orden != actividades.IndexOf(act) + 1)
{
act.orden = actividades.IndexOf(act) + 1;
ControladorActividades.ActualizarActividadProyecto(act);
}
}
}
/// <summary>
/// Comprobar metodo
/// </summary>
/// <param name="subproyecto"></param>
/// <returns></returns>
public static List <USUARIO> ObtenerMiembrosDirectosOrdenMenorCalificaciones(SUBPROYECTO subproyecto)
{
using (var bd = new DescarEntity())
{
var subs = (from s in bd.USUARIOs
join us in bd.Usuario_Proyecto on s.id_usuario equals us.id_usuario
join tau in bd.Tipo_Actividad_usuario on us.id_usuario equals tau.id_usuario
where us.id_subproyecto == subproyecto.id_subproyecto
select s);
return(subs.ToList().GroupBy(x => x.id_usuario).OrderByDescending(x => x.Count()).ToList().Select(x => x.First()).ToList());
}
}
public static void EliminarDetalleRecursoSubproyecto(SUBPROYECTO subproyecto)
{
using (var bd = new DescarEntity())
{
var act = (from mv in bd.Detalle_recurso
join ap in bd.Actividad_proyecto on mv.id_actividad_proyecto equals ap.id_actividad_proyecto
where ap.id_subproyecto == subproyecto.id_subproyecto
select mv);
bd.Detalle_recurso.RemoveRange(act);
bd.SaveChanges();
}
}
public static SUBPROYECTO ActualizarAsignacionAutomatica(SUBPROYECTO subproyecto, bool nuevo_valor)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.SUBPROYECTOes
where s.id_subproyecto == subproyecto.id_subproyecto
select s).Single();
sub.asignacion_automatica = nuevo_valor;
bd.SaveChanges();
}
return(subproyecto);
}
public static Actividad_proyecto ObtenerActividaHijaDeTipo(SUBPROYECTO subproyecto, Tipo_actividad tipo)
{
using (var bd = new DescarEntity())
{
var sub = (from ap in bd.Actividad_proyecto
join a in bd.Actividads on ap.id_actividad equals a.id_actividad
where ap.id_subproyecto == subproyecto.id_subproyecto
& a.id_tipo_actividad == tipo.id_tipo_actividad
select ap);
return(sub.Any() ? sub.First() : null);
}
}
public static Actividad_proyecto ObtenerActividadPorTipoActividad(SUBPROYECTO subpr, Tipo_actividad tipo_actividad)
{
using (var bd = new DescarEntity())
{
var sub = (from s in bd.SUBPROYECTOes
join ap in bd.Actividad_proyecto on s.id_subproyecto equals ap.id_subproyecto
join a in bd.Actividads on ap.id_actividad equals a.id_actividad
where s.id_subproyecto == subpr.id_subproyecto
& a.id_tipo_actividad == tipo_actividad.id_tipo_actividad
select ap);
return(sub.Any() ? sub.First() : null);
}
}
/// <summary>
/// Devuelve el nombre del subproyecto segun ubicacion en el arbol
/// </summary>
/// <param name="subpro"></param>
/// <returns></returns>
public static String ObtenerPathSubproyecto(SUBPROYECTO subpro)
{
SUBPROYECTO subp_padre = ObtenerSubproyectoPadre(subpro);
List <String> path = new List <string>();
path.Add(subpro.nombre);
while (subp_padre != null)
{
path.Add(subp_padre.nombre);
subp_padre = ObtenerSubproyectoPadre(subp_padre);
}
path.Reverse();
return(string.Join(" / ", path));
}
/// <summary>
/// Solo para UNIDADES!
/// Calcula las horas asignadas a ese subproyecto, en base al presupuesto asignado al dispositivo
/// </summary>
/// <param name="subproyecto"></param>
/// <returns></returns>
public static decimal?CalcularHorasOrdenCompra(SUBPROYECTO subproyecto)
{
SUBPROYECTO subPadre = ObtenerSubproyectoPadre(subproyecto);
if (subPadre != null)
{
if (subPadre.horas_orden_compra.HasValue)
{
return((decimal)ObtenerHorasMinimasSubproyecto(subPadre) > 0 ? Convert.ToDecimal(subPadre.horas_orden_compra.Value * (decimal)ObtenerHorasMinimasSubproyecto(subproyecto) / (decimal)ObtenerHorasMinimasSubproyecto(subPadre)) : 0);
}
else
{
return((decimal)ObtenerHorasMinimasSubproyecto(subproyecto));
}
}
return(null);
}
private void CrearActividad(SUBPROYECTO Subproyecto, int idTipoActividad, string nombre, int orden)
{
//TODO controlar duplicaciones
var actAux = ControladorActividades.InsertarActividad(
new Entidades.Actividad(
ControladorActividades.ObtenerTipoActividad(idTipoActividad).criticidad,
idTipoActividad,
nombre,
1));
var actpro = ControladorActividades.InsertarActividadProyecto(new Actividad_proyecto(
_proyAux.id_proyecto,
actAux.id_actividad,
fecha_inicio: DateTime.Now,
fecha_fin_previsto: DateTime.Now,
fecha_fin_real: DateTime.Now,
cantidad_hora: 0,//Se actualiza después
objetivo: "",
prioridad: 1,
complejidad: 1,
avance: 0,
observacion: "",
orden: orden,
id_controlador_1: 8,
id_controlador_2: 8,
nro: 0,
id_cliente: _proyAux.id_cliente.HasValue ? _proyAux.id_cliente.Value : 0,
id_subproyecto: Subproyecto.id_subproyecto,
horas: 0,
id_estado_proyecto: 0,
porcentaje_avance: 0,
fecha_inicio_real: DateTime.Now,
asignada: false,
id_cadista: 0,
id_prioridad: 1,
id_control: 0,
id_proveedor: 0,
forzada_fecha_fin: false,
forzada_fecha_inicio: false,
no_conformidad: false,
motivo_no_conformidad: "",
asignable: true));
//ControladorTareas.VerificarAsignacionAutomatica(actpro);
}
/// <summary>
/// Obtiene las horas minimas de un subproyecto, esto es la suma de todas las actividades hijas, indirectamente.
/// </summary>
/// <param name="subpro"></param>
/// <returns></returns>
public static double ObtenerHorasMinimasSubproyecto(SUBPROYECTO subpro)
{
double total = 0;
List <SUBPROYECTO> lisSubpro = ObtenerSubproyectosHijos(subpro);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subpro);
//Función recursiva para calcular las horas de los subproyectos hijos
foreach (var sub in lisSubpro)
{
total += ObtenerHorasMinimasSubproyecto(sub);
}
//Recorre las actividades y suma sus horas asignadas
foreach (var act in actividades)
{
total += ControladorActividades.ObtenerHorasAsignadas(act);
}
return(total);
}
/// <summary>
/// Busca un subproyecto por el siguiente orden: <para/>
/// OT, OT Cliente, Nombre. Si validaMiembro es true, valida que el usuario indicado
/// sea miembro del mismo, de lo contrario no devuelve.
/// </summary>
/// <param name="texto"></param>
/// <returns></returns>
public static SUBPROYECTO Buscar(string texto, int idUsuario, bool validaMiembro)
{
SUBPROYECTO sub = null;
int ot = 0;
if (Int32.TryParse(texto, out ot))
{
sub = BuscarPorOT(ot, idUsuario, validaMiembro);
}
//Busca por OT cliente
if (sub == null)
{
sub = BuscarPorOTCliente(texto, idUsuario, validaMiembro);
}
//Busca por el nombre
if (sub == null)
{
sub = BuscarPorNombre(texto, idUsuario, validaMiembro);
}
return(sub);
}
public static DateTime?CalcularFechaFinSubproyecto(SUBPROYECTO subproyecto)
{
List <ClaseExpGantt> exp = new List <ClaseExpGantt>();
ControladorSubproyecto.ObtenerEstructuraSubproyectosConActividades(exp, subproyecto, 1);
List <DateTime?> fecha = new List <DateTime?>();
foreach (var item in exp)
{
if (item.actividad != null)
{
Detalle_recurso tarea = ObtenerPorActividad(item.actividadProy);
if (tarea != null && tarea.fecha_fin.HasValue)
{
fecha.Add(tarea.fecha_fin.Value);
}
}
}
fecha.Sort((a, b) => a.Value.CompareTo(b.Value));
return(fecha.Count > 0 ? fecha.ElementAt(fecha.Count - 1) : subproyecto.fecha_inicio_estimada.Value);
}
/// <summary>
/// Obtiene la lista de miembros a un subproyecto. Esto es indirectamente, es decir
/// si el subproyecto no tiene asignados miembros explicitamente, se buscará en el nivel del arbol
/// hacia arriba
/// </summary>
/// <param name="subproyecto">El subproyecto a buscar sus miembros</param>
/// <returns>Lista de miembros que pueden trabajar en ese subproyecto</returns>
public static List <USUARIO> ObtenerMiembrosIndirectos(SUBPROYECTO subproyecto)
{
List <USUARIO> miembros = ObtenerMiembrosDirectos(subproyecto);
SUBPROYECTO subp_padre;
if (miembros.Count > 0)
{
return(miembros);
}
else
{
subp_padre = ObtenerSubproyectoPadre(subproyecto);
if (subp_padre != null)
{
return(ObtenerMiembrosIndirectos(subp_padre));
}
else
{
return(ControladorProyecto.ObtenerMiembros(ControladorProyecto.ObtenerPorID(subproyecto.id_proyecto.Value)));
}
}
}
