private string GetImageUrl(string baseUrl, ImageOptions options, QueryStringDictionary queryParams)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (queryParams == null)
{
throw new ArgumentNullException("queryParams");
}
if (options.ImageIndex.HasValue)
{
baseUrl += "/" + options.ImageIndex.Value;
}
queryParams.AddIfNotNull("Width", options.Width);
queryParams.AddIfNotNull("Height", options.Height);
queryParams.AddIfNotNull("MaxWidth", options.MaxWidth);
queryParams.AddIfNotNull("MaxHeight", options.MaxHeight);
queryParams.AddIfNotNull("Quality", options.Quality ?? ImageQuality);
queryParams.AddIfNotNull("Tag", options.Tag);
queryParams.AddIfNotNull("CropWhitespace", options.CropWhitespace);
queryParams.Add("EnableImageEnhancers", options.EnableImageEnhancers);
return(GetApiUrl(baseUrl, queryParams));
}
/// <summary>
/// Reports to the server that the user has stopped playing an item
/// </summary>
/// <param name="itemId">The item id.</param>
/// <param name="userId">The user id.</param>
/// <param name="positionTicks">The position ticks.</param>
/// <returns>Task{UserItemDataDto}.</returns>
/// <exception cref="System.ArgumentNullException">itemId</exception>
public void ReportPlaybackStopped(string itemId, string userId, long?positionTicks, Action <bool> onResponse)
{
if (string.IsNullOrEmpty(itemId))
{
throw new ArgumentNullException("itemId");
}
if (string.IsNullOrEmpty(userId))
{
throw new ArgumentNullException("userId");
}
if (WebSocketConnection != null && WebSocketConnection.IsOpen)
{
WebSocketConnection.Send("PlaybackStopped", itemId + "|" + (positionTicks == null ? "" : positionTicks.Value.ToString(CultureInfo.InvariantCulture)));
}
var dict = new QueryStringDictionary();
dict.AddIfNotNull("positionTicks", positionTicks);
var url = GetApiUrl("Users/" + userId + "/PlayingItems/" + itemId, dict);
_httpClient.Delete(url, x => onResponse(false));
}
/// <summary>
/// Registers the device for push notifications.
/// </summary>
/// <param name="deviceId">The device id.</param>
/// <param name="uri">The URI.</param>
/// <param name="sendTileUpdate">The send tile update.</param>
/// <param name="sendToastUpdate">The send toast update.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">deviceType
/// or
/// deviceId</exception>
public Task RegisterDeviceAsync(string deviceId, string uri, bool?sendTileUpdate = null, bool?sendToastUpdate = null)
{
if (string.IsNullOrEmpty(deviceId))
{
throw new ArgumentNullException("deviceId");
}
var dict = new QueryStringDictionary
{
{ "deviceid", deviceId },
{ "url", uri },
{ "devicetype", "WindowsPhone8" }
};
if (sendTileUpdate.HasValue)
{
dict.Add("sendlivetile", sendTileUpdate.Value);
}
if (sendToastUpdate.HasValue)
{
dict.Add("sendtoast", sendToastUpdate.Value);
}
var url = GetApiUrl("PushNotification/Devices", dict);
return(PostAsync <EmptyRequestResult>(url, new Dictionary <string, string>()));
}
public void IEnumerator_GetEnumerator_Enumerates_Over_KeyValuePairs()
{
var dictionary = new QueryStringDictionary("a=1;a=2;b=3&c=4");
var seenKeys = new HashSet <string>();
var enumerator = ((IEnumerable)dictionary).GetEnumerator();
while (enumerator.MoveNext())
{
var kvp = (KeyValuePair <string, string>)enumerator.Current;
var key = kvp.Key;
var value = kvp.Value;
Assert.IsFalse(seenKeys.Contains(key));
seenKeys.Add(key);
string expected = null;
switch (key)
{
case "a": expected = "1,2"; break;
case "b": expected = "3"; break;
case "c": expected = "4"; break;
default: Assert.Fail($"Unexpected key {key}"); break;
}
Assert.AreEqual(expected, value);
}
Assert.AreEqual(3, seenKeys.Count);
}
public void Ctor_Initialises_Properties(string queryString, bool caseSensitiveKeys, string expected)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKeys);
Assert.AreEqual(expected, dictionary.QueryString);
Assert.AreEqual(caseSensitiveKeys, dictionary.CaseSensitiveKeys);
}
/// <summary>
/// Reports playback progress to the server
/// </summary>
/// <param name="itemId">The item id.</param>
/// <param name="userId">The user id.</param>
/// <param name="positionTicks">The position ticks.</param>
/// <param name="isPaused">if set to <c>true</c> [is paused].</param>
/// <returns>Task{UserItemDataDto}.</returns>
/// <exception cref="System.ArgumentNullException">itemId</exception>
public void ReportPlaybackProgress(string itemId, string userId, long?positionTicks, bool isPaused, Action <bool> onResponse)
{
if (string.IsNullOrEmpty(itemId))
{
throw new ArgumentNullException("itemId");
}
if (string.IsNullOrEmpty(userId))
{
throw new ArgumentNullException("userId");
}
if (WebSocketConnection != null && WebSocketConnection.IsOpen)
{
WebSocketConnection.Send("PlaybackProgress", itemId + "|" + (positionTicks == null ? "" : positionTicks.Value.ToString(CultureInfo.InvariantCulture)) + "|" + isPaused.ToString().ToLower());
}
var dict = new QueryStringDictionary();
dict.AddIfNotNull("positionTicks", positionTicks);
dict.Add("isPaused", isPaused);
var url = GetApiUrl("Users/" + userId + "/PlayingItems/" + itemId + "/Progress", dict);
Post <EmptyRequestResult>(url, new Dictionary <string, string>(), x => onResponse(true), x => onResponse(false));
}
public void BuildModel_QueryStringDictionary_Can_Build_StringA_Model_With_Correct_Case()
{
var dictionary = new QueryStringDictionary("A=Abc");
var actual = _ModelBuilder.BuildModel(typeof(StringA), null, dictionary) as StringA;
Assert.AreEqual("Abc", actual.A);
}
public void GetValue_Returns_Expected_Value(string queryString, bool caseSensitiveKeys, string key, string join, string expected)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKeys);
var actual = dictionary.GetValue(key, join);
Assert.AreEqual(expected, actual);
}
public void Values_Returns_All_Values(string queryString, bool caseSensitiveKey, string[] expected)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKey);
var actual = dictionary.Values.ToArray();
Assertions.AreEqual(expected, actual);
}
public void QueryString_Index_Returns_Expected_Value(string queryString, bool caseSensitiveKey, string indexValue, string expected)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKey);
var actual = dictionary[indexValue];
Assert.AreEqual(expected, actual);
}
public void TryGetValue_Returns_Expected_Value(string queryString, bool caseSensitiveKeys, string searchKey, bool expectedReturn, string expectedValue)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKeys);
var actualReturn = dictionary.TryGetValue(searchKey, out var actualValue);
Assert.AreEqual(expectedReturn, actualReturn);
Assert.AreEqual(expectedValue, actualValue);
}
public void BuildModel_QueryStringDictionary_Uses_TypeParserResolver()
{
var dictionary = new QueryStringDictionary("A=Abc");
var resolver = new TypeParserResolver(new String_Reverse_Parser());
var actual = _ModelBuilder.BuildModel(typeof(StringA), resolver, dictionary) as StringA;
Assert.AreEqual("cbA", actual.A);
}
protected override List<BaseItem> GetCachedChildren()
{
var parms = new QueryStringDictionary { { "userId", Kernel.CurrentUser.ApiId }, {"Limit", 200} };
parms.Add("Fields", MB3ApiRepository.StandardFields.Select(f => f.ToString()));
var url = Kernel.ApiClient.GetApiUrl("Shows/Upcoming", parms);
using (var stream = Kernel.ApiClient.GetSerializedStream(url))
{
var result = Kernel.ApiClient.DeserializeFromStream<ItemsResult>(stream);
OurChildren = result.Items.Select(i => Kernel.Instance.MB3ApiRepository.GetItem(i, i.Type)).Where(i => i != null).ToList();
return OurChildren;
}
}
public void Keys_Returns_All_Keys(string queryString, bool caseSensitiveKey, string[] expectedKeys)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKey);
var actual = dictionary.Keys.ToList();
Assert.AreEqual(expectedKeys.Length, actual.Count);
foreach (var expectedKey in expectedKeys)
{
var actualIdx = actual.IndexOf(expectedKey);
Assert.AreNotEqual(-1, actualIdx, $"Cannot find {expectedKey} in Keys");
actual.RemoveAt(actualIdx);
}
}
/// <summary>
/// List of parameters for this request object.
/// </summary>
/// <returns></returns>
protected virtual QueryStringDictionary GetParameterList()
{
var parameters = new QueryStringDictionary();
if (string.IsNullOrEmpty(this.Language))
{
this.Language = "en-US";
}
parameters.Add("language", this.Language);
parameters.Add("format", this.Format.ToNullableString());
return(parameters);
}
protected string GetApiUrl(string handler, QueryStringDictionary queryString)
{
if (string.IsNullOrEmpty(handler))
{
throw new ArgumentNullException("handler");
}
if (queryString == null)
{
throw new ArgumentNullException("queryString");
}
return(queryString.GetUrl(ApiUrl + "/" + handler));
}
public void BuildModel_QueryStringDictionary_Can_Parse_All_Native_Types(string propertyName, string value, object expected, string culture)
{
using (new CultureSwap(culture)) {
var propertyInfo = typeof(AllNativeTypes).GetProperty(propertyName);
var dictionary = new QueryStringDictionary($"{propertyName}={value ?? ""}");
var model = _ModelBuilder.BuildModel(typeof(AllNativeTypes), null, dictionary) as AllNativeTypes;
var actual = propertyInfo.GetValue(model, null);
expected = DataRowParser.ConvertExpected(propertyInfo.PropertyType, expected);
Assert.AreEqual(expected, actual);
}
}
public void QueryString_GetValues_Returns_Expected_Values(string queryString, bool caseSensitiveKey, string key, string[] expected)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKey);
var actual = dictionary.GetValues(key);
if (expected == null)
{
Assert.IsNull(actual);
}
else
{
Assert.IsTrue(expected.SequenceEqual(actual));
}
}
protected override List <BaseItem> GetCachedChildren()
{
var parms = new QueryStringDictionary {
{ "userId", Kernel.CurrentUser.ApiId }, { "Limit", 200 }
};
parms.Add("Fields", MB3ApiRepository.StandardFields.Select(f => f.ToString()));
var url = Kernel.ApiClient.GetApiUrl("Shows/Upcoming", parms);
using (var stream = Kernel.ApiClient.GetSerializedStream(url))
{
var result = Kernel.ApiClient.DeserializeFromStream <ItemsResult>(stream);
OurChildren = result.Items.Select(i => Kernel.Instance.MB3ApiRepository.GetItem(i, i.Type)).Where(i => i != null).ToList();
return(OurChildren);
}
}
/// <summary>
/// Converts this object's parameters to a query string dictionary.
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static QueryStringDictionary ToDictionary(this object source)
{
var dictionary = new QueryStringDictionary();
var properties = source.GetType().GetRuntimeProperties();
foreach (var property in properties)
{
var key = property.Name.ToLower();
var value = property.GetValue(source, null);
if (!string.IsNullOrEmpty(key) && value != null)
{
dictionary.Add(key, value);
}
}
return(dictionary);
}
/// <summary>
/// Updates the device async.
/// </summary>
/// <param name="deviceId">The device id.</param>
/// <param name="sendTileUpdate">The send tile update.</param>
/// <param name="sendToastUpdate">The send toast update.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">deviceId</exception>
public Task UpdateDeviceAsync(string deviceId, bool?sendTileUpdate = null, bool?sendToastUpdate = null)
{
if (string.IsNullOrEmpty(deviceId))
{
throw new ArgumentNullException("deviceId");
}
var dict = new QueryStringDictionary();
if (sendTileUpdate.HasValue)
{
dict.Add("sendlivetile", sendTileUpdate.Value);
}
if (sendToastUpdate.HasValue)
{
dict.Add("sendtoast", sendToastUpdate.Value);
}
var url = GetApiUrl("PushNotification/Devices/" + deviceId, dict);
return(PostAsync <EmptyRequestResult>(url, new Dictionary <string, string>()));
}
/// <summary>
/// Registers the device for push notifications.
/// </summary>
/// <param name="deviceId">The device id.</param>
/// <param name="uri">The URI.</param>
/// <param name="sendTileUpdate">The send tile update.</param>
/// <param name="sendToastUpdate">The send toast update.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">deviceType
/// or
/// deviceId</exception>
public Task RegisterDeviceAsync(string deviceId, string uri, bool? sendTileUpdate = null, bool? sendToastUpdate = null)
{
if (string.IsNullOrEmpty(deviceId))
{
throw new ArgumentNullException("deviceId");
}
var dict = new QueryStringDictionary
{
{"deviceid", deviceId},
{"url", uri},
{"devicetype", "WindowsPhone8"}
};
if (sendTileUpdate.HasValue)
dict.Add("sendlivetile", sendTileUpdate.Value);
if (sendToastUpdate.HasValue)
dict.Add("sendtoast", sendToastUpdate.Value);
var url = GetApiUrl("PushNotification/Devices", dict);
return PostAsync<EmptyRequestResult>(url, new Dictionary<string, string>());
}
/// <summary>
/// Updates the device async.
/// </summary>
/// <param name="deviceId">The device id.</param>
/// <param name="sendTileUpdate">The send tile update.</param>
/// <param name="sendToastUpdate">The send toast update.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">deviceId</exception>
public Task UpdateDeviceAsync(string deviceId, bool? sendTileUpdate = null, bool? sendToastUpdate = null)
{
if (string.IsNullOrEmpty(deviceId))
{
throw new ArgumentNullException("deviceId");
}
var dict = new QueryStringDictionary();
if (sendTileUpdate.HasValue)
dict.Add("sendlivetile", sendTileUpdate.Value);
if (sendToastUpdate.HasValue)
dict.Add("sendtoast", sendToastUpdate.Value);
var url = GetApiUrl("PushNotification/Devices/" + deviceId, dict);
return PostAsync<EmptyRequestResult>(url, new Dictionary<string, string>());
}
public void JoinValue_Defaults_To_Comma()
{
var actual = QueryStringDictionary.JoinValue(new string[] { "a", "b" });
Assert.AreEqual("a,b", actual);
}
public void JoinValue_Returns_Expected_Value(string[] value, string join, string expected)
{
var actual = QueryStringDictionary.JoinValue(value, join);
Assert.AreEqual(expected, actual);
}
public void JoinValue_Throws_If_Passed_Null_Join()
{
QueryStringDictionary.JoinValue(new string[] { "1" }, null);
}
public void GetValue_Defaults_To_Comma()
{
var dictionary = new QueryStringDictionary("a=1&a=2");
Assert.AreEqual("1,2", dictionary.GetValue("a"));
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="modelType"></param>
/// <param name="typeParserResolver"></param>
/// <param name="values"></param>
/// <returns></returns>
public object BuildModel(Type modelType, TypeParserResolver typeParserResolver, QueryStringDictionary values)
{
if (modelType == null)
{
throw new ArgumentNullException(nameof(modelType));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
var result = Activator.CreateInstance(modelType);
foreach (var propertyInfo in modelType.GetProperties())
{
if (values.ContainsKey(propertyInfo.Name))
{
var valueText = values.GetValue(propertyInfo.Name);
var parsedValue = Parser.ParseType(
propertyInfo.PropertyType,
valueText,
typeParserResolver
);
propertyInfo.SetValue(result, parsedValue);
}
}
return(result);
}
public void GetValue_Throws_If_Passed_Null_Join()
{
var dictionary = new QueryStringDictionary("a=1");
dictionary.GetValue("a", null);
}
public void Ctor_Defaults_To_Case_Sensitive_Keys()
{
var dictionary = new QueryStringDictionary("a=1");
Assert.IsNull(dictionary["A"]);
}
public void ContainsKey_Returns_Expected_Value(string queryString, bool caseSensitiveKeys, string searchKey, bool expected)
{
var dictionary = new QueryStringDictionary(queryString, caseSensitiveKeys);
Assert.AreEqual(expected, dictionary.ContainsKey(searchKey));
}
public void Count_Returns_The_Number_Of_Keys_Correctly(string queryString, int expected)
{
var dictionary = new QueryStringDictionary(queryString);
Assert.AreEqual(expected, dictionary.Count);
}
