public Channel(String pTitle, String pDescription, ParsedUri pLink, List <Item> pItems) { title = pTitle; description = pDescription; link = pLink; items = pItems; }
private async void BtnGetMetadata_Click(object sender, RoutedEventArgs e) { // string serializedMetadata = UrlBox.Text; // Object o = RepositoryMetadataTranslationScope.Get().Deserialize(serializedMetadata, StringFormat.Xml); // StringBuilder sb = new StringBuilder(); // SimplTypesScope.Serialize(o, sb, StringFormat.Xml); // String reserializedMetadatata = sb.ToString(); // Console.WriteLine(reserializedMetadatata); //Expander expander = new Expander(); //TextBox metadataXML = new TextBox { TextWrapping = TextWrapping.Wrap, MinHeight = 100 }; //metadataXML.Text = reserializedMetadatata; string urls = UrlBox.Text; List <Task <Document> > extractionRequests = new List <Task <Document> >(); Dictionary <ParsedUri, DateTime> timeStamps = new Dictionary <ParsedUri, DateTime>(); foreach (var s in urls.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)) { Console.WriteLine("Requesting async extraction of: " + s); ParsedUri puri = new ParsedUri(s); { Task <Document> t = _semanticsSessionScope.GetDocument(puri); timeStamps.Add(puri, DateTime.Now); //Alternate, if you want the document here: //Document doc = await _semanticsSessionScope.GetDocument(puri); extractionRequests.Add(t); } } while (extractionRequests.Count > 0) { Task <Document> completedTask = await Task.WhenAny(extractionRequests); extractionRequests.Remove(completedTask); Document parsedDoc = await completedTask; if (parsedDoc == null) { continue; } Expander expander = new Expander { Header = parsedDoc.Title }; TextBox metadataXML = new TextBox { TextWrapping = TextWrapping.Wrap, MinHeight = 100 }; var s = timeStamps[parsedDoc.Location.Value]; Console.WriteLine(" ---------------------------------- Time to complete: " + DateTime.Now.Subtract(s).TotalMilliseconds); metadataXML.Text = await Task.Run(() => SimplTypesScope.Serialize(parsedDoc, StringFormat.Xml)); expander.Content = metadataXML; MetadataTitleXMLContainer.Children.Add(expander); } }
public ParsedUri Perform(ParsedUri input) { ParsedUri result = null; if (input != null && match != null) { String str = input.ToString(); Match matcher = match.Match(str); if (matcher.Success) { if (replace == null) { replace = ""; } Debug.WriteLine(matcher.Groups[0].Value + " " + matcher.Groups[1].Value); String rez = input.ToString().Replace(matcher.Groups[0].Value, replace); for (int i = 1; i < matcher.Groups.Count; i++) { rez = rez.Replace("$" + i, matcher.Groups[i].Value); } result = new ParsedUri(rez); } } return(result); }
public override Input CreateConnector(ParsedUri uri) { string databasePath = uri.LocalPath; Logger.Info("Trying Skype database: {0} ...", databasePath); return(new SkypeInput(databasePath)); }
public bool ProcessRedirect(Uri redirectedUri) { MetadataParsedURL originalMetadataPURL = originalDocument.Location; ParsedUri originalPURL = originalMetadataPURL == null ? null : originalMetadataPURL.Value; ParsedUri redirectedPURL = new ParsedUri(redirectedUri.AbsoluteUri); Debug.WriteLine("try redirecting: " + originalPURL + " > " + redirectedPURL); /*Document redirectedDocument = semanticsSessionScope.GetOrConstructDocument(redirectedPURL); * // note FIXME currently, GetOrConstructDocument does not return null! * if (redirectedDocument != null) * { * // existing document: the redirected url has been visited already. * * if (originalPURL != redirectedPURL) * redirectedDocument.AddAdditionalLocation(originalMetadataPURL); * * // TODO -- copy metadata from originalDocument?!! * * documentClosure.ChangeDocument(redirectedDocument); * * // TODO -- reconnect * * return true; * } * else * { * // TODO -- redirect to a new location. * }*/ // TODO -- what if redirectedDocument is already in the queue or being downloaded? return(false); }
private static void ParseArguments( IDictionary <string, ValueObject> arguments, out Filter filter, out Grouper grouper, out FileSystem fileSystem, out Input input, out Output output) { filter = new FilterHelper(arguments).Create(); grouper = GrouperHelper.Create(arguments["--grouper"].AsList); string fileSystemName = arguments["--file-system"].ToString(); ParsedUri inputUri = ParsedUriHelper.Parse(arguments["--input"]); ParsedUri outputUri = ParsedUriHelper.Parse(arguments["--output"]); try { fileSystem = Everything.FileSystems.GetValue(fileSystemName).Create(outputUri); input = Everything.Inputs.GetValue(inputUri.Scheme).CreateConnector(inputUri); output = Everything.Outputs.GetValue(outputUri.Scheme).CreateConnector(outputUri, fileSystem); } catch (KeyNotFoundException e) { throw new InvalidArgumentInternalException(String.Format( "Unknown scheme or name. {0}", e.Message)); } }
/// <summary> /// /// Encapsulate the oodss client requst in a simpler GetMetadata call. /// </summary> /// <param name="url"></param> /// <returns></returns> public async Task <Document> RequestMetadata(ParsedUri uri) { Document result = null; if (_metadataClient != null) { Debug.WriteLine("Performing asynchronous call"); ResponseMessage metadataResponse = _metadataClient.RequestAsync(new MetadataRequest(uri.ToString())).Result; Debug.WriteLine("Received asynchronous request "); if (metadataResponse != null && metadataResponse is MetadataResponse) { result = (metadataResponse as MetadataResponse).Metadata; } else if (metadataResponse != null && metadataResponse is SemanticServiceError) { (metadataResponse as SemanticServiceError).Perform(); } else { throw new Exception(); } } else { var requestUri = new ParsedUri(_serviceBaseUri, "?url=" + uri.AbsoluteUri); result = await _metadataTypeScope.DeserializeUri(requestUri, Format.Xml) as Document; } return(result); }
public override async Task <Document> GetDocument(ParsedUri puri) { if (puri == null) { Debug.WriteLine("Error: empty URL provided."); return(null); } var doc = await base.GetDocument(puri); if (doc == null) { try { var response = await HttpClient.GetAsync(new Uri(MetadataServiceUri, "metadata.json?url=" + puri.AbsoluteUri)); if (response.IsSuccessStatusCode) { doc = this.MetadataTranslationScope.Deserialize(await response.Content.ReadAsStreamAsync(), Format.Json) as Document; } } catch (Exception e) { Debug.WriteLine("failed to get document: {0}", e.Message); doc = null; } } return(doc); }
public void Test() { char separator = '/'; PrefixCollection <Object> pc = new PrefixCollection <Object>(separator); StringBuilder buffy = new StringBuilder(32); for (int i = 0; i < TEST_ADD.Length; i++) { // println(TEST[i].directoryString()); PrefixPhrase <Object> pp = pc.Add(TEST_ADD[i]); buffy.Clear(); pp.ToStringBuilder(buffy, separator); Console.WriteLine(buffy); } Console.WriteLine("\n"); for (int i = 0; i < TEST_MATCH.Length; i++) { ParsedUri purl = TEST_MATCH[i]; Console.WriteLine(purl.ToString() + "\t" + pc.Match(purl)); } Console.WriteLine("\n"); foreach (String phrase in pc.Values()) { Console.WriteLine(phrase); } }
public void AddDocument(D doc, ParsedUri location) { if (doc == null || location == null) { throw new InvalidOperationException("Cannot add to SemanticsGlobalCollection"); } Collection.Put(location, doc); }
public bool Match(ParsedUri purl) { String host = purl.Host; // domainPrefix is a child of this, the root (with no parent) PrefixPhrase <O> hostPrefix = LookupChild(host); // children of hostPrefix return((hostPrefix == null) ? false : hostPrefix.Match(purl.LocalPath, separator)); //edit }
public Item(String pTitle, String pDescription, ParsedUri pLink, String pGuid, String pAuthor, List <String> pCategorySet) { title = pTitle; description = pDescription; link = pLink; guid = pGuid; author = pAuthor; categorySet = pCategorySet; }
public SemanticsSessionScope(SimplTypesScope metadataTranslationScope, string repoLocation, ParsedUri serviceUri, EventHandler <EventArgs> onCompleted) : base(metadataTranslationScope, repoLocation, onCompleted) { SemanticsSessionScope.Get = this; MetadataServiceUri = serviceUri; HttpClient = new HttpClient(); }
public override async Task <Document> GetOrConstructDocument(ParsedUri location) { Document doc = await base.GetOrConstructDocument(location); if (doc != null) { doc.SemanticsSessionScope = this; } return(doc); }
public PrefixPhrase <O> getMatchingPrefix(ParsedUri purl) { String host = purl.Host; // domainPrefix is a child of this, the root (with no parent) PrefixPhrase <O> hostPrefix = LookupChild(host); // children of hostPrefix String path = purl.AbsolutePath; return((hostPrefix == null) ? null : hostPrefix.GetMatchingPrefix(path, 1, separator)); // skip over starting '/' }
private static void GetPhotos(object State) { object[] P = (object[])State; int i = (int)P [0]; IUPnPService Service = (IUPnPService)P [1]; string ContentType = (string)P [2]; string Extension = (string)P [3]; MailMessage Msg = (MailMessage)P [4]; ManualResetEvent Done = (ManualResetEvent)P [5]; DateTime Next = DateTime.Now; try { UPnPAction GetDefaultImageURL = Service ["GetDefaultImageURL"]; Variables v = new Variables(); GetDefaultImageURL.Execute(v); string ImageURL = (string)v ["RetImageURL"]; ParsedUri ImageURI = Web.ParseUri(ImageURL); HttpResponse Response; int ms; int j; using (HttpSocketClient Client = new HttpSocketClient(ImageURI.Host, ImageURI.Port, ImageURI.UriScheme is HttpsUriScheme, ImageURI.Credentials)) { Client.ReceiveTimeout = 20000; for (j = 1; j <= 3; j++) { ms = (int)System.Math.Round((Next - DateTime.Now).TotalMilliseconds); if (ms > 0) { Thread.Sleep(ms); } Response = Client.GET(ImageURI.PathAndQuery, ContentType); Msg.EmbedObject("cam" + (i + 1).ToString() + "img" + j.ToString() + "." + Extension, ContentType, Response.Data); Log.Information("Click.", EventLevel.Minor, Service.Device.FriendlyName); Next = Next.AddSeconds(5); } } } catch (ThreadAbortException) { Thread.ResetAbort(); } catch (Exception ex) { Log.Exception(ex); } finally { Done.Set(); } }
public PrefixPhrase <O> Add(ParsedUri purl) { String host = purl.Host; //edit // domainPrefix is a child of this, the root (with no parent) PrefixPhrase <O> hostPrefix = GetPrefix(null, host); // children of hostPrefix String pathStringToParse = usePathFile ? purl.ToString() : purl.LocalPath; //.pathDirectoryString; return((hostPrefix != null) ? hostPrefix.Add(pathStringToParse, separator) : LookupChild(host)); }
public WebViewParser(DocumentClosure closure) { _closure = closure; SemanticsSessionScope = closure.SemanticsSessionScope; _webView = SemanticsSessionScope.WebBrowserPool.Acquire(); _puri = closure.PURLConnection.ResponsePURL; _requestTimedOut = new DispatcherTimer() { Interval = EXTRACTION_TIMEOUT }; _requestTimedOut.Tick += ExtractionRequestTimedOut; }
public Image ConstructImage(ParsedUri location) { MetaMetadata metaMetadata = GetImageMM(location); Image result = null; if (metaMetadata != null) { result = (Image)metaMetadata.ConstructMetadata(this.MetadataTScope); result.Location = new MetadataParsedURL(location); } return(result); }
public string GetUriLeftPart(ParsedUri parsedUri) { var urlWithQuery = parsedUri.GetComponents(UriComponents.HttpRequestUrl, UriFormat.UriEscaped); var query = parsedUri.GetComponents(UriComponents.Query, UriFormat.UriEscaped); var index = urlWithQuery.IndexOf(query); string urlWithoutQuery = urlWithQuery; if (index != -1) { urlWithoutQuery = urlWithQuery.Remove(index); } return(urlWithoutQuery); }
public async Task <MetaMetadataRepository> LoadRepositoryFromServiceAsync(ParsedUri serviceUri, object cacheFile = null) { _metaMetadataRepository = (serviceUri != null) ? await RequestMetaMetadataRepository(new ParsedUri(serviceUri, "mmdrepository.xml")) : new MetaMetadataRepository(); if (cacheFile != null) { SimplTypesScope.Serialize(_metaMetadataRepository, cacheFile, Format.Xml); } InitializeRepositoryAndPerformBinding(); return(_metaMetadataRepository); }
public virtual async Task <Document> GetDocument(ParsedUri location) { if (location == null) { return(null); } Document doc; GlobalDocumentCollection.TryGetDocument(location, out doc); return(doc); }
public async Task <object> DeserializeUri(ParsedUri uri, Format format = Format.Xml, TranslationContext context = null, IDeserializationHookStrategy deserializationHookStrategy = null) { object result = null; var request = WebRequest.Create(uri); if (request != null) { WebResponse response = await request.GetResponseAsync(); result = Deserialize(response.GetResponseStream(), context, deserializationHookStrategy, format); } return(result); }
public virtual async Task <Document> GetOrConstructDocument(ParsedUri location) { var doc = await GetDocument(location); if (doc == null && MetaMetadataRepository != null) { doc = MetaMetadataRepository.ConstructDocument(location, false); if (doc != null) { GlobalDocumentCollection.AddDocument(doc, location); } } return(doc); }
public Document ConstructDocument(ParsedUri location, bool isImage) { // if (location.IsImage) return constructImage(location); if (isImage) { return(ConstructImage(location)); } MetaMetadata mmd = GetDocumentMM(location); Document result = mmd.ConstructMetadata(MetadataTScope) as Document; if (result != null) { result.Location = new MetadataParsedURL(location); } return(result); }
///<summary> /// Get the old location from this. /// Set the location of this to the newLocation. /// Add a mapping in the GlobalCollection from newLocation to this. /// Add the old location for this as an additionalLocation for this. ///</summary> public void ChangeLocation(ParsedUri newLocation) { if (newLocation != null) { MetadataParsedURL origLocation = Location; if (!origLocation.Value.Equals(newLocation)) { Location = new MetadataParsedURL(newLocation); if (SemanticsSessionScope != null) { SemanticsSessionScope.GlobalDocumentCollection.AddDocument(this, newLocation); } AddAdditionalLocation(origLocation); } } }
public override Input CreateConnector(ParsedUri uri) { string skypeId = uri.Host; Logger.Debug("Trying Skype ID: {0} ...", skypeId); string applicationDataPath = Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData); string databasePath = Path.Combine( applicationDataPath, "Skype", skypeId, "main.db"); Logger.Debug("Trying database path: {0} ...", databasePath); if (!File.Exists(databasePath)) { throw new InvalidArgumentInternalException("Database file is not found for this Skype ID."); } Logger.Debug("Database file is found."); return(new SkypeInput(databasePath)); }
private async void ShowFeeds() { Feeds.Clear(); if (FeedURLs != null) { foreach (string url in FeedURLs.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)) { var puri = new ParsedUri(url); var parsedDoc = await _sessionScope.GetDocument(puri); var feedViewModels = FeedViewModelFactory.GetFeedViewModels(parsedDoc); foreach (var viewModel in feedViewModels) { Feeds.Add(viewModel); } this.NotifyPropertyChanged("Feeds"); } } }
private MetaMetadataCompositeField GetMetaMetadata() { MetaMetadataCompositeField mm = _metaMetadata; //mm = await MetaMetadataTranslationScope.Get().Deserialize() if (_repository == null) { _repository = MetaMetadataRepositoryInit.GetRepository(); } if (mm == null && _repository != null) { if (this.MetaMetadataName != null) // get from saved composition { mm = _repository.GetMMByName(this.MetaMetadataName.Value); } if (mm == null) { ParsedUri location = Location == null ? null : Location.Value; if (location != null) { mm = IsImage ? _repository.GetImageMM(location) : _repository.GetDocumentMM(location); // TODO -- also try to resolve by mime type ??? } if (mm == null) { mm = _repository.GetByClass(this.GetType()); } if (mm == null && MetadataClassDescriptor != null) { mm = _repository.GetMMByName(MetadataClassDescriptor.TagName); } } if (mm != null) { MetaMetadata = mm; } } return(mm); }
public MetadataServicesClient(SimplTypesScope metadatascope, SemanticsSessionScope semanticSessionScope, ParsedUri serviceUri, bool useWebSockets = false) { SimplTypesScope[] oodssAndMetadataScope = { metadatascope, DefaultServicesTranslations.Get() }; _metadataTypeScope = SimplTypesScope.Get("MetadataServicesTranslationScope", oodssAndMetadataScope, typeof(MetadataRequest), typeof(MetadataResponse), typeof(SemanticServiceError) ); _serviceBaseUri = serviceUri; if (useWebSockets) { _metadataClient = new WebSocketOODSSClient("127.0.0.1", 2018, _metadataTypeScope, semanticSessionScope); _metadataClient.StartAsync(); } }