コード例 #1
0
    protected void ddlBDD_SelectedIndexChanged(object sender, EventArgs e)
    {
        //Definir el objeto de negocio de la aplicación
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

        Mensaje = "Asignando la Fuente de Documentos";
        sm.AsignarConfiguracion("BDDfuente", ddlBDD.SelectedItem.Text);
        Mensaje = "La Base de Datos Documental como fuete de datos se ha cambiado a: <b>" + ddlBDD.SelectedItem.Text + "</b>";
    }
コード例 #2
0
    protected void btnIndexarFeed_Click(object sender, EventArgs e)
    {
        if (!string.IsNullOrEmpty(txtFeedId.Text))
        {
            //Definir el objeto de negocio de la aplicación
            ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

            Mensaje = "Indexando Feed de Xively";
            Mensaje = sm.CargarFeedXivelyBDD(txtFeedId.Text);
        }
        else
        {
            Mensaje = "Para indexar un feed debe proveer un identificador de feed válido de Xively";
        }
    }
コード例 #3
0
    protected void Page_Unload(object sender, EventArgs e)
    {
        if (Session["Indexado"] != null)
        {
            if ((Boolean)Session["Indexado"] == true)
            {
                //Definir el objeto de negocio de la aplicación
                ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

                if (Session["OntologiaAnterior"] != null)
                {
                    //En cso de haber subido una ontologí pero haberla indexado se pasa a la configuracíón anterior
                    sm.AsignarConfiguracion("OntologiaAnterior", (string)Session["OntologiaAnterior"]);
                }
            }
        }
    }
コード例 #4
0
    protected void CargarOntologia()
    {
        //Definir el objeto de negocio de la aplicación
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

        //Seleccionar y convertir archivo en byte array
        if (fuOntologia.IsPosting)
        {
            try
            {
                string pathstr                = Server.MapPath("~/App_Data/Ontologias/");
                string nombrefile             = fuOntologia.PostedFile.FileName;
                string filenameontologialocal = pathstr + nombrefile;

                //Se almacena en la aplicación web. Si existe lo sobreescribe
                fuOntologia.SaveAs("~/App_Data/Ontologias", fuOntologia.PostedFile.FileName);

                //Se prepara para envarlo al servicio web
                StreamReader reader    = new StreamReader(filenameontologialocal);
                BinaryReader binReader = new BinaryReader(reader.BaseStream);

                //Crea una variable byte array del archivo para sus uso posterior
                byte[] binFile = binReader.ReadBytes(Convert.ToInt32(binReader.BaseStream.Length));

                //close reader
                binReader.Close();
                reader.Close();

                //Llamar al servicio Web para cargar el archivo
                Mensaje = "Cargando archivo de Ontología";
                Mensaje = sm.CargarOntologia(fuOntologia.PostedFile.FileName, binFile);

                //Reflejar el cambio en el drop de ontologias
                drpOntologías.Items.Add(sm.ObtenerConfiguracion("FileOntology"));
            }
            catch (Exception ex)
            {
                Mensaje = "ERROR: " + ex.Message.ToString();
            }
        }
        else
        {
            Mensaje = "Usted no ha especificado un archivo";
        }
    }
コード例 #5
0
    //Realiza la búsqueda al Índice Semántico y la presenta al usuario
    private void BuscarSemanticIndex()
    {
        //Definir el objeto de negocio de la aplicación
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

        //Verificar si el buscador esta disponible
        if (sm.ObtenerConfiguracion("BusquedaBloqueada") == "No")
        {
            //Calculamos el tiempo de demora en el proceso
            DateTime inicio = DateTime.Now;

            //Realizamos el proceso de expanción implícito
            string consultaexpandida = sm.ExpandirConsulta(TxtConsulta.Text, rdblistIdioma.SelectedItem.Text);

            //Obtener el resultado de la busqueda y presentarlo en la pagina
            List <FeedXively> FeedResultados = sm.BuscarFeeds(consultaexpandida, rdblistIdioma.SelectedItem.Text);

            Session["ConsultaExpandida"] = consultaexpandida;

            MostrarResumenResultadosFeed(FeedResultados);
            //MostrarResumenResultados(sm.Buscar(TxtConsulta.Text, rdblistIdioma.SelectedItem.Text));

            //Si el mapa esta visible, geoposicionar
            if (pnMapa.Visible)
            {
                GeoposicionarElementos();
            }

            //Tiempo final
            DateTime fin = DateTime.Now;

            //Mostramos el resultado
            TimeSpan intervalo = new TimeSpan(fin.Ticks - inicio.Ticks);
            LblResultados.Text += " - Tiempo Consulta: " + ((float)intervalo.TotalMilliseconds / 1000).ToString() + " segundos";
        }
        else
        {
            LblResultados.Text += "En este momento el buscador esta realizando indexación. Por favor intente más tarde.";
        }
    }
