Exemplo n.º 1
0
        private Response Refresh(string graphName)
        {
            _semanticEngine   = _kernel.Get <ISemanticLayer>("dotNetRDF");
            _projectionEngine = _kernel.Get <IProjectionLayer>("rdf");

            LoadDataObjectSet(graphName, null);
            XDocument rdf = _projectionEngine.ToXml(graphName, ref _dataObjects);

            return(_semanticEngine.Refresh(graphName, rdf));
        }
Exemplo n.º 2
0
        public Response Pull(string scope, string app, string graph, Request request)
        {
            Response response = new Response();

            response.Level = StatusLevel.Success;

            Status status = new Status();

            status.Messages = new Messages();

            try
            {
                status.Identifier = String.Format("{0}.{1}", scope, app);

                InitializeScope(scope, app);

                if (_settings["ReadOnlyDataLayer"] != null && _settings["ReadOnlyDataLayer"].ToString().ToLower() == "true")
                {
                    string message = "Can not perform post on read-only data layer of [" + scope + "." + app + "].";
                    _logger.Error(message);

                    status.Level = StatusLevel.Error;
                    status.Messages.Add(message);
                }
                else
                {
                    InitializeDataLayer();

                    DateTime startTime = DateTime.Now;

                    #region move this portion to dotNetRdfEngine?
                    if (!request.ContainsKey("targetEndpointUri"))
                    {
                        throw new Exception("Target Endpoint Uri is required");
                    }

                    string targetEndpointUri = request["targetEndpointUri"];

                    if (!request.ContainsKey("targetGraphBaseUri"))
                    {
                        throw new Exception("Target graph uri is required");
                    }

                    string targetGraphBaseUri = request["targetGraphBaseUri"];
                    _settings["TargetGraphBaseUri"] = targetGraphBaseUri;

                    if (targetGraphBaseUri.ToLower() == "[default graph]")
                    {
                        targetGraphBaseUri = String.Empty;
                    }

                    SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(new Uri(targetEndpointUri), targetGraphBaseUri);

                    if (request.ContainsKey("targetCredentials"))
                    {
                        string         targetCredentialsXML = request["targetCredentials"];
                        WebCredentials targetCredentials    = Utility.Deserialize <WebCredentials>(targetCredentialsXML, true);

                        if (targetCredentials.isEncrypted)
                        {
                            targetCredentials.Decrypt();
                        }

                        endpoint.SetCredentials(targetCredentials.GetNetworkCredential().UserName, targetCredentials.GetNetworkCredential().Password, targetCredentials.GetNetworkCredential().Domain);
                    }

                    string proxyHost       = _settings["ProxyHost"];
                    string proxyPort       = _settings["ProxyPort"];
                    string proxyCredsToken = _settings["ProxyCredentialToken"];

                    if (!String.IsNullOrEmpty(proxyHost) && !String.IsNullOrEmpty(proxyPort) && !String.IsNullOrEmpty(proxyCredsToken))
                    {
                        WebProxyCredentials proxyCreds = _settings.GetWebProxyCredentials();
                        endpoint.Proxy            = proxyCreds.GetWebProxy() as WebProxy;
                        endpoint.ProxyCredentials = proxyCreds.GetNetworkCredential();
                    }

                    VDS.RDF.IGraph resultGraph = endpoint.QueryWithResultGraph("CONSTRUCT {?s ?p ?o} WHERE {?s ?p ?o}");
                    #endregion

                    if (resultGraph != null && resultGraph.Triples.Count > 0)
                    {
                        // call RdfProjectionEngine to fill data objects from a given graph
                        _projectionEngine = _kernel.Get <IProjectionLayer>("rdf");

                        System.Text.StringBuilder sb           = new System.Text.StringBuilder();
                        TextWriter textWriter                  = new StringWriter(sb);
                        VDS.RDF.Writing.RdfXmlWriter rdfWriter = new VDS.RDF.Writing.RdfXmlWriter();
                        rdfWriter.Save(resultGraph, textWriter);
                        XDocument xDocument = XDocument.Parse(sb.ToString());

                        if (xDocument != null && xDocument.Root != null)
                        {
                            _logger.Debug(xDocument.Root.ToString());
                            _dataObjects = _projectionEngine.ToDataObjects(graph, ref xDocument);

                            if (_dataObjects != null && _dataObjects.Count > 0)
                            {
                                status.Messages.Add("Query target endpoint completed successfully.");
                                status.Messages.Add(String.Format("Number of data objects created [{0}].", _dataObjects.Count));

                                // post data objects to data layer
                                response.Append(_dataLayer.Post(_dataObjects));

                                DateTime endTime  = DateTime.Now;
                                TimeSpan duration = endTime.Subtract(startTime);

                                status.Messages.Add(String.Format("Execution time [{0}:{1}.{2}] minutes.",
                                                                  duration.Minutes, duration.Seconds, duration.Milliseconds));
                            }
                            else
                            {
                                status.Messages.Add(string.Format("No data objects being created."));
                            }
                        }
                        else
                        {
                            throw new Exception("Facade document is empty.");
                        }
                    }
                    else
                    {
                        throw new Exception("Facade graph is empty.");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error("Error in Pull(): ", ex);

                status.Level = StatusLevel.Error;
                status.Messages.Add(string.Format("Error pulling graph: {0}", ex));
            }

            response.Append(status);
            return(response);
        }
Exemplo n.º 3
0
        public Response Pull(string projectName, string applicationName, string graphName, Request request)
        {
            Status status = new Status();

            status.Messages = new Messages();

            try
            {
                status.Identifier = String.Format("{0}.{1}", projectName, applicationName);

                InitializeScope(projectName, applicationName);
                InitializeDataLayer();

                DateTime startTime = DateTime.Now;

                if (!request.ContainsKey("targetEndpointUri"))
                {
                    throw new Exception("Target Endpoint Uri is required");
                }

                string targetEndpointUri = request["targetEndpointUri"];

                if (!request.ContainsKey("targetGraphBaseUri"))
                {
                    throw new Exception("Target graph uri is required");
                }

                string targetGraphBaseUri = request["targetGraphBaseUri"];
                _settings["TargetGraphBaseUri"] = targetGraphBaseUri;

                SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(new Uri(targetEndpointUri), targetGraphBaseUri);

                if (request.ContainsKey("targetCredentials"))
                {
                    string         targetCredentialsXML = request["targetCredentials"];
                    WebCredentials targetCredentials    = Utility.Deserialize <WebCredentials>(targetCredentialsXML, true);

                    if (targetCredentials.isEncrypted)
                    {
                        targetCredentials.Decrypt();
                    }

                    endpoint.SetCredentials(
                        targetCredentials.GetNetworkCredential().UserName,
                        targetCredentials.GetNetworkCredential().Password,
                        targetCredentials.GetNetworkCredential().Domain);
                }

                string proxyHost = _settings["ProxyHost"];
                string proxyPort = _settings["ProxyPort"];
                if (!String.IsNullOrEmpty(proxyHost) && !String.IsNullOrEmpty(proxyPort))
                {
                    WebProxy webProxy = new WebProxy(proxyHost, Int32.Parse(proxyPort));

                    WebProxyCredentials proxyCrendentials = _settings.GetWebProxyCredentials();
                    if (proxyCrendentials != null)
                    {
                        webProxy.Credentials = _settings.GetProxyCredential();
                    }

                    endpoint.SetProxyCredentials(proxyCrendentials.userName, proxyCrendentials.password, proxyCrendentials.domain);
                    endpoint.SetProxy(webProxy.Address);
                }

                String         query = "CONSTRUCT {?s ?p ?o} WHERE {?s ?p ?o}";
                VDS.RDF.IGraph graph = endpoint.QueryWithResultGraph(query);

                System.Text.StringBuilder sb           = new System.Text.StringBuilder();
                TextWriter textWriter                  = new StringWriter(sb);
                VDS.RDF.Writing.RdfXmlWriter rdfWriter = new VDS.RDF.Writing.RdfXmlWriter();
                rdfWriter.Save(graph, textWriter);
                XDocument xDocument = XDocument.Parse(sb.ToString());

                // call RdfProjectionEngine to fill data objects from a given graph
                _projectionEngine = _kernel.Get <IProjectionLayer>("rdf");
                _dataObjects      = _projectionEngine.ToDataObjects(graphName, ref xDocument);

                // post data objects to data layer
                _dataLayer.Post(_dataObjects);

                DateTime endTime  = DateTime.Now;
                TimeSpan duration = endTime.Subtract(startTime);

                status.Messages.Add(string.Format("Graph [{0}] has been posted to legacy system successfully.", graphName));

                status.Messages.Add(String.Format("Execution time [{0}:{1}.{2}] minutes.",
                                                  duration.Minutes, duration.Seconds, duration.Milliseconds));
            }
            catch (Exception ex)
            {
                _logger.Error("Error in Pull(): ", ex);

                status.Level = StatusLevel.Error;
                status.Messages.Add(string.Format("Error pulling graph: {0}", ex));
            }

            _response.Append(status);
            return(_response);
        }
Exemplo n.º 4
0
        //Gets from datalayer and send it to another endpoint
        public Response Push(string projectName, string applicationName, string graphName, PushRequest request)
        {
            Status status = new Status();

            status.Messages = new Messages();

            try
            {
                String targetUri            = String.Empty;
                String targetCredentialsXML = String.Empty;
                String filter                 = String.Empty;
                String projectNameForPush     = String.Empty;
                String applicationNameForPush = String.Empty;
                String graphNameForPush       = String.Empty;
                String format                 = String.Empty;
                targetUri            = request["targetUri"];
                targetCredentialsXML = request["targetCredentials"];
                filter                 = request["filter"];
                projectNameForPush     = request["targetProjectName"];
                applicationNameForPush = request["targetApplicationName"];
                graphNameForPush       = request["targetGraphName"];
                format                 = request["format"];

                WebHttpClient httpClient = new WebHttpClient(targetUri);

                InitializeScope(projectName, applicationName);
                InitializeDataLayer();

                _graphMap = _mapping.FindGraphMap(graphName);

                _projectionEngine = _kernel.Get <IProjectionLayer>(format);
                IList <IDataObject> dataObjectList;
                if (filter != String.Empty)
                {
                    IList <string> identifiers = new List <string>();
                    identifiers.Add(filter);
                    dataObjectList = _dataLayer.Get(_graphMap.dataObjectName, identifiers);
                }
                else
                {
                    dataObjectList = _dataLayer.Get(_graphMap.dataObjectName, null);
                }

                XDocument xDocument = _projectionEngine.ToXml(graphName, ref dataObjectList);

                _isDataLayerInitialized = false;
                _isScopeInitialized     = false;
                Response localResponse = httpClient.Post <XDocument, Response>(@"/" + projectNameForPush + "/" + applicationNameForPush + "/" + graphNameForPush + "?format=" + format, xDocument, true);

                _response.Append(localResponse);

                if (request.ExpectedResults != null)
                {
                    foreach (Status responseStatus in localResponse.StatusList)
                    {
                        string dataObjectName = request.ExpectedResults.DataObjectName;

                        IList <IDataObject> dataObjects = _dataLayer.Get(
                            dataObjectName, new List <string> {
                            responseStatus.Identifier
                        });

                        foreach (var resultMap in request.ExpectedResults)
                        {
                            string propertyValue    = responseStatus.Results[resultMap.Key];
                            string dataPropertyName = resultMap.Value;

                            dataObjects[0].SetPropertyValue(dataPropertyName, propertyValue);
                        }

                        _response.Append(_dataLayer.Post(dataObjects));
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error(string.Format("Error in pushing data", ex));

                status.Level = StatusLevel.Error;
                status.Messages.Add(string.Format("Error in pushing data: {0}", ex));
            }

            return(_response);
        }
Exemplo n.º 5
0
        public Response PullDTO(string projectName, string applicationName, string graphName, Request request)
        {
            String targetUri            = String.Empty;
            String targetCredentialsXML = String.Empty;
            String filter                 = String.Empty;
            String projectNameForPull     = String.Empty;
            String applicationNameForPull = String.Empty;
            String graphNameForPull       = String.Empty;
            String dataObjectsString      = String.Empty;
            Status status                 = new Status();

            status.Messages = new Messages();

            try
            {
                status.Identifier = String.Format("{0}.{1}", projectName, applicationName);

                InitializeScope(projectName, applicationName);
                InitializeDataLayer();

                _projectionEngine = _kernel.Get <IProjectionLayer>("dto");

                targetUri            = request["targetUri"];
                targetCredentialsXML = request["targetCredentials"];
                graphNameForPull     = request["targetGraphName"];
                filter                 = request["filter"];
                projectNameForPull     = request["projectName"];
                applicationNameForPull = request["applicationName"];

                WebCredentials targetCredentials = Utility.Deserialize <WebCredentials>(targetCredentialsXML, true);
                if (targetCredentials.isEncrypted)
                {
                    targetCredentials.Decrypt();
                }

                WebHttpClient httpClient = new WebHttpClient(targetUri);
                if (filter != String.Empty)
                {
                    dataObjectsString = httpClient.GetMessage(@"/" + projectNameForPull + "/" + applicationNameForPull + "/" + graphNameForPull + "/" + filter + "?format=dto");
                }
                else
                {
                    dataObjectsString = httpClient.GetMessage(@"/" + projectNameForPull + "/" + applicationNameForPull + "/" + graphNameForPull + "?format=dto");
                }
                XDocument xDocument = XDocument.Parse(dataObjectsString);

                IList <IDataObject> dataObjects = _projectionEngine.ToDataObjects(graphName, ref xDocument);

                _response.Append(_dataLayer.Post(dataObjects));
                status.Messages.Add(String.Format("Pull is successful from " + targetUri + "for Graph " + graphName));
            }
            catch (Exception ex)
            {
                _logger.Error("Error in PullDTO: " + ex);

                status.Level = StatusLevel.Error;
                status.Messages.Add("Error while pulling " + graphName + " data from " + targetUri + " as " + targetUri + " data with filter " + filter + ".\r\n");
                status.Messages.Add(ex.ToString());
            }

            _response.Append(status);
            return(_response);
        }