Beispiel #1
0
        //---------------------------------------------------------------------------------------------------------------------

        private void InitializeData(int count)
        {
            DataSets           = new CatalogueDataSetInfo[count];
            DataSetIdentifiers = new string[count];
            DataSetResources   = new string[count];
            DataSetSizes       = new long[count];
            foreach (KeyValuePair <string, string> kvp in MetadataElementNames)
            {
                metadataValues[kvp.Key] = new TypedValue[count];
            }
        }
Beispiel #2
0
        //---------------------------------------------------------------------------------------------------------------------

        /// <summary>Adds data sets from the specified URL.</summary>
        /// <returns><c>true</c>, if the request was successful, <c>false</c> if there was an error.</returns>
        /// <param name="url">A URL at which RDF metadata content for the data sets can be obtained.</param>
        /// <param name="startIndex">The start index of the current partial request.</param>
        /// <param name="count">The number of data sets to be received with the current partial request.</param>
        protected bool AddResultsFromRdf(string url, int startIndex, int count)
        {
            /*url = Regex.Replace(url, @"([^\&\?]+)=\{startIndex\??\}", "$1=" + startIndex);
             * url = Regex.Replace(url, @"([^\&\?]+)=\{count\??\}", "$1=" + count);*/
            url = Regex.Replace(url, @"([\?&])startIndex=", (startIndex == -1 ? "" : "$1startIndex=" + startIndex));
            url = Regex.Replace(url, @"([\?&])count=", "$1count=" + count);
            context.AddDebug(3, "Catalogue query (page): " + url);

            try {
                XmlDocument doc = new XmlDocument();
                doc.Load(url);

                if (namespaceManager == null)
                {
                    namespaceManager = new XmlNamespaceManager(doc.NameTable);
                    foreach (XmlAttribute attr in doc.DocumentElement.Attributes)
                    {
                        if (attr.Prefix == "xmlns")
                        {
                            namespaceManager.AddNamespace(attr.LocalName, attr.Value);
                        }
                    }
                }

                // In the first request, retrieve meta information on results
                if (startIndex == 0)
                {
                    // Extract the number of results from the retreived XML document and add it to the local totalResults
                    XmlNode node = doc.SelectSingleNode("//rdf:Description/os:totalResults", namespaceManager);
                    int     tr   = 0;
                    if (node != null)
                    {
                        Int32.TryParse(node.InnerText, out tr);
                    }
                    TotalResults = tr;

                    // Extract the first start index (i.e. the index offset)
                    node       = doc.SelectSingleNode("//rdf:Description/os:startIndex", namespaceManager);
                    startIndex = 0;
                    if (node != null)
                    {
                        Int32.TryParse(node.InnerText, out startIndex);
                    }

                    // Extract the actual number of items per page, in case it does not correspond to the requested count value
                    node = doc.SelectSingleNode("//rdf:Description/os:itemsPerPage", namespaceManager);
                    //if (node != null) Int32.TryParse(node.InnerText, out dataSetsPerRequest);

                    // Set length of dataSets array and of metadata arrays

                    count = (TotalResults <= maxCount ? TotalResults : maxCount);
                    InitializeData(count);

                    ReceivedResults = 0;
                }

                if (count == 0 || TotalResults < minCount)
                {
                    return(true);                                       // continue only if results are requested
                }
                XmlNodeList nodes = doc.SelectNodes(DataSetXmlName, namespaceManager);
                for (int i = 0; i < nodes.Count; i++)
                {
                    DataSets[ReceivedResults] = new CatalogueDataSetInfo(this, ReceivedResults);
                    GetDataSetInformation(ReceivedResults, nodes[i] as XmlElement);
                    ReceivedResults++;
                }
                context.AddDebug(3, "Results: " + ReceivedResults);
            } catch (Exception e) {
                context.AddError("Catalogue query failed: " + e.Message + " " + url);
                return(false);
            }

            return(true);
        }