コード例 #6
0
    protected void btnRegistrar_Click(object sender, EventArgs e)
    {
        //Recuperar los valores generales a aregistrar
        string   consultaoriginal  = TxtConsulta.Text;
        string   consultaexpandida = Session["consultaexpandida"].ToString();
        DateTime fechaconsulta     = DateTime.Now;

        //Verificar que se haya iniciado sesion
        if (User.Identity.IsAuthenticated)
        {
            //Definir el objeto de negocio de la aplicación
            ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

            //Guardamos la consulta del usuario
            int consultaId = sm.SaveConsulta(consultaoriginal, consultaexpandida, fechaconsulta, User.Identity.Name);

            //Recorrer el grid para registrar cada resultado
            foreach (GridViewRow row in gridResultados.Rows)
            {
                CheckBox check  = row.FindControl("chkRelevancia") as CheckBox;
                string   feedid = row.Cells[1].Text;
                if (check.Checked)
                {
                    //La calificacion es 1 porque esta chequeado el feed
                    sm.SaveCalificacion(consultaId, feedid, 1);
                }
                else
                {
                    sm.SaveCalificacion(consultaId, feedid, 0);
                }
            }
            RegistrarScriptMensaje("Las calificaciones han sido registradas correctamente. !Muchas Gracias¡", true);
        }
        else
        {
            RegistrarScriptMensaje("Debe Iniciar sesion para poder registrar sus calificaciones", false);
        }
    }
コード例 #7
0
    //Permite presentar el Biotipo seleccionado en el mapa
    private void MostrarBiotipoenMapa()
    {
        string[] lugar = drplLugares.SelectedValue.Split(',');
        //Damos formato a la cadena para una mejor visualización
        latlng.Text = string.Format("Lat: {0}, Lng: {1}", lugar[0], lugar[1]);

        //Filtrar los resultados por los más cercanos al lugar escogido
        //Definir el objeto del negocio de la aplicación
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

        //Recupoeramos los resultados actuales de la consulta
        List <FeedXively> dtsResultados = (Session["ResultadosFeedGeneral"] as List <FeedXively>);

        //El método retorna los sensores que cumplen la condicion de cercanía
        List <FeedXively> dtsGeopos = sm.RetornarMapaLugarListaSensores(lugar[0].ToString(),
                                                                        lugar[1].ToString(),
                                                                        dtsResultados, rdblistIdioma.SelectedItem.Text, txtradio.Text);

        //Cargamos el datgrid con los sensores correspondientes
        MostrarResumenResultadosFeed(dtsGeopos);

        //Los marcadores son ubicados mediante javascript en el script del page load
    }
