Beispiel #1
0
        public static bool crearEditarComponente(Proyecto proyecto, String nombreComponente, String descripcion, decimal fPrestamo, decimal donacion,
                                                 decimal nacional, String usuario, long codigoPresupuestario, int orden)
        {
            ComponenteSigade componenteSigade = ComponenteSigadeDAO.getComponenteSigadePorCodigoNumero(codigoPresupuestario + "", orden);

            Componente componente = ComponenteDAO.getComponentePorProyectoYComponenteSigade(proyecto.id, componenteSigade != null ? componenteSigade.id : 0);

            if (componente == null)
            {
                ComponenteTipo   componenteTipo   = ComponenteTipoDAO.getComponenteTipoPorId(1);
                AcumulacionCosto acumulacionCosto = AcumulacionCostoDAO.getAcumulacionCostoById(3);

                componente = new Componente();
                componente.acumulacionCostos  = acumulacionCosto;
                componente.acumulacionCostoid = acumulacionCosto.id;
                componente.componenteSigades  = componenteSigade;
                componente.componenteSigadeid = componenteSigade.id;
                componente.componenteTipos    = componenteTipo;
                componente.componenteTipoid   = componenteTipo.id;
                componente.proyectos          = proyecto;
                componente.proyectoid         = proyecto.id;
                componente.unidadEjecutoras   = proyecto.unidadEjecutoras;
                componente.nombre             = nombreComponente;
                componente.descripcion        = descripcion;
                componente.usuarioCreo        = usuario;
                componente.fechaCreacion      = DateTime.Now;
                componente.estado             = 1;
                componente.fechaInicio        = proyecto.fechaInicio;
                componente.fechaFin           = proyecto.fechaFin;
                componente.duracion           = 1;
                componente.duracionDimension  = "d";
                componente.nivel             = 1;
                componente.esDeSigade        = 1;
                componente.fuentePrestamo    = fPrestamo;
                componente.fuenteDonacion    = donacion;
                componente.fuenteNacional    = nacional;
                componente.inversionNueva    = 0;
                componente.entidad           = proyecto.entidad;
                componente.ejercicio         = proyecto.ejercicio;
                componente.ueunidadEjecutora = componente.unidadEjecutoras.unidadEjecutora;
            }
            else
            {
                componente.fuentePrestamo     = fPrestamo;
                componente.fuenteDonacion     = donacion;
                componente.fuenteNacional     = nacional;
                componente.fechaActualizacion = DateTime.Now;
                componente.usuarioActualizo   = usuario;
            }
            return(ComponenteDAO.guardarComponente(componente, false));
        }
Beispiel #2
0
        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);
        }
