protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            string strDinnerId = ExtractParameter(request.RequestUri);
            int dinnerId = 0;
            if (!String.IsNullOrEmpty(strDinnerId) && Int32.TryParse(strDinnerId, out dinnerId))
            {
                return FetchDinner(dinnerId).Then(dinner =>
                {
                    if (dinner != null && dinner.d != null)
                    {
                        return new ContentProviderResult()
                        {
                            Content = String.Format(_nerdDinnerContentFormat,
                            dinner.d.Latitude,
                            dinner.d.Longitude,
                            dinner.d.Address,
                            String.Format(
                            _nerdDinnerInfoContentFormat,
                            dinner.d.Title,
                            dinner.d.EventDate.Value.Date.ToLongDateString(),
                            dinner.d.EventDate.Value.ToLongTimeString(),
                            dinner.d.Address,
                            dinner.d.Description,
                            dinner.d.DinnerID)),
                            Title = dinner.d.Title
                        };
                    }

                    return null;
                });
            }

            return TaskAsyncHelper.FromResult<ContentProviderResult>(null);
        }
Example #2
0
        private Task<ContentProviderResult> ExtractContent(ContentProviderHttpRequest request)
        {
            var validProviders = _contentProviders.Where(c => c.IsValidContent(request.RequestUri))
                                                  .ToList();

            if (validProviders.Count == 0)
            {
                return TaskAsyncHelper.FromResult<ContentProviderResult>(null);
            }

            var tasks = validProviders.Select(c => c.GetContent(request)).ToArray();

            var tcs = new TaskCompletionSource<ContentProviderResult>();

            Task.Factory.ContinueWhenAll(tasks, completedTasks =>
            {
                var faulted = completedTasks.FirstOrDefault(t => t.IsFaulted);
                if (faulted != null)
                {
                    tcs.SetException(faulted.Exception);
                }
                else if (completedTasks.Any(t => t.IsCanceled))
                {
                    tcs.SetCanceled();
                }
                else
                {
                    ContentProviderResult result = completedTasks.Select(t => t.Result)
                                                                 .FirstOrDefault(content => content != null);
                    tcs.SetResult(result);
                }
            });

            return tcs.Task;
        }
Example #3
0
        protected override async Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            string format = @"<a rel=""nofollow external"" target=""_blank"" href=""{0}""><img src=""{1}"" /></a>";
            string imageUrl = request.RequestUri.ToString();
            string href = imageUrl;

            // Only proxy what we need to (non https images)
            if (_configuration.RequireHttps &&
                !request.RequestUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
            {
                var uploadProcessor = _kernel.Get<UploadProcessor>();
                var response = await Http.GetAsync(request.RequestUri);
                string fileName = Path.GetFileName(request.RequestUri.LocalPath);
                string contentType = GetContentType(request.RequestUri);
                long contentLength = response.ContentLength;

                using (Stream stream = response.GetResponseStream())
                {
                    UploadResult result = await uploadProcessor.HandleUpload(fileName, contentType, stream, contentLength);

                    if (result != null)
                    {
                        imageUrl = result.Url;
                    }
                }
            }

            return new ContentProviderResult()
            {
                Content = String.Format(format, Encoder.HtmlAttributeEncode(href), 
                                                Encoder.HtmlAttributeEncode(imageUrl)),
                Title = href
            };
        }
Example #4
0
        private Task <ContentProviderResult> ExtractContent(ContentProviderHttpRequest request)
        {
            var validProviders = _contentProviders.Where(c => c.IsValidContent(request.RequestUri))
                                 .ToList();

            if (validProviders.Count == 0)
            {
                return(TaskAsyncHelper.FromResult <ContentProviderResult>(null));
            }

            var tasks = validProviders.Select(c => c.GetContent(request)).ToArray();

            var tcs = new TaskCompletionSource <ContentProviderResult>();

            Task.Factory.ContinueWhenAll(tasks, completedTasks =>
            {
                var faulted = completedTasks.FirstOrDefault(t => t.IsFaulted);
                if (faulted != null)
                {
                    tcs.SetException(faulted.Exception);
                }
                else if (completedTasks.Any(t => t.IsCanceled))
                {
                    tcs.SetCanceled();
                }
                else
                {
                    ContentProviderResult result = completedTasks.Select(t => t.Result)
                                                   .FirstOrDefault(content => content != null);
                    tcs.SetResult(result);
                }
            });

            return(tcs.Task);
        }
