public static async Task<trackInfo> getInfo(string artistName, string trackName, string username = "")
{
RequestParameters rParams = new RequestParameters("track.getinfo");
rParams.Add("artist", artistName);
rParams.Add("track", trackName);
if (!string.IsNullOrEmpty(username))
rParams.Add("username", username);
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
trackInfo track = new trackInfo(returnedXml.Element("lfm").Element("track"));
return track;
}
else if (Request.CheckStatus(returnedXml) == 6) // Track not found
{
// Trying with autocorrect
rParams.Add("autocorrect", "1");
returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
trackInfo track = new trackInfo(returnedXml.Element("lfm").Element("track"));
return track;
}
else
throw new LastFmAPIException(returnedXml);
}
else
throw new LastFmAPIException(returnedXml);
}
public async void Authentication()
{
var sortedParams = new Dictionary<string, string>();
sortedParams = authParams.OrderBy(param => param.Key)
.ToDictionary(param => param.Key, param => param.Value);
//var sortedParams = authParams;
var builder = new StringBuilder();
foreach (var param in sortedParams)
{
builder.Append(param.Key).Append(param.Value);
}
var requestParameters = new RequestParameters("auth");
requestParameters.Add("username", "huesername");
requestParameters.Add("password", "huyasword");
requestParameters.Add("test", "huest");
var paramSignature = new ParamsSignature();
var x = paramSignature.MakeSignature(requestParameters);
builder.Append(secret);
var signature = MD5CryptoServiceProvider.GetMd5String(builder.ToString());
authParams.Add("api_sig", signature);
authParams.Add("format", "JSON");
var request = new Request();
string response = await request.MakeRequest(authParams);
}
public static async Task<tagInfo> getInfo(string tagName, string lang = "en")
{
RequestParameters rParams = new RequestParameters("tag.getinfo");
rParams.Add("tag", tagName);
rParams.Add("lang", lang);
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
tagInfo retTag = new tagInfo(returnedXml.Element("lfm").Element("tag"));
return retTag;
}
else
throw new LastFmAPIException(returnedXml);
}
/// <summary>
/// artist.getTopAlbums last.fm api function
/// </summary>
/// <param name="artistName">Name of the artist to find top albums for</param>
/// <param name="page">Page number to return content of</param>
/// <param name="limit">Maximum number of elements per page</param>
/// <returns>List of top albums</returns>
public static async Task<List<albumInfo>> getTopAlbums(string artistName, int page = 0, int limit = 0)
{
RequestParameters rParams = new RequestParameters("artist.getTopAlbums");
rParams.Add("artist", artistName);
rParams.Add("page", page.ToString());
rParams.Add("limit", limit.ToString());
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
List<albumInfo> albums = new List<albumInfo>((from item in returnedXml.Descendants("topalbums").Elements() select new albumInfo(item)));
return albums;
}
else
throw new LastFmAPIException(returnedXml);
}
/// <summary>
/// album.getInfo last.fm API function
/// </summary>
/// <param name="artistName">Artist name</param>
/// <param name="albumName">Album name</param>
/// <param name="username">Username (if used, user's playcount and whether he loved this track or not included)</param>
/// <param name="lang">Language to return response in</param>
/// <returns>Album information</returns>
public static async Task<albumInfo> getInfo(string artistName, string albumName, string username = "", string lang = "en")
{
RequestParameters rParams = new RequestParameters("album.getinfo");
rParams.Add("artist", artistName);
rParams.Add("album", albumName);
if (!string.IsNullOrEmpty(username))
rParams.Add("username", username);
rParams.Add("lang", lang);
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
albumInfo album = new albumInfo(returnedXml.Element("lfm").Element("album"));
return album;
}
else
throw new LastFmAPIException(returnedXml);
}
public static async Task<List<trackInfo>> getRecentTracks(String user, int limit = 50, int page = 1)
{
RequestParameters rParams = new RequestParameters("user.getRecentTracks");
rParams.Add("user", user);
rParams.Add("limit", limit.ToString());
rParams.Add("page", page.ToString());
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
int totalPagesAttr = Int32.Parse(returnedXml.Element("lfm").Element("recenttracks").Attribute("totalPages").Value);
if (page > totalPagesAttr)
throw new ArgumentOutOfRangeException("page", "Page number is greater than total amount of pages");
List<trackInfo> tracks = new List<trackInfo>(from item in returnedXml.Element("lfm").Element("recenttracks").Elements() select new trackInfo(item));
return tracks;
}
else
throw new LastFmAPIException(Request.GetErrorMessage(returnedXml), Request.CheckStatus(returnedXml));
}
public static async Task<List<artistInfo>> getRecommendedArtists(int page = 1, int limit = 50)
{
RequestParameters rParams = new RequestParameters("user.getRecommendedArtists");
rParams.Add("limit", limit.ToString());
rParams.Add("page", page.ToString());
rParams.Add("sk", Session.CurrentSession.SessionKey);
XDocument returnedXml = await Request.MakeRequest(rParams, true);
if (Request.CheckStatus(returnedXml) == 0)
{
int totalPagesAttr = Int32.Parse(returnedXml.Element("lfm").Element("recommendations").Attribute("totalPages").Value);
if (page > totalPagesAttr)
throw new ArgumentOutOfRangeException("page", "Page number is greater than total amount of pages");
List<artistInfo> artists = new List<artistInfo>(from item in returnedXml.Element("lfm").Element("recommendations").Elements() select new artistInfo(item));
return artists;
}
else
throw new LastFmAPIException(returnedXml);
}
public static async Task<UserInfo> getInfo(string user)
{
RequestParameters rParams = new RequestParameters("user.getinfo");
rParams.Add("user", user);
XDocument ReturnedXML = await Request.MakeRequest(rParams);
if (Request.CheckStatus(ReturnedXML) == 0)
return new UserInfo(ReturnedXML.Element("lfm").Element("user"));
else
throw new LastFmAPIException(Request.GetErrorMessage(ReturnedXML), Request.CheckStatus(ReturnedXML));
}
public static async Task<Session> authorize(string username, string password)
{
string password_hash = MD5CryptoServiceProvider.GetMd5String(password);
string authToken = MD5CryptoServiceProvider.GetMd5String(username.ToLower() + password_hash);
RequestParameters rParams = new RequestParameters("auth.getMobileSession");
rParams.Add("username", username);
rParams.Add("authToken", authToken);
XDocument ReturnedXML = await Request.MakeRequest(rParams, true);
if (Request.CheckStatus(ReturnedXML) == 0)
{
string skey = (from el in ReturnedXML.Descendants("key") select el).First().Value;
string user = (from el in ReturnedXML.Descendants("name") select el).First().Value;
return new Session(skey, user);
}
else
{
MessageBox.Show("Sorry, something went wrong. Probably, you specified wrong password or username. Please, try again");
return null;
}
}
public static async Task<List<artistInfo>> getTopArtists(int page = 1, int limit = 50)
{
RequestParameters rParams = new RequestParameters("chart.getTopArtists");
rParams.Add("page", page.ToString());
rParams.Add("limit", limit.ToString());
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
List<artistInfo> artists = new List<artistInfo>(from item in returnedXml.Descendants("artists").Elements()
select new artistInfo(item));
int totalResults = Int32.Parse(returnedXml.Element("lfm").Element("artists").Attribute("total").Value);
int currentPage = Int32.Parse(returnedXml.Element("lfm").Element("artists").Attribute("page").Value);
int itemsPerPage = Int32.Parse(returnedXml.Element("lfm").Element("artists").Attribute("perPage").Value);
// chart.getTopArtists if passed page number is more than the overall number of pages does load the last page
if (currentPage != page)
throw new IndexOutOfRangeException("No more pages to show");
return artists;
}
else
throw new LastFmAPIException(returnedXml);
}
/// <summary>
/// artist.getInfo last.fm api function
/// </summary>
/// <param name="artistName">Artist name</param>
/// <returns>Artist info object, containing artist desription</returns>
public static async Task<artistInfo> getInfo(string artistName)
{
RequestParameters rParams = new RequestParameters("artist.getinfo");
rParams.Add("artist", artistName);
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
artistInfo artist = new artistInfo(returnedXml.Element("lfm").Element("artist"));
return artist;
}
else
throw new LastFmAPIException(returnedXml);
}
/// <summary>
/// Compiles all the arguments in one request, sends it to the last.fm and returns response xml
/// </summary>
/// <param name="rParams">List of parameters</param>
/// <param name="toSign">Indicates, whether request should be signed or not</param>
/// <returns>XDocument, containing the whole response from the server</returns>
public async static Task<XDocument> MakeRequest(RequestParameters rParams, bool toSign = false)
{
try { rParams.Add("api_key", secret_data.api_key); }
catch (ArgumentException) { }
if (toSign == true)
{
StringBuilder sb = new StringBuilder();
//All arguments must be sorted in signature
//Because silverlight doesn't support SortedDictionary, I used Linq instead
var sortedList = from q in rParams orderby q.Key ascending select q.Key;
foreach (string key in sortedList)
sb.Append(key.ToString() + rParams[key]);
sb.Append(secret_data.secret);
rParams.Add("api_sig", MD5CryptoServiceProvider.GetMd5String(sb.ToString()));
}
string request_string = rParams.ToString();
WebClient client = new WebClient();
client.Headers["User-Agent"] = "wp.fm";
client.Headers["Content-Type"] = "application/x-www-form-urlencoded";
client.Headers["Accept-Charset"] = "utf-8";
client.Encoding = Encoding.UTF8;
byte[] byteArray = rParams.ToBytes();
Stream toReadFrom;
try
{
string response = "response string not set";
response = await client.UploadStringTaskAsync(new Uri(root_url), "POST", rParams.ToString());
toReadFrom = new MemoryStream(Encoding.UTF8.GetBytes(response));
}
catch (WebException ex)
{
toReadFrom = ((HttpWebResponse)ex.Response).GetResponseStream();
}
return XDocument.Load(new XmlSanitizingStream(toReadFrom));
}
public static async Task<List<tagInfo>> search(string tagName, int page = 0, int limit = 30)
{
RequestParameters rParams = new RequestParameters("tag.search");
rParams.Add("tag", tagName);
rParams.Add("limit", limit.ToString());
rParams.Add("page", page.ToString());
XDocument returnedXml = await Request.MakeRequest(rParams);
if (Request.CheckStatus(returnedXml) == 0)
{
List<tagInfo> tags = new List<tagInfo>((from item in returnedXml.Descendants("tagmatches").Elements() select new tagInfo(item)));
XNamespace opensearch = @"http://a9.com/-/spec/opensearch/1.1/";
IEnumerable<XElement> opensearch_ = from el in returnedXml.Element("lfm").Element("results").Elements()
where el.Name.Namespace == opensearch
select el;
int totalResults = Int32.Parse((from el in opensearch_ where el.Name.LocalName == "totalResults" select el.Value).First());
int startIndex = Int32.Parse((from el in opensearch_ where el.Name.LocalName == "startIndex" select el.Value).First());
int itemsPerPage = Int32.Parse((from el in opensearch_ where el.Name.LocalName == "itemsPerPage" select el.Value).First());
if (totalResults - startIndex < 0)
throw new IndexOutOfRangeException("Page being shown is the first page");
return tags;
}
else
throw new LastFmAPIException(returnedXml);
}
public static async void updateNowPlaying(string artistName, string trackName, string albumName = null)
{
if (!Session.CanUseCurrentSession())
MessageBox.Show("This service requires authentication");
RequestParameters rParams = new RequestParameters("track.updateNowPlaying");
rParams.Add("artist", artistName);
rParams.Add("track", trackName);
rParams.Add("sk", Session.CurrentSession.SessionKey);
if (!String.IsNullOrEmpty(albumName))
rParams.Add("album", albumName);
XDocument returnedXml = await Request.MakeRequest(rParams, true);
if (Request.CheckStatus(returnedXml) != 0)
throw new LastFmAPIException(returnedXml);
}
/// <summary>Initializes Analytics parameter list.</summary>
protected override void InitParameters()
{
base.InitParameters();
RequestParameters.Add(
"alt", new Google.Apis.Discovery.Parameter
{
Name = "alt",
IsRequired = false,
ParameterType = "query",
DefaultValue = "atom",
Pattern = null,
});
RequestParameters.Add(
"fields", new Google.Apis.Discovery.Parameter
{
Name = "fields",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"key", new Google.Apis.Discovery.Parameter
{
Name = "key",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"oauth_token", new Google.Apis.Discovery.Parameter
{
Name = "oauth_token",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"prettyPrint", new Google.Apis.Discovery.Parameter
{
Name = "prettyPrint",
IsRequired = false,
ParameterType = "query",
DefaultValue = "false",
Pattern = null,
});
RequestParameters.Add(
"quotaUser", new Google.Apis.Discovery.Parameter
{
Name = "quotaUser",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"userIp", new Google.Apis.Discovery.Parameter
{
Name = "userIp",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
}
public static async void scrobble(List<trackInfo> tracks)
{
if (!Session.CanUseCurrentSession())
MessageBox.Show("This service requires authentication");
if (tracks.Count > 50)
throw new ArgumentOutOfRangeException("tracks", "Number of elements in the list must not exceed 50");
RequestParameters rParams = new RequestParameters("track.scrobble");
rParams.Add("sk", Session.CurrentSession.SessionKey);
for (int i = 0; i < tracks.Count; ++i)
{
trackInfo track = tracks[i];
if (track != null && track.name != null && track.album != null && track.date != null)
{
rParams.Add("artist[" + i + "]", track.artist.name);
rParams.Add("track[" + i + "]", track.name);
int timestamp = (int)(track.date.ToUniversalTime() - new DateTime(1970, 1, 1)).TotalSeconds;
rParams.Add("timestamp[" + i + "]", timestamp.ToString());
}
}
XDocument returnedXml = await Request.MakeRequest(rParams, true);
if (Request.CheckStatus(returnedXml) != 0)
throw new LastFmAPIException(returnedXml);
}
/// <summary>Initializes Get parameter list.</summary>
protected override void InitParameters()
{
base.InitParameters();
RequestParameters.Add(
"ids", new Google.Apis.Discovery.Parameter
{
Name = "ids",
IsRequired = true,
ParameterType = "query",
DefaultValue = null,
Pattern = @"ga:[0-9]+",
});
RequestParameters.Add(
"start-date", new Google.Apis.Discovery.Parameter
{
Name = "start-date",
IsRequired = true,
ParameterType = "query",
DefaultValue = null,
Pattern = @"[0-9]{4}-[0-9]{2}-[0-9]{2}",
});
RequestParameters.Add(
"end-date", new Google.Apis.Discovery.Parameter
{
Name = "end-date",
IsRequired = true,
ParameterType = "query",
DefaultValue = null,
Pattern = @"[0-9]{4}-[0-9]{2}-[0-9]{2}",
});
RequestParameters.Add(
"metrics", new Google.Apis.Discovery.Parameter
{
Name = "metrics",
IsRequired = true,
ParameterType = "query",
DefaultValue = null,
Pattern = @"ga:.+",
});
RequestParameters.Add(
"dimensions", new Google.Apis.Discovery.Parameter
{
Name = "dimensions",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = @"(ga:.+)?",
});
RequestParameters.Add(
"filters", new Google.Apis.Discovery.Parameter
{
Name = "filters",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = @"ga:.+",
});
RequestParameters.Add(
"max-results", new Google.Apis.Discovery.Parameter
{
Name = "max-results",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"segment", new Google.Apis.Discovery.Parameter
{
Name = "segment",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"sort", new Google.Apis.Discovery.Parameter
{
Name = "sort",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = @"(-)?ga:.+",
});
RequestParameters.Add(
"start-index", new Google.Apis.Discovery.Parameter
{
Name = "start-index",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
}
/// <summary>
/// Sends scrobble request to the server
/// </summary>
/// <param name="artistName"> Artist who plays the track </param>
/// <param name="trackName"> Name of the track </param>
/// <param name="timestamp"> DateTime object representing when track was played </param>
public static async void scrobble(string artistName, string trackName, DateTime timestamp = default(DateTime))
{
if (!Session.CanUseCurrentSession())
MessageBox.Show("This service requires authentication");
int timeStamp;
if (timestamp != default(DateTime) && timestamp != null)
timeStamp = (int)(timestamp.ToUniversalTime() - new DateTime(1970, 1, 1)).TotalSeconds;
else
timeStamp = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
RequestParameters rParams = new RequestParameters("track.scrobble");
rParams.Add("artist", artistName);
rParams.Add("track", trackName);
rParams.Add("timestamp", timeStamp.ToString());
rParams.Add("sk", Session.CurrentSession.SessionKey);
XDocument returnedXml = await Request.MakeRequest(rParams, true);
if (Request.CheckStatus(returnedXml) != 0)
throw new LastFmAPIException(returnedXml);
}
/// <summary>Initializes List parameter list.</summary>
protected override void InitParameters()
{
base.InitParameters();
RequestParameters.Add("projectId", new Google.Apis.Discovery.Parameter
{
Name = "projectId",
IsRequired = true,
ParameterType = "path",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("endTime", new Google.Apis.Discovery.Parameter
{
Name = "endTime",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("filter", new Google.Apis.Discovery.Parameter
{
Name = "filter",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("orderBy", new Google.Apis.Discovery.Parameter
{
Name = "orderBy",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("pageSize", new Google.Apis.Discovery.Parameter
{
Name = "pageSize",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("pageToken", new Google.Apis.Discovery.Parameter
{
Name = "pageToken",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("startTime", new Google.Apis.Discovery.Parameter
{
Name = "startTime",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("view", new Google.Apis.Discovery.Parameter
{
Name = "view",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
}
/// <summary>Initializes Search parameter list.</summary>
protected override void InitParameters()
{
base.InitParameters();
RequestParameters.Add(
"prefix", new Google.Apis.Discovery.Parameter
{
Name = "prefix",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"query", new Google.Apis.Discovery.Parameter
{
Name = "query",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"types", new Google.Apis.Discovery.Parameter
{
Name = "types",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"indent", new Google.Apis.Discovery.Parameter
{
Name = "indent",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"languages", new Google.Apis.Discovery.Parameter
{
Name = "languages",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"ids", new Google.Apis.Discovery.Parameter
{
Name = "ids",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"limit", new Google.Apis.Discovery.Parameter
{
Name = "limit",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
}
/// <summary>
/// Evaluates the specified template
/// </summary>
/// <param name="template"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public static IWebResults evaluateTemplate(string template, Dictionary<string, object> arguments)
{
if (null == template)
template = "/DefaultTemplate/headerfooter.ochf";
FunctionCallContext functionCallContext = FunctionCallContext.GetCurrentContext();
IFileContainer templateEngineFileContainer = functionCallContext.ScopeWrapper.FileHandlerFactoryLocator.FileSystemResolver.ResolveFile("/System/TemplateEngine");
ITemplateEngine templateEngineWebHandler = (ITemplateEngine)templateEngineFileContainer.WebHandler;
RequestParameters requestParameters = new RequestParameters();
if (null != arguments)
foreach (KeyValuePair<string, object> requestParameter in (Dictionary<string, object>)arguments)
requestParameters.Add(requestParameter.Key, requestParameter.Value.ToString());
IWebConnection webConnection = new BlockingShellWebConnection(
functionCallContext.WebConnection,
functionCallContext.WebConnection.Session,
template,
requestParameters,
null,
null,
functionCallContext.WebConnection.CookiesFromBrowser,
FunctionCaller.CallingFrom);
return templateEngineWebHandler.Evaluate(webConnection, template);
}
/// <summary>Initializes FirebaseML parameter list.</summary>
protected override void InitParameters()
{
base.InitParameters();
RequestParameters.Add(
"$.xgafv", new Google.Apis.Discovery.Parameter
{
Name = "$.xgafv",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"access_token", new Google.Apis.Discovery.Parameter
{
Name = "access_token",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"alt", new Google.Apis.Discovery.Parameter
{
Name = "alt",
IsRequired = false,
ParameterType = "query",
DefaultValue = "json",
Pattern = null,
});
RequestParameters.Add(
"callback", new Google.Apis.Discovery.Parameter
{
Name = "callback",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"fields", new Google.Apis.Discovery.Parameter
{
Name = "fields",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"key", new Google.Apis.Discovery.Parameter
{
Name = "key",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"oauth_token", new Google.Apis.Discovery.Parameter
{
Name = "oauth_token",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"prettyPrint", new Google.Apis.Discovery.Parameter
{
Name = "prettyPrint",
IsRequired = false,
ParameterType = "query",
DefaultValue = "true",
Pattern = null,
});
RequestParameters.Add(
"quotaUser", new Google.Apis.Discovery.Parameter
{
Name = "quotaUser",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"uploadType", new Google.Apis.Discovery.Parameter
{
Name = "uploadType",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add(
"upload_protocol", new Google.Apis.Discovery.Parameter
{
Name = "upload_protocol",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
}
/// <summary>
/// Assists in letting server-side javascript call into the server
/// </summary>
/// <param name="webMethodString"></param>
/// <param name="url"></param>
/// <param name="contentType"></param>
/// <param name="postArguments"></param>
/// <param name="bypassJavascript"></param>
/// <returns></returns>
public static object Shell(
string webMethodString,
string url,
string contentType,
object postArguments,
Dictionary<string, object> options)
{
FunctionCallContext functionCallContext = FunctionCallContext.GetCurrentContext();
WebMethod webMethod = Enum<WebMethod>.Parse(webMethodString);
byte[] content;
if (null != postArguments)
{
if (postArguments is Dictionary<string, object>)
{
RequestParameters requestParameters = new RequestParameters();
foreach (KeyValuePair<string, object> requestParameter in (Dictionary<string, object>)postArguments)
requestParameters.Add(requestParameter.Key, requestParameter.Value.ToString());
content = requestParameters.ToBytes();
}
else
content = Encoding.UTF8.GetBytes(postArguments.ToString());
}
else
content = new byte[0];
IWebResults shellResult = functionCallContext.WebConnection.ShellTo(
webMethod,
url,
content,
contentType,
FunctionCaller.CallingFrom,
FunctionCaller.BypassJavascript);
if (null != options)
{
object resultsAsBase64;
if (options.TryGetValue("EncodeAsBase64", out resultsAsBase64))
if (resultsAsBase64 is bool)
if ((bool)resultsAsBase64)
using (Stream contentStream = shellResult.ResultsAsStream)
{
byte[] buffer = new byte[contentStream.Length];
contentStream.Read(buffer, 0, buffer.Length);
return Convert.ToBase64String(buffer);
}
}
return ConvertWebResultToJavascript(shellResult);
}
public static async void unlove(string trackName, string artistName)
{
if (!Session.CanUseCurrentSession())
throw new UnauthorizedException("User must login to perform this action");
RequestParameters rParams = new RequestParameters("track.unlove");
rParams.Add("artist", artistName);
rParams.Add("track", trackName);
rParams.Add("sk", Session.CurrentSession.SessionKey);
XDocument returnedXml = await Request.MakeRequest(rParams, true);
if (Request.CheckStatus(returnedXml) != 0)
throw new LastFmAPIException(returnedXml);
}
/// <summary>Initializes FindInstalledAppDevices parameter list.</summary>
protected override void InitParameters()
{
base.InitParameters();
RequestParameters.Add("customer", new Google.Apis.Discovery.Parameter
{
Name = "customer",
IsRequired = true,
ParameterType = "path",
DefaultValue = null,
Pattern = @"^customers/[^/]+$",
});
RequestParameters.Add("appId", new Google.Apis.Discovery.Parameter
{
Name = "appId",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("appType", new Google.Apis.Discovery.Parameter
{
Name = "appType",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("filter", new Google.Apis.Discovery.Parameter
{
Name = "filter",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("orderBy", new Google.Apis.Discovery.Parameter
{
Name = "orderBy",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("orgUnitId", new Google.Apis.Discovery.Parameter
{
Name = "orgUnitId",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("pageSize", new Google.Apis.Discovery.Parameter
{
Name = "pageSize",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
RequestParameters.Add("pageToken", new Google.Apis.Discovery.Parameter
{
Name = "pageToken",
IsRequired = false,
ParameterType = "query",
DefaultValue = null,
Pattern = null,
});
}