Beispiel #3
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 bool guardarSubComponente(Subcomponente SubComponente, bool calcular_valores_agregados)
        {
            bool ret      = false;
            int  guardado = 0;

            try
            {
                using (DbConnection db = new OracleContext().getConnection())
                {
                    if (SubComponente.id < 1)
                    {
                        int sequenceId = db.ExecuteScalar <int>("SELECT seq_subcomponente.nextval FROM DUAL");
                        SubComponente.id = sequenceId;
                        guardado         = db.Execute("INSERT INTO SUBCOMPONENTE VALUES (:id, :nombre, :descripcion, :componenteid, :subcomponenteTipoid, :usuarioCreo, " +
                                                      ":usuarioActualizo, :fechaCreacion, :fechaActualizacion, :estado, :ueunidadEjecutora, :snip, :programa, :subprograma, :proyecto, :actividad, " +
                                                      ":obra, :latitud, :longitud, :costo, :acumulacionCostoid, :renglon, :ubicacionGeografica, :fechaInicio, :fechaFin, :duracion, :duracionDimension, " +
                                                      ":orden, :treePath, :nivel, :entidad, :ejercicio, :fechaInicioReal, :fechaFinReal, :inversionNueva)", SubComponente);

                        if (guardado > 0)
                        {
                            Componente componente = ComponenteDAO.getComponente(SubComponente.componenteid);
                            SubComponente.componentes = componente;
                            SubComponente.treepath    = SubComponente.componentes.treepath + "" + (10000000 + SubComponente.id);
                        }
                    }

                    guardado = db.Execute("UPDATE SUBCOMPONENTE SET nombre=:nombre, descripcion=:descripcion, componenteid=:componenteid, subcomponente_tipoid=:subcomponenteTipoid, " +
                                          "usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, fecha_actualizacion=:fechaActualizacion, estado=:estado, " +
                                          "ueunidad_ejecutora=:ueunidadEjecutora, snip=:snip, programa=:programa, subprograma=:subprograma, proyecto=:proyecto, actividad=:actividad, obra=:obra, " +
                                          "latitud=:latitud, longitud=:longitud, costo=:costo, acumulacion_costoid=:acumulacionCostoid, renglon=:renglon, ubicacion_geografica=:ubicacionGeografica, " +
                                          "fecha_inicio=:fechaInicio, fecha_fin=:fechaFin, duracion=:duracion, duracion_dimension=:duracionDimension, orden=:orden, treePath=:treePath, nivel=:nivel, " +
                                          "entidad=:entidad, ejercicio=:ejercicio, fecha_inicio_real=:fechaInicioReal, fecha_fin_real=:fechaFinReal, inversion_nueva=:inversionNueva WHERE id=:id", SubComponente);

                    if (guardado > 0)
                    {
                        SubcomponenteUsuario cu = new SubcomponenteUsuario();
                        cu.subcomponentes  = SubComponente;
                        cu.subcomponenteid = SubComponente.id;
                        cu.usuario         = SubComponente.usuarioCreo;
                        cu.usuarioCreo     = SubComponente.usuarioCreo;

                        int existe = db.ExecuteScalar <int>("SELECT COUNT(*) FROM SUBCOMPONENTE_USUARIO WHERE subcomponenteid=:id AND usuario=:usuario", new { id = cu.subcomponenteid, usuario = cu.usuario });

                        if (existe > 0)
                        {
                            guardado = db.Execute("UPDATE SUBCOMPONENTE_USUARIO SET usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, " +
                                                  "fecha_actualizacion=:fechaActualizacion WHERE subcomponenteid=:subcomponenteid AND usuario=:usuario", cu);
                        }
                        else
                        {
                            guardado = db.Execute("INSERT INTO SUBCOMPONENTE_USUARIO VALUES (:subcomponenteid, :usuario, :usuarioCreo, :usuarioActualizo, :fechaCreacion, " +
                                                  ":fechaActualizacion)", cu);
                        }

                        if (guardado > 0 && SubComponente.usuarioCreo.Equals("admin"))
                        {
                            SubcomponenteUsuario cu_admin = new SubcomponenteUsuario();
                            cu_admin.subcomponentes  = SubComponente;
                            cu_admin.subcomponenteid = SubComponente.id;
                            cu_admin.usuario         = "admin";
                            cu_admin.usuarioCreo     = SubComponente.usuarioCreo;

                            existe = db.ExecuteScalar <int>("SELECT COUNT(*) FROM SUBCOMPONENTE_USUARIO WHERE subcomponenteid=:id AND usuario=:usuario", new { id = cu_admin.subcomponenteid, usuario = cu.usuario });

                            if (existe > 0)
                            {
                                guardado = db.Execute("UPDATE SUBCOMPONENTE_USUARIO SET usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, " +
                                                      "fecha_actualizacion=:fechaActualizacion WHERE subcomponenteid=:subcomponenteid AND usuario=:usuario", cu_admin);
                            }
                            else
                            {
                                guardado = db.Execute("INSERT INTO SUBCOMPONENTE_USUARIO VALUES (:subcomponenteid, :usuario, :usuarioCreo, :usuarioActualizo, :fechaCreacion, :fechaActualizacion)", cu_admin);
                            }
                        }

                        if (guardado > 0 && calcular_valores_agregados)
                        {
                            ProyectoDAO.calcularCostoyFechas(Convert.ToInt32(SubComponente.treepath.Substring(0, 8)) - 10000000);
                        }

                        ret = guardado > 0 ? true : false;
                    }
                }
            }
            catch (Exception e)
            {
                CLogger.write("3", "SubComponenteDAO.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;
            }
        }
Beispiel #6
0
        public static bool guardarActividad(Actividad Actividad, bool calcular_valores_agregados)
        {
            bool ret      = false;
            int  guardado = 0;

            try
            {
                using (DbConnection db = new OracleContext().getConnection())
                {
                    if (Actividad.id < 1)
                    {
                        int sequenceId = db.ExecuteScalar <int>("SELECT seq_actividad.nextval FROM DUAL");
                        Actividad.id = sequenceId;
                        guardado     = db.Execute("INSERT INTO ACTIVIDAD VALUES (:id, :nombre, :descripcion, :fechaInicio, :fechaFin, :porcentajeAvance, :usuarioCreo, " +
                                                  ":usuarioActualizo, :fechaCreacion, :fechaActualizacion, :estado, :actividadTipoid, :snip, :programa, :subprograma, :proyecto, :actividad, " +
                                                  ":obra, :objetoId, :objetoTipo, :duracion, :duracionDimension, :predObjetoId, :predObjetoTipo, :latitud, :longitud, :costo, :acumulacionCosto, " +
                                                  ":renglon, :ubicacionGeografica, :orden, :treePath, :nivel, :proyectoBase, :componenteBase, :productoBase, :fechaInicioReal, :fechaFinReal, " +
                                                  ":inversionNueva)", Actividad);

                        if (guardado > 0)
                        {
                            switch (Actividad.objetoTipo)
                            {
                            case 0:
                                Proyecto proyecto = ProyectoDAO.getProyecto(Convert.ToInt32(Actividad.objetoId));
                                Actividad.treepath = proyecto.treepath + "" + (10000000 + Actividad.id);
                                break;

                            case 1:
                                Componente componente = ComponenteDAO.getComponente(Convert.ToInt32(Actividad.objetoId));
                                Actividad.treepath = componente.treepath + "" + (10000000 + Actividad.id);
                                break;

                            case 2:
                                Subcomponente subcomponente = SubComponenteDAO.getSubComponente(Convert.ToInt32(Actividad.objetoId));
                                Actividad.treepath = subcomponente.treepath + "" + (10000000 + Actividad.id);
                                break;

                            case 3:
                                Producto producto = ProductoDAO.getProductoPorId(Convert.ToInt32(Actividad.objetoId));
                                Actividad.treepath = producto.treepath + "" + (10000000 + Actividad.id);
                                break;

                            case 4:
                                Subproducto subproducto = SubproductoDAO.getSubproductoPorId(Convert.ToInt32(Actividad.objetoId));
                                Actividad.treepath = subproducto.treepath + "" + (10000000 + Actividad.id);
                                break;

                            case 5:
                                Actividad actividad = ActividadDAO.getActividadPorId(Convert.ToInt32(Actividad.objetoId));
                                Actividad.treepath = actividad.treepath + "" + (10000000 + Actividad.id);
                                break;
                            }
                        }
                    }

                    guardado = db.Execute("UPDATE actividad SET nombre=:nombre, descripcion=:descripcion, fecha_inicio=:fechaInicio, fecha_fin=:fechaFin, porcentaje_avance=:porcentajeAvance, " +
                                          "usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, fecha_actualizacion=:fechaActualizacion, " +
                                          "estado=:estado, actividad_tipoid=:actividadTipoid, snip=:snip, programa=:programa, subprograma=:subprograma, proyecto=:proyecto, actividad=:actividad, " +
                                          "obra=:obra, objeto_id=:objetoId, objeto_tipo=:objetoTipo, duracion=:duracion, duracion_dimension=:duracionDimension, pred_objeto_id=:predObjetoId, " +
                                          "pred_objeto_tipo=:predObjetoTipo, latitud=:latitud, longitud=:longitud, costo=:costo, acumulacion_costo=:acumulacionCosto, renglon=:renglon, " +
                                          "ubicacion_geografica=:ubicacionGeografica, orden=:orden, treePath=:treePath, nivel=:nivel, proyecto_base=:proyectoBase, componente_base=:componenteBase, " +
                                          "producto_base=:productoBase, fecha_inicio_real=:fechaInicioReal, fecha_fin_real=:fechaFinReal, inversion_nueva=:inversionNueva WHERE id=:id", Actividad);

                    if (guardado > 0)
                    {
                        ActividadUsuario au = new ActividadUsuario();
                        au.actividads    = Actividad;
                        au.actividadid   = Actividad.id;
                        au.usuario       = Actividad.usuarioCreo;
                        au.fechaCreacion = DateTime.Now;
                        au.usuarioCreo   = Actividad.usuarioCreo;

                        int existe = db.ExecuteScalar <int>("SELECT COUNT(*) FROM ACTIVIDAD_USUARIO WHERE actividadid=:id AND usuario=:usuario", new { id = au.actividadid, usuario = au.usuario });

                        if (existe > 0)
                        {
                            guardado = db.Execute("UPDATE ACTIVIDAD_USUARIO SET usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, " +
                                                  "fecha_actualizacion=:fechaActualizacion WHERE actividadid=:actividadid AND usuario=:usuario", au);
                        }
                        else
                        {
                            guardado = db.Execute("INSERT INTO actividad_usuario(:actividadid, :usuario, :usuarioCreo, :usuarioActualizo, :fechaCreacion, :fechaActualizacion)", au);
                        }

                        if (guardado > 0 && !Actividad.usuarioCreo.Equals("admin"))
                        {
                            ActividadUsuario au_admin = new ActividadUsuario();
                            au_admin.actividads    = Actividad;
                            au_admin.actividadid   = Actividad.id;
                            au_admin.usuario       = "admin";
                            au_admin.fechaCreacion = DateTime.Now;
                            au.usuarioCreo         = Actividad.usuarioCreo;

                            existe = db.ExecuteScalar <int>("SELECT COUNT(*) FROM ACTIVIDAD_USUARIO WHERE actividadid=:id AND usuario=:usuario", new { id = au_admin.actividadid, usuario = au_admin.usuario });

                            if (existe > 0)
                            {
                                guardado = db.Execute("UPDATE ACTIVIDAD_USUARIO SET usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, " +
                                                      "fecha_actualizacion=:fechaActualizacion WHERE actividadid=:actividadid AND usuario=:usuario", au_admin);
                            }
                            else
                            {
                                guardado = db.Execute("INSERT INTO actividad_usuario(:actividadid, :usuario, :usuarioCreo, :usuarioActualizo, :fechaCreacion, :fechaActualizacion)", au_admin);
                            }
                        }

                        if (calcular_valores_agregados)
                        {
                            ProyectoDAO.calcularCostoyFechas(Convert.ToInt32(Actividad.treepath.Substring(0, 8)) - 10000000);
                        }

                        ret = true;
                    }
                }
            }
            catch (Exception e)
            {
                CLogger.write("3", "ActividadDAO.class", e);
            }
            return(ret);
        }
Beispiel #7
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);
        }
