示例#1
0
        public static decimal calcularCosto(Proyecto proyecto)
        {
            decimal costo = decimal.Zero;

            try
            {
                List <Componente> componentes = ComponenteDAO.getComponentesPorProyecto(proyecto.id);
                List <Actividad>  actividades = ActividadDAO.GetActividadesPorObjeto(proyecto.id, 1);

                if ((componentes != null && componentes.Count > 0) || (actividades != null && actividades.Count > 0))
                {
                    foreach (Componente componente in componentes)
                    {
                        costo += componente.costo ?? default(decimal);
                    }

                    if (actividades != null && actividades.Count > 0)
                    {
                        foreach (Actividad actividad in actividades)
                        {
                            costo += actividad.costo ?? default(decimal);
                        }
                    }
                }
                else
                {
                    costo = proyecto.costo ?? default(decimal);
                }
            }
            catch (Exception e)
            {
                CLogger.write("16", "Proyecto.class", e);
            }

            return(costo);
        }
        public static void actualizarCostoPlanificadoObjeto(PlanAdquisicion pa)
        {
            decimal ret        = decimal.Zero;
            int     objetoId   = Convert.ToInt32(pa.objetoId);
            int     objetoTipo = Convert.ToInt32(pa.objetoTipo);
            List <PlanAdquisicionPago> pagos       = PlanAdquisicionPagoDAO.getPagosByPlan(Convert.ToInt32(pa.id));
            List <Actividad>           actividades = ActividadDAO.GetActividadesPorObjeto(objetoId, objetoTipo);

            foreach (Actividad actividad in actividades)
            {
                ret += actividad.costo ?? default(decimal);
            }

            switch (objetoTipo)
            {
            case 0:
                Proyecto          proyecto    = ProyectoDAO.getProyecto(objetoId);
                List <Componente> componentes = ComponenteDAO.getComponentesPorProyecto(proyecto.id);
                if (componentes == null || componentes.Count == 0)
                {
                    if (actividades == null || actividades.Count == 0)
                    {
                        if (pagos != null && pagos.Count > 0)
                        {
                            foreach (PlanAdquisicionPago pago in pagos)
                            {
                                ret += pago.pago ?? default(decimal);
                            }
                        }
                        else
                        {
                            ret = pa.total ?? default(decimal);
                        }
                    }
                }
                else
                {
                    foreach (Componente cmp in componentes)
                    {
                        ret += cmp.costo ?? default(decimal);
                    }
                }
                proyecto.costo = ret;
                ProyectoDAO.guardarProyecto(proyecto, false);
                break;

            case 1:
                Componente           componente     = ComponenteDAO.getComponente(objetoId);
                List <Producto>      productos      = ProductoDAO.getProductosByComponente(componente.id);
                List <Subcomponente> subcomponentes = SubComponenteDAO.getSubComponentesPorComponente(componente.id);
                if (productos == null || productos.Count == 0 || subcomponentes == null || subcomponentes.Count == 0)
                {
                    if (actividades == null || actividades.Count == 0)
                    {
                        if (pagos != null && pagos.Count > 0)
                        {
                            foreach (PlanAdquisicionPago pago in pagos)
                            {
                                ret += pago.pago ?? default(decimal);
                            }
                        }
                        else
                        {
                            ret = pa.total ?? default(decimal);
                        }
                    }
                }
                else
                {
                    if (productos != null)
                    {
                        foreach (Producto prod in productos)
                        {
                            ret += prod.costo ?? default(decimal);
                        }
                    }
                    if (subcomponentes != null)
                    {
                        foreach (Subcomponente subcomponente in subcomponentes)
                        {
                            ret += subcomponente.costo ?? default(decimal);
                        }
                    }
                }
                componente.costo = ret;
                ComponenteDAO.guardarComponente(componente, false);
                break;

            case 3:
                Producto           producto     = ProductoDAO.getProductoPorId(objetoId);
                List <Subproducto> subproductos = SubproductoDAO.getSubproductosByProductoid(producto.id);
                if (subproductos == null || subproductos.Count == 0)
                {
                    if (actividades == null || actividades.Count == 0)
                    {
                        if (pagos != null && pagos.Count > 0)
                        {
                            foreach (PlanAdquisicionPago pago in pagos)
                            {
                                ret += pago.pago ?? default(decimal);
                            }
                        }
                        else
                        {
                            ret = pa.total ?? default(decimal);
                        }
                    }
                }
                else
                {
                    foreach (Subproducto subprod in subproductos)
                    {
                        ret += subprod.costo ?? default(decimal);
                    }
                }
                producto.costo = ret;
                ProductoDAO.guardarProducto(producto, false);
                break;

            case 4:
                Subproducto subproducto = SubproductoDAO.getSubproductoPorId(objetoId);
                if (actividades != null && actividades.Count > 0)
                {
                    subproducto.costo = ret;
                    SubproductoDAO.guardarSubproducto(subproducto, false);
                }
                break;

            case 5:
                Actividad actividad = ActividadDAO.GetActividadPorId(objetoId);
                if (actividades != null && actividades.Count > 0)
                {
                    actividad.costo = ret;
                    ActividadDAO.guardarActividad(actividad, false);
                }
                break;
            }
        }