コード例 #8
0
    ///<summary>
    ///Esta función recibe un Biotipo (lugar). Consulta la ontología por las variables que miden el biotipo y posteriormente
    ///consulta el indice por cada variable con el fin de seleccionar los posibles sensores que pueden medir dicha información
    ///y asi poder desplegarla en un servicio de aplicación.
    ///</summary>
    ///<returns>
    ///Biotipo con la información medioambiental.
    /// </returns>
    /// <param name="nodoBiotipo">Es el biotipo que ha sido identificado y se desea su información</param>
    /// <param name="radio">Radio que define el área de acción del Biotipo</param>
    /// <param name="idioma">Idioma de preferencia del usuario. Por defecto busca Español</param>
    public Biotipo ObtenerInfoBiotipoMedioAmbiente(GeonameNode nodoBiotipo, string radio, string idioma)
    {
        //Objeto del negocio
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();
 
        //Biotipo generado para presentarlo al usuario
        Biotipo bio = new Biotipo();

        /****************** Obtenemos los Datos Generales del Biotipo **********************/
        bio.GeonameId = nodoBiotipo.geonameId;
        bio.name = nodoBiotipo.Nombre_lugar;
        bio.CountryName = nodoBiotipo.Nombre_pais;
        bio.CountryCode = nodoBiotipo.Codigo_pais;
        bio.AreaImpacto.lat = nodoBiotipo.Latitud;
        bio.AreaImpacto.lon = nodoBiotipo.Longitud.ToString();
        bio.AreaImpacto.Area = radio;

        /****************** Buscamos las variables de cada caracteristica desde la ontologia y Relacionan Sensores **********************/
        //Conceptos retornados de cada concepto
        List<string> conceptosE = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesE = new List<Variable>();

        //vaiables del Edafotopo
        string conceptoBuscar = "Edafotopo";
        conceptosE = sm.RetornarConceptos(conceptoBuscar,idioma);
        if(conceptosE != null)
            foreach(string concepto in conceptosE)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que la pueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesE.Add(variableMedir);
                }
            }
        bio.Edafotopo.Variables=variablesE;

        //vaiables del Hidrotopo
        //Conceptos retornados de cada concepto
        List<string> conceptosH = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesH = new List<Variable>();

        conceptoBuscar = "Hidrotopo";
        conceptosH = sm.RetornarConceptos(conceptoBuscar,idioma);
        if (conceptosH != null)
            foreach(string concepto in conceptosH)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que lapueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesH.Add(variableMedir);
                }
            }
        bio.Hidrotopo.Variables=variablesH;

        //vaiables del Climátopo
        //Conceptos retornados de cada concepto
        List<string> conceptosC = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesC = new List<Variable>();

        conceptoBuscar = "Climátopo";
        conceptosC = sm.RetornarConceptos(conceptoBuscar,idioma);
        if (conceptosC != null)
            foreach(string concepto in conceptosC)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que lapueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesC.Add(variableMedir);
                }
            }
        bio.Climatopo.Variables=variablesC;

        /****************** Los valores de referencia se los deja,mos al usuario **********************/
        return bio;
    }
コード例 #9
0
    public Biotipo ObtenerInfoBiotipoContaminacion(GeonameNode nodoBiotipo, string radio, string idioma)
    {
        //Objeto del negocio
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

        //Biotipo generado para presentarlo al usuario
        Biotipo bio = new Biotipo();

        /****************** Obtenemos los Datos Generales del Biotipo **********************/
        bio.GeonameId = nodoBiotipo.geonameId;
        bio.name = nodoBiotipo.Nombre_lugar;
        bio.CountryName = nodoBiotipo.Nombre_pais;
        bio.CountryCode = nodoBiotipo.Codigo_pais;
        bio.AreaImpacto.lat = nodoBiotipo.Latitud;
        bio.AreaImpacto.lon = nodoBiotipo.Longitud.ToString();
        bio.AreaImpacto.Area = radio;

        /****************** Buscamos las variables de cada caracteristica desde la ontologia y Relacionan Sensores **********************/
        //Conceptos retornados de cada concepto
        List<string> conceptosE = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesE = new List<Variable>();

        //vaiables del Aire
        string conceptoBuscar = "Contaminación del Aire";
        conceptosE = sm.RetornarConceptos(conceptoBuscar, idioma);
        if (conceptosE != null)
            foreach (string concepto in conceptosE)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que la pueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesE.Add(variableMedir);
                }
            }
        bio.ContaminacionAire.Variables = variablesE;

        //vaiables del Suelo
        //Conceptos retornados de cada concepto
        List<string> conceptosH = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesH = new List<Variable>();

        conceptoBuscar = "Contaminación del Suelo";
        conceptosH = sm.RetornarConceptos(conceptoBuscar, idioma);
        if (conceptosH != null)
            foreach (string concepto in conceptosH)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que lapueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesH.Add(variableMedir);
                }
            }
        bio.ContaminacionSuelo.Variables = variablesH;

        //vaiables del Agua
        //Conceptos retornados de cada concepto
        List<string> conceptosC = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesC = new List<Variable>();

        conceptoBuscar = "Contaminación del Agua";
        conceptosC = sm.RetornarConceptos(conceptoBuscar, idioma);
        if (conceptosC != null)
            foreach (string concepto in conceptosC)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que lapueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesC.Add(variableMedir);
                }
            }
        bio.ContaminacionAgua.Variables = variablesC;


        //Conceptos retornados de cada concepto
        List<string> conceptosS = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesS = new List<Variable>();

        //vaiables del Sonora
        conceptoBuscar = "Contaminación Sonora";
        conceptosS = sm.RetornarConceptos(conceptoBuscar, idioma);
        if (conceptosS != null)
            foreach (string concepto in conceptosS)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que la pueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesS.Add(variableMedir);
                }
            }
        bio.ContaminacionSonora.Variables = variablesS;

        //vaiables del Termica
        //Conceptos retornados de cada concepto
        List<string> conceptosT = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesT = new List<Variable>();

        conceptoBuscar = "Contaminación Térmica";
        conceptosT = sm.RetornarConceptos(conceptoBuscar, idioma);
        if (conceptosT != null)
            foreach (string concepto in conceptosT)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que lapueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesT.Add(variableMedir);
                }
            }
        bio.ContaminacionTermica.Variables = variablesT;

        //vaiables del Visual
        //Conceptos retornados de cada concepto
        List<string> conceptosV = new List<string>();
        //Variable relacionadas a buscar mediciones
        List<Variable> variablesV = new List<Variable>();

        conceptoBuscar = "Contaminación Visual";
        conceptosV = sm.RetornarConceptos(conceptoBuscar, idioma);
        if (conceptosV != null)
            foreach (string concepto in conceptosV)
            {
                if (concepto != conceptoBuscar)
                {
                    Variable variableMedir = new Variable();
                    variableMedir.Id = concepto;
                    //Buscar Sensores que lapueden medir
                    variableMedir.sensores = sm.RetornarMapaLugar(bio.AreaImpacto.lat, bio.AreaImpacto.lon, concepto, idioma, radio);
                    variablesV.Add(variableMedir);
                }
            }
        bio.ContaminacionVisual.Variables = variablesV;

        /****************** Los valores de referencia se los deja,mos al usuario **********************/
        return bio;
    }
