public void MovieInfoAsync(string t, int? y, string l = "pt")
        {
            AggregatedMovieInfo movieInfo = new AggregatedMovieInfo();
            AsyncManager.OutstandingOperations.Increment();

            if (string.IsNullOrEmpty(t))
            {
                FinalizeOperations(movieInfo);
            }
            else
            {
                //var imdbResultTask = GetImdbInfoAsync(t, y, l);
                var imdbResultTask = GetCachedImdbInfoAsync(t, y, l);
                tasks.Add(imdbResultTask);

                imdbResultTask.ContinueWith(
                    _ =>
                    {
                        if (imdbResultTask.IsCompleted)
                        {
                            var imdbResult = imdbResultTask.Result;
                            FillValuesFromImdbResult(imdbResult, movieInfo);

                            if (!String.IsNullOrEmpty(movieInfo.plot))
                            {
                                //var bingPlotResultTask = GetBingInfoWithRetriesAsync(movieInfo.Synopsis, l).Run<string>().ContinueWith(
                                var bingPlotResultTask = GetCachedBingInfoWithRetriesAsync(movieInfo.plot, t, l).Run<string>().ContinueWith(
                                    bingTask =>
                                    {
                                        if (bingTask.IsCompleted)
                                        {
                                            FillValuesFromBingPlotResult(bingTask.Result, movieInfo);
                                        }
                                    }
                                );

                                tasks.Add(bingPlotResultTask);
                            }

                            if (!string.IsNullOrEmpty(movieInfo.title) && !string.IsNullOrEmpty(movieInfo.director_name))
                            {
                                //var flickrResultTask = GetFlickrInfoAsync(movieInfo.FullTitle, movieInfo.Director).ContinueWith(
                                var flickrResultTask = GetCachedFlickrInfoAsync(movieInfo.title, movieInfo.director_name, l).ContinueWith(
                                    flickrTask =>
                                    {
                                        if (flickrTask.IsCompleted)
                                        {
                                            FillValuesFromFlickrResult(flickrTask.Result, movieInfo);
                                        }
                                    }
                                );

                                tasks.Add(flickrResultTask);
                            }

                            if (y.HasValue)
                            {
                                //var nYTimesResultTask = GetNyTimesInfoAsync(movieInfo.FullTitle, y.Value).ContinueWith(
                                var nYTimesResultTask = GetCachedNyTimesInfoAsync(movieInfo.title, y.Value, l).ContinueWith(
                                    nyTimesTask =>
                                    {
                                        if (nyTimesTask.IsCompleted)
                                        {
                                            var nyTimesResult = nyTimesTask.Result;
                                            FillValuesFromNYTimesResult(nyTimesResult, l, movieInfo);
                                        }
                                    }
                                );

                                tasks.Add(nYTimesResultTask);
                            }

                            Task.Factory.ContinueWhenAll(tasks.ToArray(), tsks => FinalizeOperations(movieInfo));
                        }
                        else
                        {
                            FinalizeOperations(movieInfo);
                        }
                    });
            }
        }
 private void FinalizeOperations(AggregatedMovieInfo movieInfo)
 {
     AsyncManager.Parameters["movieInfo"] = movieInfo;
     AsyncManager.OutstandingOperations.Decrement();
 }
 private void FillValuesFromBingPlotResult(string bingPlotResult, AggregatedMovieInfo movieInfo)
 {
     movieInfo.plot = bingPlotResult;
 }
        private void FillValuesFromFlickrResult(string flickrResult, AggregatedMovieInfo movieInfo)
        {
            var parseValue = JsonValue.Parse(flickrResult).AsDynamic();

            if (parseValue.stat == "ok")
            {
                var photos = parseValue.photos.photo;

                foreach (var photo in photos)
                {
                    var farm = photo.farm.Value;
                    var server = photo.server.Value;
                    var id = photo.id.Value;
                    var secret = photo.secret.Value;
                    var template = String.Format("http://farm{0}.static.flickr.com/{1}/{2}_{3}.jpg", farm, server, id, secret);

                    movieInfo.photos.Add(template);
                }
            }
        }
        private void FillValuesFromImdbResult(string imdbResult, AggregatedMovieInfo movieInfo)
        {
            var parseValue = JsonValue.Parse(imdbResult).AsDynamic();

            if (parseValue.Response == "True")
            {
                movieInfo.title = parseValue.Title;
                movieInfo.year = parseValue.Year;
                movieInfo.director_name = parseValue.Director;
                movieInfo.plot = parseValue.Plot;
                movieInfo.poster_url = parseValue.Poster;
            }
        }
        private void FillValuesFromNYTimesResult(string nyTimesResult, string language, AggregatedMovieInfo movieInfo)
        {
            var parseValue = JsonValue.Parse(nyTimesResult).AsDynamic();

            if (parseValue.status == "OK")
            {
                var criticsResults = parseValue.results;

                foreach (var criticsResult in criticsResults)
                {
                    string critic = criticsResult.byline;
                    string capsuleReview = criticsResult.capsule_review;
                    string fullReviewUrl = criticsResult.link.url;

                    var returnTask = GetBingInfoWithRetriesAsync(capsuleReview, language).Run<string>().ContinueWith(
                        bingTask =>
                        {
                            if (bingTask.IsCompleted)
                            {
                                movieInfo.ConcurrentReviews.Add(new NyTimesReview(critic, bingTask.Result, fullReviewUrl));
                            }

                        }, TaskContinuationOptions.AttachedToParent
                    );

                    tasks.Add(returnTask);
                }
            }
        }
 public JsonResult MovieInfoCompleted(AggregatedMovieInfo movieInfo)
 {
     movieInfo.NormalizeReviewsForJson();
     return Json(movieInfo, JsonRequestBehavior.AllowGet);
 }