/// <summary>
/// Obtiene la estructura de todo el proyecto, incluyendo las actividades que la involucran, y las asignaciones.
/// </summary>
/// <param name="lista"></param>
/// <param name="sub"></param>
/// <param name="nivel"></param>
/// <returns></returns>
public static List <ClaseExpGantt> ObtenerEstructuraSubproyectosConActividades(List <ClaseExpGantt> lista, SUBPROYECTO sub, int nivel)
{
List <SUBPROYECTO> listaSubproyectos = ObtenerSubproyectosHijos(subpro: sub);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(sub);
ClaseExpGantt estructura = new ClaseExpGantt()
{
subproyecto = sub, nivel = nivel
};
lista.Add(estructura);
nivel = nivel + 1;
foreach (var actividad in actividades)
{
Detalle_recurso tarea = ControladorTareas.ObtenerPorActividad(actividad);
ClaseExpGantt ExpoActivida = new ClaseExpGantt()
{
actividadProy = actividad, nivel = nivel, tarea = tarea, subproyecto = null, actividad = ControladorActividades.ObtenerActividad(actividad), usuario = tarea != null?ControladorUsuarios.ObtenerUsuario(tarea.id_usuario.Value) : null
};
lista.Add(ExpoActivida);
}
foreach (SUBPROYECTO subpro in listaSubproyectos)
{
ObtenerEstructuraSubproyectosConActividades(lista, subpro, nivel);
}
return(lista);
}
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);
}
/// <summary>
/// Agrega una tarea en la base de datos para el usuario seleccionado.
/// Se asigna con estado Pendiente.
/// Si el usuaro ya tiene ese
/// </summary>
/// <param name="idActividadProyectoSolicitar"></param>
/// <param name="idUsuario"></param>
/// <returns></returns>
public static Detalle_recurso RequerirTarea(int idActividadProyectoSolicitar, int idUsuario)
{
Detalle_recurso tarea = new Detalle_recurso();
tarea.id_actividad_proyecto = idActividadProyectoSolicitar;
tarea.forzada = false;
tarea.id_usuario = idUsuario;
tarea.motivo = "solicitud";
tarea.tipo = "";
tarea.porcentaje_avance = 0;
tarea.realizada = false;
tarea.cantidad_hora = Convert.ToDecimal(ControladorActividades.ObtenerHorasTotalesActividad(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar)));
tarea.id_estado = ObtenerEstadoPorNombre("Pendiente").IdEstadoTarea;
tarea.fecha_inicio = DateTime.Now;
tarea.fecha_fin = ControladorCalendario.CalcularFechaFin(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar), ControladorUsuarios.ObtenerUsuario(idUsuario), tarea.fecha_inicio.Value, ControladorActividades.ObtenerHorasTotalesActividad(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar)));
tarea.duracion_cadista = (decimal)ControladorActividades.ObtenerHorasOrdenCompraParaCadista(ControladorActividades.ObtenerActividadProyecto(idActividadProyectoSolicitar));
tarea.fecha_inicio_cadista = tarea.fecha_inicio;
tarea.fecha_fin_cadista = tarea.fecha_fin;
if (ControladorTareas.EstaAsignadaAUsuario(idActividadProyectoSolicitar, idUsuario) == null)
{
return(Insertar(tarea));
}
return(null);
}
private void ExportarControlesPredeterminados(IXLWorksheet worksheet, Proyecto proyecto)
{
//Controles Predeterminados
List <CONTROL_SUBPROYECTO> controles = ControladorControles.ObtenerControlesProyecto(proyecto);
for (int i = 2; i < 15; i++)
{
worksheet.Cell(i, 10).Value = "";
if (controles == null || controles.Count == 0)
{
continue;
}
Control control;
List <Tipo_actividad> actividades = ControladorActividades.ObtenerTiposActividad();
foreach (var tipo_act in actividades)
{
if (worksheet.Cell(i, 9).Value.ToString().ToLower().Equals(tipo_act.descripcion.ToLower()))
{
foreach (var ctrlSub in controles)
{
if (ctrlSub.id_tipo_actividad == tipo_act.id_tipo_actividad)
{
worksheet.Cell(i, 10).Value = ControladorControles.ObtenerPorID(ctrlSub.id_control).nombre_control;
break;
}
}
}
}
}
//Fin controles predeterminados
}
/// <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);
}
/// <summary>
/// Verifica si la actividad tiene asignación automática, y si no tiene
/// se lo asigna a todos sus miebros.
/// </summary>
/// <param name="act"></param>
/// <returns></returns>
public static bool VerificarAsignacionAutomatica(Actividad_proyecto act)
{
var subproyecto = ControladorSubproyecto.BuscarPorId(act.id_subproyecto.Value);
if (subproyecto.asignacion_automatica)
{
Usuario_Proyecto _Usuario_proyecto = new Usuario_Proyecto();
List <USUARIO> odt_miembros_subproyectos = ControladorSubproyecto.ObtenerMiembrosIndirectos(subproyecto);
foreach (USUARIO row in odt_miembros_subproyectos)
{
var detalle = new Detalle_recurso()
{
realizada = false,
tipo = "automatico",
porcentaje_avance = 0,
id_actividad_proyecto = act.id_actividad_proyecto,
motivo = "- Asignada automáticamente - ",
cantidad_hora = Convert.ToDecimal(ControladorActividades.ObtenerHorasPorOrdenCompra(act)),
id_usuario = Convert.ToInt32(row.id_usuario),
fecha_inicio = null,
fecha_fin = null
};
ControladorTareas.Insertar(detalle);
}
return(true);
}
return(false);
}
/// <summary>
/// Completar
/// </summary>
/// <param name="actividad"></param>
/// <returns></returns>
public static bool AsignarActividadProyecto(Actividad_proyecto actividad, double cantidad_horas_solapamiento)
{
List <Tuple <USUARIO, decimal> > miembros_habilitados = ControladorSubproyecto.ObtenerMiemrosHabilitadosParaAsignar(actividad);
DateTime fecha_inicio;
DateTime fecha_fin;
double tiempo_trabajado, tiempo_total;
tiempo_total = ControladorActividades.ObtenerHorasTotalesActividad(actividad);
tiempo_trabajado = 0;//ControladorActividades.ObtenerHorasConsumidas(actividad);
//Modificar este metodo para que verifique fecha inicio mayor a la actual.
fecha_inicio = ControladorActividades.ObtenerFechaInicioMinima(actividad);
//Devuelve la fecha fin ideal
fecha_fin = ControladorCalendario.ObtenerFechaFinMinima(actividad, fecha_inicio).Value;
List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > > listaPorFechaFin;
List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > > listaPorCalifi;
List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > > listaOrdenada = new List <Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> > >();
if (!ControladorActividades.EstaCompletada(actividad))
{
foreach (var miem in miembros_habilitados)
{
DateTime fecha = ObtenerFechaInicioMinimaUsuario(miem.Item1, fecha_inicio, tiempo_total - tiempo_trabajado, actividad, fecha_fin);
DateTime?fecha_fin_usuario = ControladorCalendario.CalcularFechaFin(actividad, miem.Item1, fecha, null);
listaOrdenada.Add(new Tuple <Tuple <USUARIO, decimal>, Tuple <DateTime, DateTime> >(miem, new Tuple <DateTime, DateTime>(fecha, fecha_fin_usuario.Value)));
}
if (listaOrdenada.Count > 0)
{
//Ordena la lista primero por fecha de fin, luego por calificaciones, el que tiene mas primero.
listaOrdenada = listaOrdenada.OrderBy(x => x.Item2.Item2).ThenByDescending(x => x.Item1.Item2).ToList();
listaPorFechaFin = listaOrdenada.OrderBy(x => x.Item2.Item2).ToList();
listaPorCalifi = listaOrdenada.OrderByDescending(x => x.Item1.Item2).ToList();
if (listaOrdenada.ElementAt(0).Item2.Item2.Subtract(listaPorCalifi.ElementAt(0).Item2.Item2).TotalHours <= cantidad_horas_solapamiento)
{
AsignarActividad(actividad, listaPorCalifi.ElementAt(0).Item1.Item1, listaPorCalifi.ElementAt(0).Item2.Item1, listaPorCalifi.ElementAt(0).Item2.Item2);
}
else
{
AsignarActividad(actividad, listaOrdenada.ElementAt(0).Item1.Item1, listaOrdenada.ElementAt(0).Item2.Item1, listaOrdenada.ElementAt(0).Item2.Item2);
}
return(true);
}
return(false);
}
return(false);
}
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);
}
}
}
public static List <Tuple <USUARIO, decimal> > ObtenerMiemrosHabilitadosParaAsignar(Actividad_proyecto actividad)
{
List <USUARIO> miembros = ObtenerMiembrosIndirectos(BuscarPorId(actividad.id_subproyecto.Value));
List <Tuple <USUARIO, Tuple <int, decimal> > > listaMiembros = new List <Tuple <USUARIO, Tuple <int, decimal> > >();
foreach (var item in miembros)
{
if (ControladorUsuarios.EstaHabilitadoParaActividad(item, actividad))
{
decimal?calif = ControladorActividades.ObtenerTipoActividadUsuario(ControladorActividades.ObtenerActividad(actividad).id_tipo_actividad, item.id_usuario).calificacion;
listaMiembros.Add(new Tuple <USUARIO, Tuple <int, decimal> >(item, new Tuple <int, decimal>(ControladorUsuarios.ObtenerCantidadCalificaciones(item), calif.HasValue ? calif.Value : 1)));
}
}
return(listaMiembros.OrderByDescending(x => x.Item2.Item2).ThenBy(x => x.Item2.Item1).AsEnumerable().Select(x => new Tuple <USUARIO, decimal>(x.Item1, x.Item2.Item2)).ToList());
}
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);
}
public static void SubirOrdenActividad(Actividad_proyecto actividad)
{
ActualizarOrdenActividades(ControladorSubproyecto.BuscarPorId(actividad.id_subproyecto.Value));
List <Actividad_proyecto> actividades = ObtenerActividadesProyectoDeSubproyecto(ControladorSubproyecto.BuscarPorId(actividad.id_subproyecto.Value)).OrderBy(x => x.orden).ToList();
int indexOf = actividades.IndexOf(actividades.Where(x => x.id_actividad_proyecto == actividad.id_actividad_proyecto).FirstOrDefault());
if (indexOf == 0)
{
return;
}
actividades[indexOf].orden--;
ControladorActividades.ActualizarActividadProyecto(actividades[indexOf]);
if (indexOf - 1 >= 0)
{
actividades[indexOf - 1].orden++;
ControladorActividades.ActualizarActividadProyecto(actividades[indexOf - 1]);
}
}
internal static void ActualizarHorasProyectosActivos()
{
List <Proyecto> proyectos_activos = ObtenerProyectosActivos();
decimal totalProy = 0;
decimal totalSub = 0;
foreach (var proyecto in proyectos_activos)
{
totalProy = 0;
List <SUBPROYECTO> subproyectos = ObtenerSubproyectosHijos(proyecto);
foreach (var subpro in subproyectos)
{
List <SUBPROYECTO> subproyectosHijos = ControladorSubproyecto.ObtenerSubproyectosHijos(subpro);
List <Actividad_proyecto> actividades = ControladorActividades.ObtenerActividadesProyectoDeSubproyecto(subpro);
List <SUBPROYECTO> hijos;
totalSub = 0;
//Función recursiva para calcular las horas de los subproyectos hijos
foreach (var sub in subproyectosHijos)
{
totalSub += ControladorSubproyecto.ActualizarHorasSubproyecto(sub);
}
//Recorre las actividades y suma sus horas
foreach (var item in actividades)
{
item.cantidad_hora = (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
ControladorActividades.ActualizarActividadProyecto(item);
totalSub += (decimal)ControladorActividades.ObtenerHorasTotalesActividad(item);
}
totalProy += totalSub;
subpro.horas_estimadas = totalSub;
ControladorSubproyecto.ActualizarSubproyecto(subpro);
}
proyecto.total_hora = totalProy;
Update(proyecto);
}
}
private void ImportarControlesPredeterminados(IXLWorksheet worksheet, Proyecto proyecto)
{
//Controles Predeterminados
for (int i = 2; i < 15; i++)
{
Control control;
List <Tipo_actividad> actividades = ControladorActividades.ObtenerTiposActividad();
foreach (var tipo_act in actividades)
{
if (worksheet.Cell(i, 9).Value.ToString().ToLower().Equals(tipo_act.descripcion.ToLower()))
{
CONTROL_SUBPROYECTO controlSub = ControladorControles.VerificarExistencia(tipo_act, proyecto);
control = ControladorControles.ObtenerPorNombre(worksheet.Cell(i, 10).Value.ToString());
if (control != null)
{
if (controlSub == null)
{
controlSub = new CONTROL_SUBPROYECTO()
{
id_proyecto = proyecto.id_proyecto,
id_control = control.id_control,
id_subproyecto = null,
id_tipo_actividad = tipo_act.id_tipo_actividad
};
ControladorControles.Insertar(controlSub);
}
//Existe, pero puede haber cambiado el tipo de actividad
else
{
controlSub.id_control = control.id_control;
ControladorControles.ActualizarControlSubproyecto(controlSub);
}
}
break;
}
}
}
//Fin controles predeterminados
}
/// <summary>
/// Asigna la actividad al usuario - VER TEMA DE FECHAS
/// </summary>
/// <param name="actividad"></param>
/// <param name="usuario"></param>
public static Detalle_recurso AsignarActividad(Actividad_proyecto actividad, USUARIO usuario, DateTime fecha_inicio, DateTime fecha_fin)
{
Detalle_recurso tarea = new Detalle_recurso();
tarea.cantidad_hora = (decimal)(ControladorActividades.ObtenerHorasTotalesActividad(actividad));
tarea.fecha_fin = fecha_fin;
tarea.fecha_inicio = fecha_inicio;
tarea.forzada = false;
tarea.id_actividad_proyecto = actividad.id_actividad_proyecto;
tarea.id_estado = ObtenerEstadoPorNombre("Asignado") != null?ObtenerEstadoPorNombre("Asignado").IdEstadoTarea : 0;
tarea.id_usuario = usuario.id_usuario;
tarea.motivo = "asignada por algoritmo";
tarea.porcentaje_avance = 0;
tarea.realizada = false;
tarea.tipo = "asignada por algoritmo";
tarea.fecha_inicio_cadista = fecha_inicio;
tarea.fecha_fin_cadista = fecha_fin;
tarea.duracion_cadista = (decimal)(ControladorActividades.ObtenerHorasOrdenCompraParaCadista(actividad));
return(TareaDB.AsignarActividad(tarea));
}
private void GenerarDatosUnidades(SUBPROYECTO sub)
{
IXLWorksheet _worksheetProyecto = _xlworkbook.Worksheet("Template Dispositivo");
IXLWorksheet _worksheetSoporte = _xlworkbook.Worksheet("Soporte");
IXLWorksheet sheetUnidad = _worksheetProyecto.CopyTo(sub.nombre.Length > 31 - sub.ot.Value.ToString().Length - 3 ? sub.ot + " - " + sub.nombre.Substring(0, 31 - sub.ot.Value.ToString().Length - 3) : sub.ot + " - " + sub.nombre, _worksheetProyecto.Position);
sheetUnidad.Unhide();
List <HORA_TIPO_SUBPROYECTO> _HORAS = ControladorSubproyecto.ObtenerHorasTipoUnidad();
//Formato
var dataV = sheetUnidad.Range("'+" + sheetUnidad.Name + "'!C9:C68").SetDataValidation();
dataV.List(_worksheetSoporte.Range(_worksheetSoporte.Cell(2, 5), _worksheetSoporte.Cell(_HORAS.Count + 2, 5)));
dataV.IgnoreBlanks = true;
dataV.InCellDropdown = true;
dataV.ShowInputMessage = true;
dataV.ShowErrorMessage = true;
dataV.ErrorStyle = ClosedXML.Excel.XLErrorStyle.Stop;
sheetUnidad.Cell(1, 3).Value = sub.ot;
sheetUnidad.Cell(2, 3).Value = sub.ot_cliente;
sheetUnidad.Cell(3, 3).Value = sub.horas_orden_compra.HasValue ? sub.horas_orden_compra : null;
int fila = 9;
List <SUBPROYECTO> subproyectos = ControladorSubproyecto.ObtenerSubproyectosHijos(sub);
List <Actividad_proyecto> actividades;
foreach (var subproyecto in subproyectos)
{
sheetUnidad.Cell(fila, 1).Value = subproyecto.id_subproyecto;
sheetUnidad.Cell(fila, 2).Value = subproyecto.nombre;
HORA_TIPO_SUBPROYECTO hora =
ControladorSubproyecto.ObtenerHoraTipoSubproyecto(subproyecto.id_hora_tipo_subproyecto);
if (hora != null)
{
sheetUnidad.Cell(fila, 3).Value = hora.nombre;
//sheetUnidad.Cell(fila, 4).Value = hora.horas;
}
else
{
sheetUnidad.Cell(fila, 3).Value = "";
sheetUnidad.Cell(fila, 4).Value = ControladorSubproyecto.CalcularHorasOrdenCompra(subproyecto);
}
sheetUnidad.Cell(fila, 5).Value = decimal.Round((decimal)ControladorSubproyecto.CalcularHorasOrdenCompra(subproyecto), 2);
actividades = ControladorSubproyecto.ObtenerActividades(subproyecto);
int columna = 0;
foreach (var acti in actividades)
{
switch (ControladorActividades.ObtenerActividad(acti).id_tipo_actividad)
{
//Concepto
case 2:
columna = 9;
break;
case 3:
columna = 22;
break;
case 4:
columna = 35;
break;
default:
columna = -1;
break;
}
if (columna > 0)
{
decimal horaConsumida = (decimal)(Math.Round(ControladorActividades.ObtenerHorasConsumidas(acti, "prod"), 2));
decimal horaAsignada = (decimal)ControladorActividades.ObtenerHorasAsignadasPorOrdenCompra(acti) * (decimal)0.85;
USUARIO responsablePro =
ControladorActividades.ObtenerResponsableProduccion(acti.id_actividad_proyecto);
sheetUnidad.Cell(fila, columna + 1).DataType = XLCellValues.Number;
sheetUnidad.Cell(fila, columna + 1).Value = horaConsumida;
sheetUnidad.Cell(fila, columna + 2).Value = decimal.Round(horaAsignada, 2);
sheetUnidad.Cell(fila, columna + 3).Value = horaAsignada > 0 ? decimal.Round(horaConsumida / horaAsignada * 100, 2) + "%" : "0%";
sheetUnidad.Cell(fila, columna + 4).Value = responsablePro != null ? responsablePro.nombre + " " +
responsablePro.apellido : "Sin asignar";
sheetUnidad.Cell(fila, columna + 4).WorksheetColumn().AdjustToContents();
columna += 4;
//Control
horaConsumida = (decimal)(Math.Round(ControladorActividades.ObtenerHorasConsumidas(acti, "calidad"), 2));
horaAsignada = (decimal)(ControladorActividades.ObtenerHorasAsignadasPorOrdenCompra(acti) * 0.10);
responsablePro =
ControladorActividades.ObtenerResponsableControln(acti.id_actividad_proyecto);
sheetUnidad.Cell(fila, columna + 1).DataType = XLCellValues.Number;
sheetUnidad.Cell(fila, columna + 1).Value = horaConsumida;
sheetUnidad.Cell(fila, columna + 2).Value = decimal.Round(horaAsignada, 2);
sheetUnidad.Cell(fila, columna + 3).Value = horaAsignada > 0 ? decimal.Round(horaConsumida / horaAsignada * 100, 2) + "%" : "0%";
sheetUnidad.Cell(fila, columna + 4).Value = responsablePro != null ? responsablePro.nombre + " " +
responsablePro.apellido : "Sin asignar";
sheetUnidad.Cell(fila, columna + 4).WorksheetColumn().AdjustToContents();
columna += 4;
//Correccion
horaConsumida = (decimal)(Math.Round(ControladorActividades.ObtenerHorasConsumidas(acti, "correc"), 2));
horaAsignada = (decimal)(ControladorActividades.ObtenerHorasAsignadasPorOrdenCompra(acti) * 0.05);
responsablePro =
ControladorActividades.ObtenerResponsableCorreccion(acti.id_actividad_proyecto);
sheetUnidad.Cell(fila, columna + 1).DataType = XLCellValues.Number;
sheetUnidad.Cell(fila, columna + 1).Value = horaConsumida;
sheetUnidad.Cell(fila, columna + 2).Value = decimal.Round(horaAsignada, 2);
sheetUnidad.Cell(fila, columna + 3).Value = horaAsignada > 0 ? decimal.Round(horaConsumida / horaAsignada * 100, 2) + "%" : "0%";
sheetUnidad.Cell(fila, columna + 4).Value = responsablePro != null ? responsablePro.nombre + " " +
responsablePro.apellido : "Sin asignar";
sheetUnidad.Cell(fila, columna + 4).WorksheetColumn().AdjustToContents();
}
}
fila++;
}
//Otras actividades
fila = 9;
List <Actividad_proyecto> listaActividades = ControladorSubproyecto.ObtenerActividades(sub);
foreach (Actividad_proyecto actividad in listaActividades)
{
sheetUnidad.Cell(fila, 7).Value = ControladorActividades.ObtenerActividad(actividad).nombre_actividad;
fila++;
}
}
public static bool TieneLogueoPermitido(Detalle_recurso dr)
{
Actividad_proyecto ap = ActividadProyectoDB.ObtenerActividadProyecto(dr.id_actividad_proyecto.Value);
SUBPROYECTO subproyecto = ControladorSubproyecto.BuscarPorId(ap.id_subproyecto.Value);
Proyecto p = ControladorProyecto.ObtenerPorID(ap.id_proyecto.Value);
Tipo_actividad ta = ControladorActividades.ObtenerTipoActividad(ap);
Movimiento_voz mv = ControladorActividades.ObtenerMovimientoVoz(ap);
bool decision = false;
int orden = (int)ap.orden;
if (dr.realizada.Value)
{
return(false);
}
if (dr.forzada && !dr.realizada.Value)
{
decision = true;
}
if (ap.no_conformidad)
{
return(false);
}
if (p.activo.HasValue && !p.activo.Value)
{
return(false);
}
if (orden == 1)
{
decision = true;
}
var anterior = ControladorActividades.ObtenerActividadAnterior(ap);
if (anterior == null)
{
return(true);
}
if (ControladorActividades.TieneControl_prod_1_Completado(anterior))
{
decision = true;
}
else
{
decision = false;
}
///////// TODO - CAMBIAR A POR ORDEN
//if (ta.descripcion.ToLower().Contains("conce"))
//{
// if(mv == null || !mv.control_prod.Value)
// {
// decision = true;
// }
//}
//else if (ta.descripcion.ToLower().Contains("prep"))
//{
// Tipo_actividad tipo_act_concepto = ControladorActividades.ObtenerTipoActividad("concepto");
// Actividad_proyecto concepto = ControladorSubproyecto.ObtenerActividaHijaDeTipo(subproyecto, tipo_act_concepto);
// if (ControladorActividades.TieneControl_prod_1_Completado(concepto) && !ControladorActividades.TieneControl_prod_1_Completado(ap))
// {
// decision = true;
// }
//}
//else if (ta.descripcion.ToLower().Contains("deta"))
//{
// Tipo_actividad tipo_act_concepto = ControladorActividades.ObtenerTipoActividad("concepto");
// Tipo_actividad tipo_act_preparacion = ControladorActividades.ObtenerTipoActividad("preparac");
// Actividad_proyecto concepto = ControladorSubproyecto.ObtenerActividaHijaDeTipo(subproyecto, tipo_act_concepto);
// Actividad_proyecto preparacion = ControladorSubproyecto.ObtenerActividaHijaDeTipo(subproyecto, tipo_act_preparacion);
// if (ControladorActividades.TieneControl_prod_1_Completado(concepto) && ControladorActividades.TieneControl_prod_1_Completado(preparacion) && !ControladorActividades.TieneControl_prod_1_Completado(ap))
// {
// decision = true;
// }
//}
//else
//{
// decision = true;
//}
////////////// END TODO
if (decision)
{
if (dr.id_estado.HasValue)
{
if (dr.id_estado <= 2)
{
return(true);
}
return(false);
}
else
{
return(decision);
}
}
return(false);
}
public static DateTime?CalcularFechaFin(Actividad_proyecto actividad, USUARIO usuario, DateTime fecha_inicio, double?horas)
{
Calendario_Laboral calendario = ObtenerCalendarioLaboraldeMiembro(usuario);
Calendario_Laboral padre = ObtenerCalendario(calendario.id_calendario_padre.Value);
List <Definicion_Calendario_Laboral> definiciones_padre = ObtenerDefiniciones(padre).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones = ObtenerExcepciones(padre);
List <Definicion_Calendario_Laboral> definiciones_hijo = ObtenerDefiniciones(calendario).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones_hijo = ObtenerExcepciones(calendario);
List <DateTime> fechasIncluidas = new List <DateTime>();
fechasIncluidas.AddRange(definiciones_padre.Select(x => x.fecha_hasta));
fechasIncluidas.AddRange(excepciones.Select(x => x.fecha_fin.Value).ToList());
fechasIncluidas.AddRange(definiciones_hijo.Select(x => x.fecha_hasta));
fechasIncluidas.AddRange(excepciones_hijo.Select(x => x.fecha_fin.Value).ToList());
fechasIncluidas.Sort((a, b) => b.CompareTo(a));
double horasActividad = horas.HasValue ? horas.Value : ControladorActividades.ObtenerHorasTotalesActividad(actividad);
double restante = horasActividad * 60;
TimeSpan hora = fecha_inicio.TimeOfDay;
DateTime fecha_fin;
if (fechasIncluidas.Count > 0)
{
for (DateTime i = fecha_inicio; i <= fechasIncluidas.First(); i = i.AddDays(1))
{
//Agregar si la expcecion no base no define un dia pero la base si,
//dentro de un período
var aux = ObtenerHorasLaboralesDia(calendario, i);
double tiempoDia = 0;
foreach (var item in aux)
{
if (fecha_inicio.Date == i.Date)
{
//Hay que tener en cuenta la hora, sino no
if (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks)
{
tiempoDia += (item.Item2.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
}
else if (hora.Ticks <= item.Item1.Ticks)
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
}
else
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
if (restante - tiempoDia == 0)
{
fecha_fin = i;
TimeSpan hora_fin = TimeSpan.FromTicks(item.Item2.Ticks);
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else if (restante - tiempoDia < 0)
{
TimeSpan hora_fin;
if (fecha_inicio.Date == i.Date && (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks))
{
hora_fin = TimeSpan.FromTicks((long)(hora.Ticks + (restante * TimeSpan.TicksPerMinute)));
}
else
{
hora_fin = TimeSpan.FromTicks((long)(item.Item1.Ticks + (restante * TimeSpan.TicksPerMinute)));
}
fecha_fin = i;
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else
{
restante = restante - tiempoDia;
tiempoDia = 0;
}
}
}
}
return(null);
}
public static DateTime ObtenerFechaInicioMinima(Actividad_proyecto actividad)
{
//Si la actividad es Concepto, le fecha minima de inicio es la fecha del proyecto
//Si la actividad es Preparacion, la fecha minima de inicio es la fecha del proyecto
//mas el tiempo de concepto, pero si el concepto ya esta asignado, que la fecha minima de inicio sea la fecha
//fin de concepto.. Lo mismo para preparacion.
String tipo_actividad = ControladorActividades.ObtenerTipoActividad(actividad).descripcion.ToLower();
SUBPROYECTO sub = ControladorSubproyecto.BuscarPorId(actividad.id_subproyecto.Value);
List <Detalle_recurso> tareas = new List <Detalle_recurso>();
DateTime fecha;
Actividad_proyecto act_anterior = ControladorActividades.ObtenerActividadAnterior(actividad);
if (act_anterior != null)
{
double tiempo_actividad;
//Suma los tiempos del
var act_anterior_aux = act_anterior;
tiempo_actividad = 0;
do
{
tiempo_actividad = ObtenerHorasTotalesActividad(act_anterior_aux);
act_anterior_aux = ControladorActividades.ObtenerActividadAnterior(act_anterior_aux);
} while (act_anterior_aux != null);
tareas = obtenerTareasDeActividad(act_anterior);
if (tareas.Count == 0)
{
//No esta asignada, se asigna a la fecha de proyecto + tiempo_actividad
fecha = ControladorCalendario.CalcularFechaFinDesdeProyecto(actividad, tiempo_actividad).Value;
}
else
{
//Está asignada, se asigna a la fecha fin de la asignacion de actividad anterior.
tareas = tareas.OrderByDescending(x => x.fecha_fin).ToList();
fecha = tareas.First().fecha_fin.Value;
}
}
else
{
fecha = ControladorProyecto.ObtenerPorID(actividad.id_proyecto.Value).fecha_inicio.Value;
}
//if (tipo_actividad.Contains("prep") || (tipo_actividad.Contains("deta")))
//{
// List<AvanceSubproyecto> avance;
// double tiempo_actividad;
// if (tipo_actividad.Contains("deta"))
// {
// tiempo_actividad = ObtenerHorasTotalesActividad(ObtenerActividadPorTipoActividad(sub,acti_concepto)) + ObtenerHorasTotalesActividad(ObtenerActividadPorTipoActividad(sub, acti_prepa));
// tareas = obtenerTareasDeActividad(ObtenerActividadPorTipoActividad(sub, acti_prepa));
// }
// else
// {
// tiempo_actividad = ObtenerHorasTotalesActividad(ObtenerActividadPorTipoActividad(sub, acti_concepto));
// tareas = obtenerTareasDeActividad(ObtenerActividadPorTipoActividad(sub, acti_concepto));
// }
// if (tareas.Count == 0)
// {
// //No esta asignada, se asigna a la fecha de proyecto + tiempo_actividad
// fecha = ControladorCalendario.CalcularFechaFinDesdeProyecto(actividad, tiempo_actividad).Value;
// }else
// {
// //Está asignada, se asigna a la fecha fin de la asignacion de actividad anterior.
// tareas = tareas.OrderByDescending(x => x.fecha_fin).ToList();
// fecha = tareas.First().fecha_fin.Value;
// }
//}
//else //Es concepto, o cualquier otro tipo de actividad, inicia cuando lo hace el proyecto.
//{
// fecha = ControladorProyecto.ObtenerPorID(actividad.id_proyecto.Value).fecha_inicio.Value;
//}
return(fecha < DateTime.Now ? DateTime.Now : fecha);
}
public static DateTime?ObtenerFechaFinMinima(Actividad_proyecto actividad, DateTime fecha_inicio)
{
Proyecto proyecto = ControladorProyecto.ObtenerPorID(actividad.id_proyecto.Value);
Calendario_Laboral padre = ObtenerCalendario(proyecto.id_calendario_laboral_base.Value);
List <Definicion_Calendario_Laboral> definiciones_padre = ObtenerDefiniciones(padre).OrderByDescending(x => x.fecha_hasta).ToList();
List <Excepcion_Calendario> excepciones = ObtenerExcepciones(padre);
List <DateTime> fechasIncluidas = ObtenerDefiniciones(padre).OrderByDescending(x => x.fecha_hasta).Select(x => x.fecha_hasta).ToList();
fechasIncluidas.AddRange(excepciones.Select(x => x.fecha_fin.Value).ToList());
fechasIncluidas.Sort((a, b) => b.CompareTo(a));
double horasActividad = ControladorActividades.ObtenerHorasTotalesActividad(actividad);
double restante = horasActividad * 60;
TimeSpan hora = fecha_inicio.TimeOfDay;
DateTime fecha_fin;
if (fechasIncluidas.Count > 0)
{
for (DateTime i = fecha_inicio; i <= fechasIncluidas.First(); i = i.AddDays(1))
{
var aux = ObtenerHorasLaboralesDia(padre, i);
double tiempoDia = 0;
foreach (var item in aux)
{
if (fecha_inicio.Date == i.Date)
{
//Hay que tener en cuenta la hora, sino no
if (hora.Ticks > item.Item1.Ticks && hora.Ticks < item.Item2.Ticks)
{
tiempoDia += (item.Item2.Ticks - hora.Ticks) / TimeSpan.TicksPerMinute;
}
else if (hora.Ticks <= item.Item1.Ticks)
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
}
else
{
tiempoDia += (item.Item2.Ticks - item.Item1.Ticks) / TimeSpan.TicksPerMinute;
}
//restante = restante - tiempoDia;
if (restante - tiempoDia == 0)
{
fecha_fin = i;
TimeSpan hora_fin = TimeSpan.FromTicks(item.Item2.Ticks);
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else if (restante - tiempoDia < 0)
{
var hora_fin = TimeSpan.FromTicks((long)(item.Item1.Ticks + (restante * TimeSpan.TicksPerMinute)));
fecha_fin = i;
DateTime nuevo = new DateTime(i.Year, i.Month, i.Day, hora_fin.Hours, hora_fin.Minutes, hora_fin.Seconds);
return(nuevo);
}
else
{
restante = restante - tiempoDia;
tiempoDia = 0;
}
}
}
}
return(null);
}
public void ExportarTodosProyectos()
{
List <Proyecto> proyectos = ControladorProyecto.ObtenerProyectosActivos();
if (OpenFile())
{
IXLWorksheet _worksheetProyecto = _xlworkbook.Worksheet("Tabla_Tareas");
List <ClaseExpGantt> estructura;
int fila = 2;
int filaAsig = 2;
CrearRecursos();
foreach (var item in proyectos)
{
estructura = _controladorProyecto.ObtenerEstructuraProyectoConActividades(item);
_worksheetProyecto.Cell(fila, 1).Value = fila - 1;
_worksheetProyecto.Cell(fila, 2).Value = "Sí";
_worksheetProyecto.Cell(fila, 3).Value = "Programada manualmente";
_worksheetProyecto.Cell(fila, 4).Value = item.nombre_proyecto;
_worksheetProyecto.Cell(fila, 5).Value = item.total_hora + " horas";
_worksheetProyecto.Cell(fila, 6).Value = ControladorTareas.CalcularFechaInicioProyecto(item);
_worksheetProyecto.Cell(fila, 7).Value = ControladorTareas.CalcularFechaFinProyecto(item);
_worksheetProyecto.Cell(fila, 9).Value = 1;
fila++;
foreach (ClaseExpGantt subproyecto in estructura)
{
filaAsig = CrearAsignacion(subproyecto, filaAsig, fila - 1);
if (subproyecto.subproyecto != null)
{
_worksheetProyecto.Cell(fila, 1).Value = fila - 1;
_worksheetProyecto.Cell(fila, 2).Value = "Sí";
_worksheetProyecto.Cell(fila, 3).Value = "Programada manualmente";
_worksheetProyecto.Cell(fila, 4).Value = subproyecto.subproyecto.nombre;
_worksheetProyecto.Cell(fila, 5).Value = subproyecto.subproyecto.horas_estimadas + " horas";// ControladorSubproyecto.ObtenerHorasOrdenCompra(subproyecto.subproyecto) + " horas";
_worksheetProyecto.Cell(fila, 6).Value = ControladorTareas.CalcularFechaInicioSubproyecto(subproyecto.subproyecto);
_worksheetProyecto.Cell(fila, 7).Value = ControladorTareas.CalcularFechaFinSubproyecto(subproyecto.subproyecto);
_worksheetProyecto.Cell(fila, 9).Value = subproyecto.nivel + 1;
}
else
{
_worksheetProyecto.Cell(fila, 1).Value = fila - 1;
_worksheetProyecto.Cell(fila, 2).Value = "Sí";
_worksheetProyecto.Cell(fila, 3).Value = "Programada automáticamente";
_worksheetProyecto.Cell(fila, 4).Value = subproyecto.actividad.nombre_actividad;
if (subproyecto.tarea != null)
{
if (subproyecto.actividad.id_tipo_actividad == ControladorActividades.ObtenerTipoActividad("prepa").id_tipo_actividad ||
subproyecto.actividad.id_tipo_actividad == ControladorActividades.ObtenerTipoActividad("deta").id_tipo_actividad)
{
//Predecesores
//_worksheetProyecto.Cell(fila, 8).Value = fila - 2;
}
_worksheetProyecto.Cell(fila, 4).Value = subproyecto.actividad.nombre_actividad + " - " + subproyecto.usuario.FullName;
_worksheetProyecto.Cell(fila, 5).Value = subproyecto.tarea.cantidad_hora + " horas";
_worksheetProyecto.Cell(fila, 6).Value = subproyecto.tarea.fecha_inicio;
_worksheetProyecto.Cell(fila, 7).Value = subproyecto.tarea.fecha_fin;
_worksheetProyecto.Cell(fila, 11).Value = subproyecto.actividadProy.id_actividad_proyecto;
}
_worksheetProyecto.Cell(fila, 9).Value = subproyecto.nivel + 1;
}
fila++;
}
}
if (CloseFile())
{
System.Diagnostics.Process.Start(path + "\\" + "Gantt" + ".xlsx");
}
}
}
private void AgregarUnidades(IXLWorksheet worksheet)
{
var sub = ControladorSubproyecto.BuscarPorOTDeExportacion(worksheet.Name, _proyAux.id_proyecto);
if (sub == null)
{
return;
}
decimal horasOC;
bool isNumericOC = decimal.TryParse(worksheet.Cell(3, 3).GetFormattedString(), out horasOC);
if (isNumericOC)
{
sub.horas_orden_compra = horasOC;
}
else
{
sub.horas_orden_compra = null;
}
ControladorSubproyecto.ActualizarSubproyecto(sub);
int i;
//Por si las dudas hayan escrito algo en la fila 9 (no deberian) porque anda mal la exportacion de Excel
int j = 9;
//Que columna?
for (i = j; !string.IsNullOrEmpty(worksheet.Cell(i, 2).Value.ToString()); i++)
{
int n;
bool isNumeric = int.TryParse(worksheet.Cell(i, 4).GetFormattedString(), out n);
HORA_TIPO_SUBPROYECTO hora_tipo = ControladorSubproyecto.ObtenerHoraTipoSubproyecto(worksheet.Cell(i, 3).Value.ToString());
decimal?dec = null;
var subAux = new SUBPROYECTO
{
nombre = worksheet.Cell(i, 2).Value.ToString(),
fecha_fin_estimada = DateTime.Today,
asignacion_automatica = true,
fecha_inicio_estimada = DateTime.Today,
fecha_inicio_real = DateTime.Today,
fecha_fin_real = DateTime.Today,
ot_cliente = "",
id_tipo_subproyecto = 4,
orden = 0,
id_hora_tipo_subproyecto = hora_tipo == null ? 0: hora_tipo.id_hora_tipo_subproyecto,
horas_estimadas = isNumeric ? n : hora_tipo == null ? 0 : hora_tipo.id_hora_tipo_subproyecto > 0 ? ControladorSubproyecto.ObtenerHoraTipoSubproyecto(worksheet.Cell(i, 3).Value.ToString()).horas : 0,
id_prioridad = 0,
observaciones = "",
ot = i - 9,
id_estado_proyecto = 0,
forzada_fecha_fin_estimada = false,
forzada_fecha_inicio_estimada = false,
genera_ot = false,
id_proyecto = _proyAux.id_proyecto
};
//mp existe
//TODO ACTUALIZAR
int id;
SUBPROYECTO subPro = null;
bool existeSubproyecto = false;
SUBPROYECTO sub2 = null;
if (int.TryParse(worksheet.Cell(i, 1).Value.ToString(), out id))
{
sub2 = ControladorSubproyecto.BuscarPorId(id);
}
if (sub2 == null)
{
ControladorSubproyecto.InsertarSubproyecto(subAux);
subAux.id_subproyecto_padre = sub.id_subproyecto;
ControladorSubproyecto.ActualizarSubproyecto(subAux);
//Check
CrearActividades(subAux);
subAux.horas_orden_compra = (decimal)ControladorSubproyecto.CalcularHorasOrdenCompra(subAux);
ControladorSubproyecto.ActualizarSubproyecto(subAux);
}
else
{
sub2.nombre = worksheet.Cell(i, 2).Value.ToString();
sub2.id_hora_tipo_subproyecto = subAux.id_hora_tipo_subproyecto;
sub2.horas_estimadas = ControladorSubproyecto.CalcularHorasOrdenCompra(subAux) != null?Convert.ToDecimal(ControladorSubproyecto.CalcularHorasOrdenCompra(subAux).Value.ToString("#.##")) : 0;
sub2.orden = subAux.orden;
//Eliminar subproyecto
if (sub2.nombre == null || sub2.nombre == "")
{
ControladorSubproyecto.EliminarSubproyecto(sub2);
}
else
{
ControladorSubproyecto.ActualizarSubproyecto(sub2);
decimal?valor = (decimal)ControladorSubproyecto.CalcularHorasOrdenCompra(sub2);
sub2.horas_orden_compra = ControladorSubproyecto.CalcularHorasOrdenCompra(sub2).HasValue ? decimal.Round((decimal)ControladorSubproyecto.CalcularHorasOrdenCompra(sub2).Value, 2, MidpointRounding.AwayFromZero) : 0;
ControladorSubproyecto.ActualizarSubproyecto(sub2);
}
}
}
List <Actividad> listaActividades = ControladorActividades.ObtenerActividadesDeSubproyecto(sub);
for (i = 9; !string.IsNullOrEmpty(worksheet.Cell(i, 7).Value.ToString()); i++)
{
string nombre = worksheet.Cell(i, 7).Value.ToString();
if (listaActividades.Count == 0 || !listaActividades.Where(x => x.nombre_actividad == nombre).Any())
{
CrearActividad(sub, ControladorActividades.ObtenerTipoActividad(nombre) == null ? 1 : ControladorActividades.ObtenerTipoActividad(nombre).id_tipo_actividad, nombre, listaActividades.Count == 0 ? 1 : listaActividades.Count + 1);
}
}
}
private void CrearActividades(SUBPROYECTO Subproyecto)
{
CrearActividad(Subproyecto, ControladorActividades.ObtenerTipoActividad("Concepto") == null ? 1 : ControladorActividades.ObtenerTipoActividad("Concepto").id_tipo_actividad, "Concepto", 1);
CrearActividad(Subproyecto, ControladorActividades.ObtenerTipoActividad("Preparación") == null ? 1 : ControladorActividades.ObtenerTipoActividad("Preparación").id_tipo_actividad, "Preparación", 2);
CrearActividad(Subproyecto, ControladorActividades.ObtenerTipoActividad("Detallado") == null ? 1 : ControladorActividades.ObtenerTipoActividad("Detallado").id_tipo_actividad, "Detallado", 3);
}