コード例 #10
0
    //Busca los Biotipos que estan relacionados a los sensores retornados en la consulta
    private List <GeonameNode> BuscarBiotiposConsulta(List <FeedXively> dts, List <GeonameNode> geonodes)
    {
        //Definir el objeto del negocio
        ServiciosMedioAmbientales sm = new ServiciosMedioAmbientales();

        //Variables temporales
        Boolean            encontrado          = false;
        string             ciudadesadicionales = string.Empty;
        List <GeonameNode> geonodestmp         = new List <GeonameNode>();

        //Recorrer el dataset para la busqueda de nuevos lugares
        foreach (FeedXively dtr in dts)
        {
            GeonameNode gn = new GeonameNode();

            //En caso de no tener Coordenadas Descartarlo
            if (dtr.feed.location != null)
            {
                //Leemos la localización de registro correspondiente
                gn.Nombre_lugar         = ""; //Este lugar hay que averiguarlo con el Servicio Web enviando las coordenadas
                gn.Nombre_lugar_usuario = dtr.feed.location.name;
                gn.Latitud  = dtr.feed.location.lat;
                gn.Longitud = dtr.feed.location.lon;

                geonodestmp.Add(gn);
            }
        }

        //Obtenemos los Biotipos (lugares) encontrados
        List <GeonameNode> gns = sm.ObtenerBiotiposConsulta(geonodestmp);

        if (gns != null)
        {
            foreach (GeonameNode gn in gns)
            {
                geonodestmp.Add(gn);
            }

            //Añadimos los nuevos lugares a la lista actual
            foreach (GeonameNode geonode in geonodestmp)
            {
                //Verificamos si los nuevos lugares ya fueron detectados en la consulta
                foreach (GeonameNode geon in geonodes)
                {
                    if (geon.Nombre_lugar_Jerarquico == geonode.Nombre_lugar_Jerarquico)
                    {
                        encontrado = true;
                        break;
                    }
                }

                //Si no estaba el lugar adicionarlo, verificando nulos
                if (!encontrado && !string.IsNullOrEmpty(geonode.Nombre_lugar_Jerarquico))
                {
                    geonodes.Add(geonode);
                }
                encontrado = false;
            }

            return(geonodes);
        }
        return(null);
    }