Example #5
0
        private Task<XkcdContentProvider.XkcdComicInfo> ExtractFromResponse(ContentProviderHttpRequest request)
        {
            return Http.GetAsync(request.RequestUri).Then(response =>
            {
                var comicInfo = new XkcdComicInfo();

                using (var responseStream = response.GetResponseStream())
                {
                    var htmlDocument = new HtmlDocument();
                    htmlDocument.Load(responseStream);
                    htmlDocument.OptionFixNestedTags = true;

                    var comic = htmlDocument.DocumentNode.SelectSingleNode("//div[@id='comic']/img");

                    if (comic == null)
                    {
                        return null;
                    }

                    comicInfo.Title = comic.Attributes["alt"].Value;
                    comicInfo.ImageUrl = comic.Attributes["src"].Value;
                    comicInfo.Description = comic.Attributes["title"].Value;

                }

                return comicInfo;
            });
        }
Example #6
0
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return TaskAsyncHelper.FromResult(new ContentProviderResult()
      {
          Content = String.Format(@"<img src=""{0}"" />", request.RequestUri),
          Title = request.RequestUri.AbsoluteUri.ToString()
      });
 }
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return TaskAsyncHelper.FromResult(new ContentProviderResult()
     {
         Content = String.Format(_iframedMeetingFormat, request.RequestUri.AbsoluteUri),
         Title = String.Format(LanguageResources.JoinMeContent_DefaultTitle, request.RequestUri.AbsoluteUri)
     });
 }
Example #8
0
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return TaskAsyncHelper.FromResult(new ContentProviderResult()
     {
         Content = String.Format(_iframedMeetingFormat, request.RequestUri.AbsoluteUri),
         Title = "Join Me Meeting: " + request.RequestUri.AbsoluteUri.ToString()
     });
 }
 public Task<ContentProviderResult> GetContent(ContentProviderHttpRequest request)
 {
     return TaskAsyncHelper.FromResult(new ContentProviderResult()
     {
         Content = String.Format(@"<audio controls=""controls"" src=""{0}"">Your browser does not support the audio tag.</audio>", request.RequestUri),
         Title = request.RequestUri.AbsoluteUri.ToString()
     });
 }
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return base.GetCollapsibleContent(request).Then(content =>
     {
         var queryString = new QueryStringCollection(request.RequestUri.Query);
         content.Title = queryString["q"] ?? "Google Maps";
         return content;
     });
 }
Example #11
0
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     string url = request.RequestUri.ToString();
     return TaskAsyncHelper.FromResult(new ContentProviderResult()
      {
          Content = String.Format(@"<img src=""{0}"" />", Encoder.HtmlAttributeEncode(url)),
          Title = url
      });
 }
 public Task<ContentProviderResult> GetContent(ContentProviderHttpRequest request)
 {
     string url = request.RequestUri.ToString();
     return TaskAsyncHelper.FromResult(new ContentProviderResult()
     {
         Content = String.Format(@"<audio controls=""controls"" src=""{1}"">{0}</audio>", LanguageResources.AudioTagSupportRequired, Encoder.HtmlAttributeEncode(url)),
         Title = request.RequestUri.AbsoluteUri
     });
 }