Beispiel #8
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);
        }
        public static List <TipoAdquisicion> getTipoAdquisicionPorObjeto(int objetoId, int objetoTipo)
        {
            List <TipoAdquisicion> ret = new List <TipoAdquisicion>();
            int cooperanteCodigo       = 0;

            switch (objetoTipo)
            {
            case 1:
                Componente componente = ComponenteDAO.getComponente(objetoId);
                Proyecto   proyecto   = ProyectoDAO.getProyecto(componente.proyectoid);
                Prestamo   prestamo   = PrestamoDAO.getPrestamoById(proyecto.prestamoid ?? default(int));
                cooperanteCodigo = prestamo.cooperantecodigo ?? default(int);
                break;

            case 2:
                Subcomponente subcomponente = SubComponenteDAO.getSubComponente(objetoId);
                proyecto         = ProyectoDAO.getProyectobyTreePath(subcomponente.treepath);
                prestamo         = PrestamoDAO.getPrestamoById(proyecto.prestamoid ?? default(int));
                cooperanteCodigo = subcomponente.componentes.proyectos.prestamos.cooperantes.codigo;
                break;

            case 3:
                Producto producto = ProductoDAO.getProductoPorId(objetoId);
                if (producto.componentes != null)
                {
                    cooperanteCodigo = producto.componentes.proyectos.prestamos.cooperantes.codigo;
                }
                else if (producto.subcomponentes != null)
                {
                    cooperanteCodigo = producto.subcomponentes.componentes.proyectos.prestamos.cooperantes.codigo;
                }
                break;

            case 4:
                Subproducto subproducto = SubproductoDAO.getSubproductoPorId(objetoId);
                if (subproducto.productos.componentes != null)
                {
                    cooperanteCodigo = subproducto.productos.componentes.proyectos.prestamos.cooperantes.codigo;
                }
                else if (subproducto.productos.subcomponentes != null)
                {
                    cooperanteCodigo = subproducto.productos.subcomponentes.componentes.proyectos.prestamos.cooperantes.codigo;
                }
                break;

            case 5:
                Actividad actividad = ActividadDAO.GetActividadPorId(objetoId);
                if (actividad.treepath != null)
                {
                    int proyectoId = Convert.ToInt32(actividad.treepath.Substring(0, 8)) - 10000000;
                    if (proyectoId != 0)
                    {
                        cooperanteCodigo = ProyectoDAO.getProyecto(proyectoId).prestamos.cooperantes.codigo;
                    }
                }
                break;
            }

            try
            {
                using (DbConnection db = new OracleContext().getConnection())
                {
                    String str_query = "SELECT * FROM TIPO_ADQUISICION ta WHERE ta.cooperantecodigo=:codigo AND ta.estado=1";
                    ret = db.Query <TipoAdquisicion>(str_query, new { codigo = cooperanteCodigo }).AsList <TipoAdquisicion>();
                }
            }
            catch (Exception e)
            {
                CLogger.write("4", "TipoAdquisicionDAO.class", e);
            }

            return(ret);
        }