示例#3
0
        public static bool guardarComponentes(String codigoPresupuestario, int proyectoId, String usuario, DateTime fechaSuscripcion)
        {
            bool     ret      = true;
            Proyecto proyecto = ProyectoDAO.getProyecto(proyectoId);

            if (proyecto.projectCargado == null || !proyecto.projectCargado.Equals(1))
            {
                List <DtmAvanceFisfinanCmp> componentesSigade = DataSigadeDAO.getComponentes(codigoPresupuestario);
                List <Componente>           componentesSipro  = ComponenteDAO.getComponentesPorProyecto(proyectoId);

                if (componentesSigade != null && componentesSigade.Count > 0)
                {
                    for (int i = 0; i < componentesSigade.Count; i++)
                    {
                        if (i < componentesSipro.Count)
                        {
                            Componente componente = componentesSipro[i];
                            componente.nombre             = componentesSigade[i].nombreComponente;
                            componente.esDeSigade         = 1;
                            componente.usuarioActualizo   = usuario;;
                            componente.fechaActualizacion = DateTime.Now;;
                            ret = ret && ComponenteDAO.guardarComponente(componente, false);
                        }
                        else
                        {
                            ComponenteTipo componenteTipo = ComponenteTipoDAO.getComponenteTipoPorId(1);

                            int              year             = DateTime.Now.Year;
                            UnidadEjecutora  unidadEjecutora  = UnidadEjecutoraDAO.getUnidadEjecutora(year, 0, 0);
                            AcumulacionCosto acumulacionCosto = AcumulacionCostoDAO.getAcumulacionCostoById(3);

                            Componente componente = new Componente();
                            componente.acumulacionCostos  = acumulacionCosto;
                            componente.acumulacionCostoid = acumulacionCosto.id;
                            componente.componenteTipos    = componenteTipo;
                            componente.componenteTipoid   = componenteTipo.id;
                            componente.unidadEjecutoras   = unidadEjecutora;
                            componente.ueunidadEjecutora  = unidadEjecutora.unidadEjecutora;
                            componente.nombre             = componentesSigade[i].nombreComponente;
                            componente.usuarioCreo        = usuario;
                            componente.fechaCreacion      = DateTime.Now;
                            componente.estado             = 1;
                            componente.fechaInicio        = fechaSuscripcion;
                            componente.fechaFin           = fechaSuscripcion;
                            componente.duracion           = 1;
                            componente.duracionDimension  = "d";
                            componente.nivel          = 1;
                            componente.esDeSigade     = 1;
                            componente.inversionNueva = 0;

                            ret = ret && ComponenteDAO.guardarComponente(componente, true);
                        }
                    }

                    if (componentesSipro.Count > componentesSigade.Count)
                    {
                        for (int i = componentesSigade.Count; i < componentesSipro.Count; i++)
                        {
                            Componente componente = componentesSipro[i];
                            ret = ret && ObjetoDAO.borrarHijos(componente.treepath, 2, usuario);
                        }
                    }
                }
            }
            return(ret);
        }
示例#4
0
        public static DateTime calcularFechaMaxima(Proyecto proyecto)
        {
            DateTime fechaActual = default(DateTime);

            try
            {
                List <Actividad> actividades = ActividadDAO.GetActividadesPorObjeto(proyecto.id, 1);
                if (actividades != null && actividades.Count > 0)
                {
                    DateTime fechaMaxima = new DateTime();
                    foreach (Actividad actividad in actividades)
                    {
                        if (fechaActual == null)
                        {
                            fechaActual = actividad.fechaFin;
                        }
                        else
                        {
                            fechaMaxima = actividad.fechaFin;

                            if (fechaActual < fechaMaxima)
                            {
                                fechaActual = fechaMaxima;
                            }
                        }
                    }
                }

                List <Componente> componentes = ComponenteDAO.getComponentesPorProyecto(proyecto.id);
                if (componentes != null && componentes.Count > 0)
                {
                    DateTime fechaMaxima = new DateTime();
                    foreach (Componente componente in componentes)
                    {
                        if (fechaActual == null)
                        {
                            fechaActual = componente.fechaFin ?? default(DateTime);
                        }
                        else
                        {
                            fechaMaxima = componente.fechaFin ?? default(DateTime);

                            if (fechaActual < fechaMaxima)
                            {
                                fechaActual = fechaMaxima;
                            }
                        }
                    }
                }
                else if (fechaActual == null)
                {
                    fechaActual = proyecto.fechaFin ?? default(DateTime);
                }
            }
            catch (Exception e)
            {
                CLogger.write("18", "Proyecto.class", e);
            }

            return(fechaActual);
        }