Example #13
0
        private Task<ContentProviderResult> ExtractContent(ContentProviderHttpRequest request)
        {
            var validProviders = _contentProviders.Select(p =>
            {
                var match = p.Match(request.RequestUri);

                return new
                {
                    Provider = p,
                    Match = match,
                    IsValid = (match != null && match.Success) || p.IsValidContent(request.RequestUri)
                };
            }).Where(c => c.IsValid).ToList();

            if (validProviders.Count == 0)
                return TaskAsyncHelper.FromResult<ContentProviderResult>(null);

            var tasks = validProviders.Select(c =>
            {
                c.Provider.Repository = _repository;
                return c.Match != null ?
                    c.Provider.GetContent(request, c.Match) :
                    c.Provider.GetContent(request);
            }).ToArray();

            var tcs = new TaskCompletionSource<ContentProviderResult>();

            Task.Factory.ContinueWhenAll(tasks, completedTasks =>
            {
                var result = completedTasks.Where(t => !t.IsFaulted && !t.IsCanceled)
                                           .Select(t => t.Result)
                                           .Where(u => u != null)
                                           .OrderByDescending(v => v.Weight)
                                           .FirstOrDefault();
                if (result != null)
                {
                    // Get the result if ready or execute the delayed task
                    result.Execute(request).Then(r => tcs.SetResult(r));
                }
                else
                {

                    var faulted = completedTasks.FirstOrDefault(t => t.IsFaulted);
                    if (faulted != null)
                    {
                        tcs.SetException(faulted.Exception);
                    }
                    else if (completedTasks.Any(t => t.IsCanceled))
                    {
                        tcs.SetCanceled();
                    }
                }
            });

            return tcs.Task;
        }
Example #14
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            string id = request.RequestUri.AbsoluteUri.Split('/').Last();

            return TaskAsyncHelper.FromResult(new ContentProviderResult()
            {
                Content = String.Format(@"<img src=""http://i.imgur.com/{0}.jpg"" />", id),
                Title = request.RequestUri.AbsoluteUri.ToString()
            });
        }
Example #15
0
        public Task<ContentProviderResult> Execute(ContentProviderHttpRequest request)
        {
            if (Title != null && Content != null)
                return TaskAsyncHelper.FromResult(this);

            if(_task == null)
                throw new ArgumentNullException("task", "Task is required if no title and content parameter is given.");

            return _task(request);
        }
Example #16
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            var spotifyUri = ExtractSpotifyUri(request.RequestUri.AbsolutePath);

            return TaskAsyncHelper.FromResult(new ContentProviderResult()
                                                  {
                                                      Content = String.Format("<iframe src=\"https://embed.spotify.com/?uri=spotify:{0}\" width=\"300\" height=\"380\" frameborder=\"0\" allowtransparency=\"true\"></iframe>", spotifyUri),
                                                      Title = String.Format("spotify:track:{0}", spotifyUri)
                                                  });
        }
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return FetchArticle(request.RequestUri).Then(article =>
     {
         return new ContentProviderResult()
         {
             Title = article.title,
             Content = article.html
         };
     });
 }
Example #18
0
        public Task<ContentProviderResult> ExtractResource(string url)
        {
            Uri resultUrl;
            if (Uri.TryCreate(url, UriKind.Absolute, out resultUrl))
            {
                var request = new ContentProviderHttpRequest(resultUrl);
                return ExtractContent(request);
            }

            return TaskAsyncHelper.FromResult<ContentProviderResult>(null);
        }
Example #19
0
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return ExtractFromResponse(request).Then(pageInfo =>
     {
         return new ContentProviderResult()
         {
             Content = String.Format(ContentFormat, pageInfo.Title, pageInfo.ImageURL, pageInfo.Title, pageInfo.Title, pageInfo.Description, pageInfo.PageURL),
             Title = pageInfo.Title
         };
     });
 }