Beispiel #10
0
        public static bool guardarProducto(Producto producto, bool calcular_valores_agregados)
        {
            bool ret      = false;
            int  guardado = 0;

            try
            {
                using (DbConnection db = new OracleContext().getConnection())
                {
                    if (producto.id < 1)
                    {
                        int sequenceId = db.ExecuteScalar <int>("SELECT seq_producto.nextval FROM DUAL");
                        producto.id = sequenceId;
                        guardado    = db.Execute("INSERT INTO PRODUCTO VALUES (:id, :nombre, :descripcion, :componenteid, :subcomponenteid, :usuarioCreo, :usuarioActualizo, " +
                                                 ":fechaCreacion, :fechaActualizacion, :productoTipoid, :estado, :ueunidadEjecutora, :snip, :programa, :subprograma, :proyecto, :actividad, :obra, " +
                                                 ":latitud, :longitud, :peso, :costo, :acumulacionCostoid, :renglon, :ubicacionGeografica, :fechaInicio, :fechaFin, :duracion, :duracionDimension, :orden, " +
                                                 ":treePath, :nivel, :ejercicio, :entidad, :fechaInicioReal, :fechaFinReal, :inversionNueva)", producto);


                        if (guardado > 0 && producto.componenteid != null)
                        {
                            producto.componentes = ComponenteDAO.getComponente(producto.componenteid ?? default(int));
                            producto.treepath    = producto.componentes.treepath + "" + (10000000 + producto.id);
                        }
                        else if (producto.subcomponenteid != null)
                        {
                            producto.subcomponentes = SubComponenteDAO.getSubComponente(producto.subcomponenteid ?? default(int));
                            producto.treepath       = producto.subcomponentes.treepath + "" + (10000000 + producto.id);
                        }
                    }

                    guardado = db.Execute("UPDATE producto SET nombre=:nombre, descripcion=:descripcion, componenteid=:componenteid, subcomponenteid=:subcomponenteid, " +
                                          "usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, fecha_actualizacion=:fechaActualizacion, " +
                                          "producto_tipoid=:productoTipoid, estado=:estado, ueunidad_ejecutora=:ueunidadEjecutora, snip=:snip, programa=:programa, subprograma=:subprograma, " +
                                          "proyecto=:proyecto, actividad=:actividad, obra=:obra, latitud=:latitud, longitud=:longitud, peso=:peso, costo=:costo, acumulacion_costoid=:acumulacionCostoid, " +
                                          "renglon=:renglon, ubicacion_geografica=:ubicacionGeografica, fecha_inicio=:fechaInicio, fecha_fin=:fechaFin, duracion=:duracion, duracion_dimension=:duracionDimension, " +
                                          "orden=:orden, treePath=:treePath, nivel=:nivel, ejercicio=:ejercicio, entidad=:entidad, fecha_inicio_real=:fechaInicioReal, fecha_fin_real=:fechaFinReal, inversion_nueva=:inversionNueva WHERE id=:id", producto);

                    if (guardado > 0)
                    {
                        Usuario         usu = UsuarioDAO.getUsuario(producto.usuarioCreo);
                        ProductoUsuario pu  = new ProductoUsuario();
                        pu.productos     = producto;
                        pu.productoid    = producto.id;
                        pu.usuario       = usu.usuario;
                        pu.usuarioCreo   = usu.usuario;
                        pu.fechaCreacion = DateTime.Now;

                        int existe = db.ExecuteScalar <int>("SELECT COUNT(*) FROM PRODUCTO_USUARIO WHERE productoid=:id AND usuario=:usuario", new { id = pu.productoid, usuario = pu.usuario });

                        if (existe > 0)
                        {
                            guardado = db.Execute("UPDATE PRODUCTO_USUARIO SET usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, " +
                                                  "fecha_actualizacion=:fechaActualizacion WHERE productoid=:productoid AND usuario=:usuario", pu);

                            ret = guardado > 0 ? true : false;
                        }
                        else
                        {
                            guardado = db.Execute("INSERT INTO PRODUCTO_USUARIO VALUES (:productoid, :usuario, :usuarioCreo, :usuarioActualizo, :fechaCreacion, :fechaActualizacion)", pu);

                            ret = guardado > 0 ? true : false;
                        }

                        if (guardado > 0 && !producto.usuarioCreo.Equals("admin"))
                        {
                            ProductoUsuario pu_admin = new ProductoUsuario();
                            pu_admin.productos     = producto;
                            pu_admin.productoid    = producto.id;
                            pu_admin.usuario       = "admin";
                            pu_admin.usuarioCreo   = producto.usuarioCreo;
                            pu_admin.fechaCreacion = DateTime.Now;

                            existe = db.ExecuteScalar <int>("SELECT COUNT(*) FROM PRODUCTO_USUARIO WHERE productoid=:id AND usuario=:usuario", new { id = pu_admin.productoid, usuario = pu_admin.usuario });

                            if (existe > 0)
                            {
                                guardado = db.Execute("UPDATE PRODUCTO_USUARIO SET usuario_creo=:usuarioCreo, usuario_actualizo=:usuarioActualizo, fecha_creacion=:fechaCreacion, " +
                                                      "fecha_actualizacion=:fechaActualizacion WHERE productoid=:productoid AND usuario=:usuario", pu_admin);
                            }
                            else
                            {
                                guardado = db.Execute("INSERT INTO PRODUCTO_USUARIO VALUES (:productoid, :usuario, :usuarioCreo, :usuarioActualizo, :fechaCreacion, :fechaActualizacion)", pu_admin);
                            }
                        }

                        if (calcular_valores_agregados)
                        {
                            ret = ProyectoDAO.calcularCostoyFechas(Convert.ToInt32(producto.treepath.Substring(0, 8)) - 10000000);
                        }
                    }
                    else
                    {
                        ret = false;
                    }
                }
            }
            catch (Exception e)
            {
                CLogger.write("3", "ProductoDAO.class", e);
            }
            return(ret);
        }