Beispiel #3
0
        //---------------------------------------------------------------------------------------------------------------------

        /// <summary>Queries the catalogue and receives the data sets to build the result.</summary>
        /// <param name="minCount">Minimum number of data sets to be included. If the minimum number is not reached, the result will be empty.</param>
        /// <param name="maxCount">Maxium number of data sets to be included.</param>
        public void GetDataSets(int minCount, int maxCount)
        {
            this.minCount = minCount;
            this.maxCount = maxCount;

            if (Url != null)
            {
                // Get the element names from the configuration file
                XmlDocument configDoc     = new XmlDocument();
                XmlElement  catalogueElem = null;
                bool        success       = false;
                try {
                    configDoc.Load(context.SiteConfigFolder + "/services.xml");
                    success = ((catalogueElem = configDoc.SelectSingleNode("/services/dataset/catalogue[@type='application/rdf+xml']") as XmlElement) != null);
                } catch (Exception) {
                }

                if (success)
                {
                    for (int i = 0; i < catalogueElem.ChildNodes.Count; i++)
                    {
                        XmlElement elem = catalogueElem.ChildNodes[i] as XmlElement;
                        if (elem == null || !elem.HasAttribute("name"))
                        {
                            continue;
                        }
                        switch (elem.Attributes["name"].Value)
                        {
                        case "dataset":
                            DataSetXmlName = elem.InnerXml;
                            break;

                        case "value":
                            ResourceXmlName = elem.InnerXml;
                            break;

                        case "_identifier":
                            IdentifierXmlName = elem.InnerXml;
                            break;

                        case "_size":
                            SizeXmlName = elem.InnerXml;
                            break;
                        }
                    }
                }
                else if (context.UserLevel == UserLevel.Administrator)
                {
                    context.AddWarning("Invalid catalogue metadata configuration");
                }

                // Get first result
                context.AddDebug(2, "Catalogue query (base): " + Url);
                if (!AddResultsFromRdf(Url, 0, (maxCount > ResultsPerRequest ? ResultsPerRequest : maxCount)))
                {
                    context.WriteInfo(String.Format("Return 1"));
                    return;
                }

                if (maxCount == 0 || TotalResults < minCount)
                {
                    InitializeData(0);
                    return;
                }

                // If necessary, do more requests
                if (maxCount > TotalResults)
                {
                    maxCount = TotalResults;
                }
                while (ReceivedResults < maxCount)
                {
                    if (!AddResultsFromRdf(Url, ReceivedResults, (maxCount > ReceivedResults + ResultsPerRequest ? ResultsPerRequest : maxCount - ReceivedResults)))
                    {
                        break;
                    }
                }
                context.AddDebug(2, "Catalogue results: " + ReceivedResults + " (total results: " + TotalResults + ")");
            }
            else if (DataSetParameter != null && context is IfyWebContext)
            {
                TotalResults    = DataSetParameter.Values.Length;
                ReceivedResults = TotalResults;

                InitializeData(ReceivedResults);

                string[] paramValues;
                paramValues = StringUtils.Split((context as IfyWebContext).GetParamValue(DataSetParameter.Name + ":_identifier"), DataSetParameter.Separator);
                if (paramValues.Length == ReceivedResults)
                {
                    for (int i = 0; i < ReceivedResults; i++)
                    {
                        DataSetIdentifiers[i] = paramValues[i];
                    }
                }
                paramValues = StringUtils.Split((context as IfyWebContext).GetParamValue(DataSetParameter.Name + ":_size"), DataSetParameter.Separator);
                if (paramValues.Length == ReceivedResults)
                {
                    for (int i = 0; i < ReceivedResults; i++)
                    {
                        Int64.TryParse(paramValues[i], out DataSetSizes[i]);
                    }
                }

                /*for (int i = 0; i < dataSetTotalCount; i++) DataSets[i] = new DataSetInfo(this, i, DataSetParameter.Values[i], sizes[i], startTimes[i], endTimes[i]); */

                for (int i = 0; i < ReceivedResults; i++)
                {
                    DataSets[i]         = new CatalogueDataSetInfo(this, i);
                    DataSetResources[i] = DataSetParameter.Values[i];
                }

                foreach (KeyValuePair <string, string> kvp in MetadataElementNames)
                {
                    metadataValues[kvp.Key] = new TypedValue[ReceivedResults];
                    paramValues             = StringUtils.Split((context as IfyWebContext).GetParamValue(DataSetParameter.Name + ":" + kvp.Key), DataSetParameter.Separator);
                    if (paramValues.Length == ReceivedResults)
                    {
                        for (int i = 0; i < ReceivedResults; i++)
                        {
                            SetMetadataValue(i, kvp.Key, paramValues[i]);
                        }
                    }
                }

                /*string paramValue = context.GetParamValue(paramName);
                 * datasetParam
                 * string[] paramValues = StringUtils.Split(paramValue, ';');
                 * DataSets = new DataSetInfo[];
                 * int[] fileSizes;
                 * DateTime[] startDates;
                 * DateTime[] endDates;*/
            }
        }