Example #20
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            string format = "<video width=\"640\" height=\"360\" preload=\"none\" controls=\"\" style=\"display: block;\"><source src=\"{0}\" type=\"{1}\">Sorry, you don't have HTML5 video, but you can try to view it directly: <a href=\"{0}\">{0}</a></video>";
            string href = request.RequestUri.ToString();

            return TaskAsyncHelper.FromResult(new ContentProviderResult()
            {
                Content = String.Format(format, Encoder.HtmlAttributeEncode(href), Encoder.HtmlAttributeEncode(GetContentType(request.RequestUri))),
                Title = href
            });
        }
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return ExtractIFrameCode(request).Then(result =>
     {
         var iframeHtml = result;
         return new ContentProviderResult()
         {
             Content = iframeHtml.Replace("http://", "https://"),
             Title = request.RequestUri.AbsoluteUri.ToString()
         };
     });
 }
        public Task <ContentProviderResult> ExtractResource(string url)
        {
            Uri resultUrl;

            if (Uri.TryCreate(url, UriKind.Absolute, out resultUrl))
            {
                var request = new ContentProviderHttpRequest(resultUrl);
                return(ExtractContent(request));
            }

            return(TaskAsyncHelper.FromResult <ContentProviderResult>(null));
        }
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            var parameters = ExtractParameters(request.RequestUri);

            return TaskAsyncHelper.FromResult(new ContentProviderResult()
            {
                Content = String.Format(_gitHubIssuesContentFormat,
                        parameters[1],
                    String.Format(_gitHubIssuesApiFormat, parameters[0], parameters[1])
                ),
                Title = request.RequestUri.AbsoluteUri
            });
        }
        public virtual Task <ContentProviderResult> GetContent(ContentProviderHttpRequest request)
        {
            return(GetCollapsibleContent(request).Then(result =>
            {
                if (GetIsCollapsible(request.RequestUri) && result != null)
                {
                    string contentTitle = String.Format(LanguageResources.Content_HeaderAndToggle, Encoder.HtmlEncode(result.Title));
                    result.Content = String.Format(ContentFormat, contentTitle, result.Content);
                }

                return result;
            }));
        }
        public virtual Task<ContentProviderResult> GetContent(ContentProviderHttpRequest request)
        {
            return GetCollapsibleContent(request).Then(result =>
            {
                if (GetIsCollapsible(request.RequestUri) && result != null)
                {
                    string contentTitle = String.Format(LanguageResources.Content_HeaderAndToggle, Encoder.HtmlEncode(result.Title));
                    result.Content = String.Format(ContentFormat, contentTitle, result.Content);
                }

                return result;
            });
        }
 protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
 {
     return ExtractFromResponse(request).Then(pageInfo =>
     {
         return new ContentProviderResult
         {
             Content = String.Format(ContentFormat,
                                     HttpUtility.HtmlAttributeEncode(pageInfo.ImageURL),
                                     HttpUtility.HtmlAttributeEncode(pageInfo.Title)),
             Title = pageInfo.Title
         };
     });
 }
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            var url = String.Format(@"http://soundcloud.com/oembed?format=json&iframe=true&show_comments=false&url={0}", request.RequestUri.AbsoluteUri);

            return Http.GetJsonAsync<SoundCloudResponse>(url).Then(widgetInfo =>
            {
                return new ContentProviderResult
                {
                    Title = widgetInfo.Title,
                    Content = widgetInfo.FrameMarkup
                };
            });
        }
Example #28
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request, Match match)
        {
            var value = match.Groups["value"].Value;

            if (match.Groups["parameters"].Success)
                value += match.Groups["parameters"].Value;

            return TaskAsyncHelper.FromResult(new ContentProviderResult
            {
                Content = TemplateHelper.Render("ContentProvider/reddit", new { location = value }),
                Title = "reddit"
            });
        }
Example #29
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            var shortKey = ExtractKey(request.RequestUri);

            if (shortKey != null)
                return GetCollapsibleContent(shortKey);

            return Http.GetJsonAsync("http://www.rdio.com/api/oembed/?format=json&url=" +
                HttpUtility.UrlEncode(request.RequestUri.AbsoluteUri)).Then(result => new ContentProviderResult
            {
                Content = result.html,
                Title = result.title
            });
        }
