public async Task <Films> GetFilms(RegionDef region, bool fullInfo = false, int cinema = int.MinValue, int film = int.MinValue)
{
StringBuilder sb = new StringBuilder();
sb.Append($"{BaseAPIUrl}{FilmsHandle}");
sb.Append($"?{QSKeyParam}={DevKey}&{QSTerritoryParam}={region}");
if (cinema != int.MinValue)
{
sb.Append($"&{QSCinemaParam}={cinema}");
}
if (film != int.MinValue)
{
sb.Append($"&{QSFilmParam}={film}");
}
sb.Append($"&{QSFullParam}={fullInfo}");
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(sb.ToString());
Films f = JsonConvert.DeserializeObject <Films>(data);
f.Cinema = cinema;
return(f);
}
public async Task <Uri> GetVideoUrl(string title)
{
string queryUrl = String.Format(youtubeUri, title);
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(queryUrl);
VideoSearchResults v = JsonConvert.DeserializeObject <VideoSearchResults>(data);
if (v != null && v.Data != null && v.Data.Items != null && v.Data.Items.Count > 0)
{
#if WINDOWS_PHONE
return(null);
#elif METRO
var uri = await MyToolkit.Multimedia.YouTube.GetVideoUriAsync(v.Data.Items[0].Id, MyToolkit.Multimedia.YouTubeQuality.Quality1080P);
if (uri.IsValid)
{
return(uri.Uri);
}
#endif
//return String.Format("vnd.youtube:{0}", v.Data.Items[0].Id);
}
return(null);
}
public async Task <FilmImages> GetFilmImages(int filmID)
{
string url = String.Format("{0}{1}{2}/{3}?{4}={5}&append_to_response=credits", BaseAPIUrl, MovieDetailsApiUrl, filmID, ImagesApiUrl, AppKeyTag, APIKey);
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
FilmImages i = JsonConvert.DeserializeObject <FilmImages>(data);
return(i);
}
public async Task <Dates> GetDates(RegionDef region, int cinema, int film)
{
string url = $"{BaseAPIUrl}{DatesHandle}?{QSKeyParam}={DevKey}&{QSCinemaParam}={cinema}&{QSFilmParam}={film}&{QSTerritoryParam}={region}";
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
Dates d = JsonConvert.DeserializeObject <Dates>(data);
return(d);
}
public async Task <Movie> GetMovieDetails(int movieID)
{
string url = String.Format("{0}{1}{2}?{3}={4}&append_to_response=releases,trailers,poster,casts", BaseAPIUrl, MovieDetailsApiUrl, movieID, AppKeyTag, APIKey);
//webclient.DownloadStringAsync(new Uri(url, UriKind.Absolute));
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
Movie m = JsonConvert.DeserializeObject <Movie>(data);
return(m);
}
public async Task <Configuration> GetConfig()
{
string url = String.Format("{0}{1}?{2}={3}", BaseAPIUrl, ConfigApiUrl, AppKeyTag, APIKey);
//webclient.DownloadStringAsync(new Uri(url, UriKind.Absolute));
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
Configuration r = JsonConvert.DeserializeObject <Configuration>(data);
return(r);
}
public async Task <Person> GetPersonDetails(int personID)
{
string url = String.Format("{0}{1}{2}?{3}={4}&append_to_response=credits", BaseAPIUrl, PersonDetailsApiUrl, personID, AppKeyTag, APIKey);
//webclient.DownloadStringAsync(new Uri(url, UriKind.Absolute));
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
Person p = JsonConvert.DeserializeObject <Person>(data);
return(p);
}
public async Task DownloadFiles(bool bForce = false)
{
AsyncWebClient awc = new AsyncWebClient();
if (Config.Region == Config.RegionDef.UK)
{
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, CinemasUKFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, CinemasUKFileName), CinemasUKFileName);
}
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, FilmsUKFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, FilmsUKFileName), FilmsUKFileName);
}
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, CinemaFilmsUKFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, CinemaFilmsUKFileName), CinemaFilmsUKFileName);
}
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, FilmCinemasUKFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, FilmCinemasUKFileName), FilmCinemasUKFileName);
}
}
else
{
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, CinemasIEFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, CinemasIEFileName), CinemasIEFileName);
}
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, FilmsIEFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, FilmsIEFileName), FilmsIEFileName);
}
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, CinemaFilmsIEFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, CinemaFilmsIEFileName), CinemaFilmsIEFileName);
}
if (!await PersistHelper.FileExisits(ApplicationData.Current.LocalFolder, FilmCinemasIEFileName) || bForce)
{
await awc.DownloadFileAsync(String.Format("{0}{1}", blobStorage, FilmCinemasIEFileName), FilmCinemasIEFileName);
}
}
}
public async Task <string> GetVideoId(string title)
{
string queryUrl = String.Format(youtubeUri, title);
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(queryUrl);
VideoSearchResults v = JsonConvert.DeserializeObject <VideoSearchResults>(data);
if (v != null && v.Data != null && v.Data.Items != null && v.Data.Items.Count > 0)
{
return(v.Data.Items[0].Id);
}
return(null);
}
public async Task <Performances> GetPerformances(RegionDef region, int cinema, int film, string date)
{
string url = $"{BaseAPIUrl}{PerformancesHandle}?{QSKeyParam}={DevKey}&{QSCinemaParam}={cinema}&{QSFilmParam}={film}&{QSDateParam}={date}&{QSTerritoryParam}={region}";
//webclient.DownloadStringAsync(new Uri(url, UriKind.Absolute));
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
DateTime dt = DateTime.ParseExact(date, "yyyymmdd", CultureInfo.InvariantCulture);
Performances p = JsonConvert.DeserializeObject <Performances>(data);
p.Date = dt;
return(p);
}
public async Task <Results> GetSearchResults(string title, DateTime dtRelease)
{
string url = null;
DateTime release = dtRelease;
bool bTryEarlier = false;
bool bSecondTry = false;
Results r = null;
while (true)
{
if (dtRelease != DateTime.MinValue)
{
url = String.Format("{0}{1}?{2}={3}&{4}={5}&{6}={7}", BaseAPIUrl, SearchMovieApiUrl, AppKeyTag, APIKey, QueryTag, title, YearTag, release.Year);
if (!bSecondTry)
{
bTryEarlier = true;
}
}
else
{
url = String.Format("{0}{1}?{2}={3}&{4}={5}", BaseAPIUrl, SearchMovieApiUrl, AppKeyTag, APIKey, QueryTag, title);
}
//webclient.DownloadStringAsync(new Uri(url, UriKind.Absolute));
AsyncWebClient awc = new AsyncWebClient();
string data = await awc.GetStringAsync(url);
r = JsonConvert.DeserializeObject <Results>(data);
if (bTryEarlier && dtRelease != DateTime.MinValue && (r.SearchResults == null || r.SearchResults.Count == 0))
{
release = dtRelease.AddYears(-1);
bSecondTry = true;
bTryEarlier = false;
}
else
{
break;
}
}
return(r);
}
public async Task DownloadPosters()
{
await DownloadFile(MovieFilmPostersFileName, false);
if (!Config.AnimateLockscreen)
{
return;
}
object o = await ReadMoviePosters();
if (o == null || !(o is JObject))
{
return;
}
JObject data = (JObject)o;
bool downloadFiles = true;
IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication();
string folder = "Shared\\ShellContent";
if (!isf.DirectoryExists(folder))
{
isf.CreateDirectory(folder);
}
else
{
if (isf.GetLastWriteTime(folder) >= isf.GetLastWriteTime(BaseStorageHelper.MovieFilmPostersFileName) && isf.GetFileNames("*.jpg").Length > 0)
{
downloadFiles = false;
}
}
if (downloadFiles)
{
AsyncWebClient awc = new AsyncWebClient();
HashSet <string> newPosters = new HashSet <string>();
foreach (var item in data)
{
string filename = Path.GetFileName((string)item.Value);
newPosters.Add(filename);
string localPath = String.Format("{0}\\{1}", folder, filename);
if (!isf.FileExists(localPath))
{
await awc.DownloadFileAsync((string)item.Value, filename, folder);
}
}
HashSet <string> allPosters = new HashSet <string>(isf.GetFileNames(String.Format("{0}\\*.*", folder)));
allPosters.ExceptWith(newPosters);
foreach (var file in allPosters)
{
try
{
isf.DeleteFile(file);
}
catch { }
}
allPosters.ExceptWith(newPosters);
foreach (var file in allPosters)
{
try
{
isf.DeleteFile(file);
}
catch { }
}
}
}
public DateTime GetReleaseDate()
{
if (String.IsNullOrEmpty(this.film_url))
{
return(DateTime.MinValue);
}
string url = this.film_url.Replace("cineworld.co.uk/", "cineworld.co.uk/mobile/");
string day = null;
string month = null;
string year = null;
AsyncWebClient awc = new AsyncWebClient();
string htmlData = null;
while (true)
{
try
{
Task <string> tFilmData = awc.GetStringAsync(url);
tFilmData.Wait();
if (!tFilmData.IsCanceled && tFilmData.Result != null)
{
htmlData = tFilmData.Result;
break;
}
}
catch { }
}
if (htmlData != null)
{
using (StringReader sr = new StringReader(htmlData.ToLower()))
{
string line = null;
while ((line = sr.ReadLine()) != null)
{
if (line.IndexOf("release date") > -1)
{
char[] aSplit = { ' ' };
string strippedData = Regex.Replace(line, @"<(.|\n)*?>", string.Empty);
string[] parts = strippedData.Split(aSplit, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length < 5)
{
return(DateTime.MinValue);
}
day = parts[parts.Length - 3];
month = parts[parts.Length - 2];
year = parts[parts.Length - 1];
break;
}
}
}
}
return(year == null ? DateTime.MinValue : DateTime.Parse(string.Format("{0} {1} {2}", day, month, year)));
}
