private static bool guardarProyectoBatch(List <List <Nodo> > listas)
        {
            bool ret = true;

            try
            {
                using (DbConnection db = new OracleContext().getConnection())
                {
                    for (int i = 0; i < listas.Count - 1; i++)
                    {
                        for (int j = 0; j < listas[i].Count; j++)
                        {
                            switch (listas[i][j].objeto_tipo)
                            {
                            case 0:
                                guardarProyecto((Proyecto)listas[i][j].objeto, false);
                                break;

                            case 1:
                                ComponenteDAO.guardarComponente((Componente)listas[i][j].objeto, false);
                                break;

                            case 2:
                                SubComponenteDAO.guardarSubComponente((Subcomponente)listas[i][j].objeto, false);
                                break;

                            case 3:
                                ProductoDAO.guardarProducto((Producto)listas[i][j].objeto, false);
                                break;

                            case 4:
                                SubproductoDAO.guardarSubproducto((Subproducto)listas[i][j].objeto, false);
                                break;

                            case 5:
                                ActividadDAO.guardarActividad((Actividad)listas[i][j].objeto, false);
                                break;
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                ret = false;
                CLogger.write("20", "ProyectoDAO.class", e);
            }
            return(ret);
        }
        public static bool actualizarNivelesPagos(String pagosString, PlanAdquisicion pa, string usuario, int objetoId, int objetoTipo)
        {
            bool ret = false;

            try
            {
                decimal bpagos      = decimal.Zero;
                bool    tiene_pagos = false;
                if (pagosString != null)
                {
                    JArray pagos = JArray.Parse(pagosString);
                    for (int j = 0; j < pagos.Count; j++)
                    {
                        JObject             objeto_pago = new JObject(new JProperty("fecha", pagos[j]), new JProperty("pago", pagos[j]));
                        DateTime            fechaPago   = (DateTime)objeto_pago["fecha"];
                        decimal             dpago       = (decimal)objeto_pago["pago"];
                        PlanAdquisicionPago pago        = new PlanAdquisicionPago();
                        pago.planAdquisicions  = pa;
                        pago.planAdquisicionid = pa.id;
                        pago.fechaPago         = fechaPago;
                        pago.pago          = dpago;
                        pago.usuarioCreo   = usuario;
                        pago.fechaCreacion = DateTime.Now;
                        pago.estado        = 1;

                        PlanAdquisicionPagoDAO.guardarPago(pago);
                        bpagos     += dpago;
                        tiene_pagos = true;
                    }
                }

                List <Actividad> actividades = ActividadDAO.GetActividadesPorObjeto(objetoId, objetoTipo);
                switch (objetoTipo)
                {
                case 3:
                    Producto           producto     = ProductoDAO.getProductoPorId(objetoId);
                    List <Subproducto> subproductos = SubproductoDAO.getSubproductosByProductoid(producto.id);
                    if (!(subproductos != null && subproductos.Count > 0) &&
                        !(actividades != null && actividades.Count > 0))
                    {
                        if (tiene_pagos)
                        {
                            producto.costo = bpagos;
                        }
                        else
                        {
                            producto.costo = pa.total;
                        }
                        ProductoDAO.guardarProducto(producto, true);
                    }
                    break;

                case 4:
                    Subproducto subproducto = SubproductoDAO.getSubproductoPorId(objetoId);
                    if (!(actividades != null && actividades.Count > 0))
                    {
                        if (tiene_pagos)
                        {
                            subproducto.costo = bpagos;
                        }
                        else
                        {
                            subproducto.costo = pa.total;
                        }
                        SubproductoDAO.guardarSubproducto(subproducto, true);
                    }
                    break;

                case 5:
                    Actividad actividad = ActividadDAO.GetActividadPorId(objetoId);
                    if (!(actividades != null && actividades.Count > 0))
                    {
                        if (tiene_pagos)
                        {
                            actividad.costo = bpagos;
                        }
                        else
                        {
                            actividad.costo = pa.total;
                        }
                        ActividadDAO.guardarActividad(actividad, true);
                    }
                    break;
                }

                ret = true;
            }
            catch (Exception e)
            {
                CLogger.write("50", "PlanAdquisicionDAO.class", e);
            }

            return(ret);
        }
        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;
            }
        }