Example #30
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            var args = ExtractParameters(request.RequestUri);
            if (args == null || !args.Any())
            {
                return TaskAsyncHelper.FromResult<ContentProviderResult>(null);
            }

            return TaskAsyncHelper.FromResult(new ContentProviderResult
             {
                 Content = String.Format(MediaFormatString, args.ToArray()),
                 Title = request.RequestUri.AbsoluteUri
             });
        }
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            string packageName = ExtractPackageName(request.RequestUri);
            if (!String.IsNullOrEmpty(packageName))
            {
                return FetchPackage(packageName).Then(package =>
                {
                    if (package != null && package.d.results.Count > 0)
                    {
                        var packageInfo = package.d.results[0];
                        var projectIcon = String.Empty;
                        if (packageInfo.IconUrl != null)
                        {
                            projectIcon = String.Format("<img class=\"nuget-projecticon\" src=\"{0}\" />",
                                                        packageInfo.IconUrl);
                        }

                        var projectInfo = new StringBuilder();
                        projectInfo.AppendFormat("<div class=\"nuget-authors\" ><span>Authors: </span><div class=\"nuget-authors-entry\">{0}</div></div>",
                                                 packageInfo.Authors);
                        projectInfo.AppendFormat("<div class=\"nuget-downloads\" ><span># Downloads:</span> {0}</div>",
                                                 packageInfo.DownloadCount);

                        if (packageInfo.ProjectUrl != null)
                        {
                            projectInfo.AppendFormat(
                                "<div class=\"nuget-ProjectUrl\" ><a target=\"_blank\" href=\"{0}\">{0}</a></div>",
                                packageInfo.ProjectUrl);
                        }

                        return new ContentProviderResult()
                        {
                            Content = String.Format(_nugetBadgeFormat,
                                                    packageInfo.Id,
                                                    packageInfo.Title,
                                                    packageInfo.Summary,
                                                    projectIcon,
                                                    packageInfo.Description,
                                                    projectInfo),
                            Title = packageInfo.Title + " NuGet package"
                        };
                    }

                    return null;
                });
            }

            return TaskAsyncHelper.FromResult<ContentProviderResult>(null);
        }
Example #32
0
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request, Match match)
        {
            if (!match.Success) throw new ArgumentException("Invalid match, expected a successful match", "match");

            var url = String.Format("https://i.minus.com/{0}.{1}", match.Groups["id"], match.Groups["ext"].Value);

            return TaskAsyncHelper.FromResult(new ContentProviderResult
            {
                Content = String.Format(ImageContentProvider.HtmlFormat,
                    Encoder.HtmlAttributeEncode(request.RequestUri.AbsoluteUri),
                    Encoder.HtmlAttributeEncode(url)),
                Title = url,
                Weight = 1
            });
        }
Example #33
0
        protected override Task <ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            var args = ExtractParameters(request.RequestUri);

            if (args == null || !args.Any())
            {
                return(TaskAsyncHelper.FromResult <ContentProviderResult>(null));
            }

            return(TaskAsyncHelper.FromResult(new ContentProviderResult()
            {
                Content = String.Format(MediaFormatString, args.ToArray()),
                Title = request.RequestUri.AbsoluteUri.ToString()
            }));
        }
        protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
        {
            return ExtractFromResponse(request).Then(pageInfo =>
            {
                if (pageInfo == null)
                {
                    return null;
                }

                return new ContentProviderResult
                {
                    Content = String.Format(ContentFormat, pageInfo.PageURL, pageInfo.QuoteNumber, pageInfo.Quote),
                    Title = pageInfo.PageURL
                };
            });
        }
        public virtual Task <ContentProviderResult> GetContent(ContentProviderHttpRequest request)
        {
            return(GetCollapsibleContent(request).Then(result =>
            {
                if (IsCollapsible && result != null)
                {
                    result.Content = String.Format(CultureInfo.InvariantCulture,
                                                   ContentFormat,
                                                   IsPopOut ? @"<div class=""collapsible_pin""></div>" : "",
                                                   Encoder.HtmlEncode(result.Title),
                                                   result.Content);
                }

                return result;
            }));
        }
Example #36
0
        public virtual Task <ContentProviderResult> GetContent(ContentProviderHttpRequest request)
        {
            return(GetCollapsibleContent(request).Then(result =>
            {
                if (IsCollapsible && result != null)
                {
                    result.Content = String.Format(CultureInfo.InvariantCulture,
                                                   ContentFormat,
                                                   String.Empty,
                                                   Encoder.HtmlEncode(result.Title),
                                                   result.Content);
                }

                return result;
            }));
        }
 protected abstract Task <ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request);