/// <summary>
/// Processes a command throwing a <see cref="LimeException"/> in case of <see cref="CommandStatus.Failure"/> status.
/// </summary>
public static Task <Command> ProcessCommandOrThrowAsync <TRequestResource>(
this ICommandProcessor channel,
CommandMethod method,
LimeUri uri,
TRequestResource resource,
CancellationToken cancellationToken,
Node from = null,
Node to = null,
Node pp = null,
IDictionary <string, string> metadata = null)
where TRequestResource : Document
{
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
return(ProcessCommandOrThrowAsync(
channel,
new Command()
{
From = from,
To = to,
Pp = pp,
Method = method,
Uri = uri,
Resource = resource,
Metadata = metadata
},
cancellationToken));
}
/// <summary>
/// Gets a resource from the specified URI.
/// </summary>
public static Task <TResource> GetResourceAsync <TResource>(
this ICommandProcessor channel,
LimeUri uri,
CancellationToken cancellationToken,
Node from = null,
Node to = null,
Node pp = null,
IDictionary <string, string> metadata = null)
where TResource : Document
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
return(ProcessCommandWithResponseResourceAsync <TResource>(
channel,
CommandMethod.Get,
uri,
cancellationToken,
from,
to,
pp,
metadata));
}
/// <summary>
/// Observes a the resource value in the specified URI.
/// </summary>
public static Task ObserveResourceAsync <TRequestResource>(
this ICommandProcessor channel,
LimeUri uri,
TRequestResource resource,
CancellationToken cancellationToken,
Node from = null,
Node to = null,
Node pp = null,
IDictionary <string, string> metadata = null)
where TRequestResource : Document
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
return(ProcessCommandOrThrowAsync(
channel,
CommandMethod.Observe,
uri,
resource,
cancellationToken,
from,
to,
pp,
metadata));
}
/// <summary>
/// Processes a command throwing a <see cref="LimeException"/> in case of <see cref="CommandStatus.Failure"/> status and returns the response resource.
/// </summary>
public static Task <TResponseResource> ProcessCommandWithResponseResourceAsync <TRequestResource, TResponseResource>(
this ICommandProcessor channel,
CommandMethod method,
LimeUri uri,
TRequestResource resource,
CancellationToken cancellationToken,
Node from = null,
Node to = null,
Node pp = null,
IDictionary <string, string> metadata = null)
where TRequestResource : Document
where TResponseResource : Document
{
return(ProcessCommandWithResponseResourceAsync <TResponseResource>(
channel,
new Command()
{
From = from,
To = to,
Pp = pp,
Method = method,
Uri = uri,
Resource = resource,
Metadata = metadata
},
cancellationToken));
}
/// <summary>
/// Composes a command envelope with a
/// delete method for the specified resource.
/// </summary>
/// <param name="channel">The channel.</param>
/// <param name="uri">The resource uri.</param>
/// <param name="from">The originator to be used in the command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">channel</exception>
/// <exception cref="LimeException">Returns an exception with the failure reason</exception>
public static async Task DeleteResourceAsync(this ICommandChannel channel, LimeUri uri, Node from, CancellationToken cancellationToken)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
var requestCommand = new Command
{
From = from,
Method = CommandMethod.Delete,
Uri = uri
};
var responseCommand = await channel.ProcessCommandAsync(requestCommand, cancellationToken).ConfigureAwait(false);
if (responseCommand.Status != CommandStatus.Success)
{
if (responseCommand.Reason != null)
{
throw new LimeException(responseCommand.Reason.Code, responseCommand.Reason.Description);
}
throw new InvalidOperationException("An invalid command response was received");
}
}
public async Task ReceiveCommandAsync_PingCommandReceivedAndAutoReplyPingsFalse_DoNotSendsPingCommandToTransport()
{
var ping = Dummy.CreatePing();
var command = Dummy.CreateCommand(ping);
command.Uri = LimeUri.Parse(UriTemplates.PING);
var cancellationToken = Dummy.CreateCancellationToken();
var tcs = new TaskCompletionSource <Envelope>();
_transport
.SetupSequence(t => t.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <Envelope>(command))
.Returns(tcs.Task);
var target = GetTarget(state: SessionState.Established, autoReplyPings: false);
var actual = await target.ReceiveCommandAsync(cancellationToken);
actual.ShouldBe(command);
_transport.Verify(
t => t.SendAsync(It.Is <Command>(
c => c.Id == command.Id &&
c.To.Equals(command.From) &&
c.Resource is Ping &&
c.Status == CommandStatus.Success),
It.IsAny <CancellationToken>()),
Times.Never());
}
public void Parse_NullString_ThrowsArgumentNullException()
{
string path = null;
Action action = () => LimeUri.Parse(path);
action.ShouldThrow <ArgumentNullException>();
}
public void Parse_InvalidSchemeAbsoluteString_ThrowsArgumentException()
{
var absolutePath = "http://[email protected]/presence";
Action action = () => LimeUri.Parse(absolutePath);
action.ShouldThrow <ArgumentException>();
}
private Task SetPresenceAsync()
{
return(_clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.PRESENCE),
Presence,
_receiveTimeout.ToCancellationToken()));
}
public async Task ReceiveCommandAsync_PingCommandAbsoluteUriReceivedAndAutoReplyPingsTrue_SendsPingCommandToTransport()
{
var ping = Dummy.CreatePing();
var command = Dummy.CreateCommand(ping);
command.Uri = LimeUri.Parse(LimeUri.Parse(UriTemplates.PING).ToUri(command.From).ToString());
var cancellationToken = Dummy.CreateCancellationToken();
var tcs = new TaskCompletionSource <Envelope>();
_transport
.SetupSequence(t => t.ReceiveAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <Envelope>(command))
.Returns(tcs.Task);
var target = GetTarget(state: SessionState.Established, autoReplyPings: true);
await Task.Delay(250);
_transport.Verify(
t => t.SendAsync(It.Is <Command>(
c => c.Id == command.Id &&
c.To.Equals(command.From) &&
c.Resource.GetMediaType().ToString().Equals(Ping.MIME_TYPE, StringComparison.OrdinalIgnoreCase) &&
c.Status == CommandStatus.Success),
It.IsAny <CancellationToken>()),
Times.Once());
}
public void Parse_InvalidRelativeString_ThrowsArgumentException()
{
var resourceName = Dummy.CreateRandomString(10);
var invalidPath = string.Format("\\{0}", resourceName);
Action action = () => LimeUri.Parse(invalidPath);
action.ShouldThrow <ArgumentException>();
}
public void ToUri_RelativeInstance_ThrowsInvalidOperationException()
{
var resourceName = DataUtil.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var limeUri = LimeUri.Parse(relativePath);
// Act
var uri = limeUri.ToUri();
}
public void Parse_ValidRelativeString_ReturnsInstance()
{
var resourceName = Dummy.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var actual = LimeUri.Parse(relativePath);
actual.Path.ShouldNotBe(null);
actual.Path.ShouldBe(relativePath);
actual.IsRelative.ShouldBe(true);
}
public Task <Command> GetContactsAsync(CancellationToken cancellationToken)
{
var rosterCommand = new Command
{
Method = CommandMethod.Get,
Uri = LimeUri.Parse(UriTemplates.CONTACTS)
};
return(Channel.ProcessCommandAsync(rosterCommand, cancellationToken));
}
public void ToUriIdentity_AbsoluteInstance_ThrowsInvalidOperationException()
{
var identity = DataUtil.CreateIdentity();
var resourceName = DataUtil.CreateRandomString(10);
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, resourceName);
var limeUri = LimeUri.Parse(absolutePath);
// Act
var uri = limeUri.ToUri(identity);
}
private async void Contacts_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (!ModernUIHelper.IsInDesignMode)
{
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
{
var addedContacts = e.NewItems.Cast <ContactViewModel>();
var cancellationToken = _receiveTimeout.ToCancellationToken();
foreach (var contactViewModel in addedContacts)
{
try
{
await base.ExecuteAsync(async() =>
{
var identityPresence = await _clientChannel.GetResourceAsync <Presence>(
LimeUri.Parse(UriTemplates.PRESENCE),
new Node()
{
Name = contactViewModel.Contact.Identity.Name,
Domain = contactViewModel.Contact.Identity.Domain
},
cancellationToken);
if (identityPresence.Instances != null &&
identityPresence.Instances.Any())
{
var presence = await _clientChannel.GetResourceAsync <Presence>(
LimeUri.Parse(UriTemplates.PRESENCE),
new Node()
{
Name = contactViewModel.Contact.Identity.Name,
Domain = contactViewModel.Contact.Identity.Domain,
Instance = identityPresence.Instances[0]
},
cancellationToken);
contactViewModel.Presence = presence;
}
});
}
catch (LimeException ex)
{
ErrorMessage = ex.Message;
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
break;
}
}
}
}
}
public Task <Command> SetContactsAsync(Contact contact, CancellationToken cancellationToken)
{
var contactCommand = new Command
{
Method = CommandMethod.Set,
Uri = LimeUri.Parse(UriTemplates.CONTACTS),
Resource = contact
};
return(Channel.ProcessCommandAsync(contactCommand, cancellationToken));
}
public void ToUri_RelativeInstance_ThrowsInvalidOperationException()
{
var resourceName = Dummy.CreateRandomString(10);
var relativePath = string.Format("/{0}", resourceName);
var limeUri = LimeUri.Parse(relativePath);
// Act
Action action = () => limeUri.ToUri();
action.ShouldThrow <InvalidOperationException>();
}
public void Parse_ValidAbsoluteString_ReturnsInstance()
{
var identity = Dummy.CreateIdentity();
var resourceName = Dummy.CreateRandomString(10);
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, resourceName);
var actual = LimeUri.Parse(absolutePath);
actual.Path.ShouldNotBe(null);
actual.Path.ShouldBe(absolutePath);
actual.IsRelative.ShouldBe(false);
}
private async Task SetPresenceAsync(IClientChannel clientChannel, CancellationToken cancellationToken = default(CancellationToken))
{
if (!IsGuest(clientChannel.LocalNode.Name))
{
await clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.PRESENCE),
new Presence { Status = PresenceStatus.Available, RoutingRule = RoutingRule, RoundRobin = true },
cancellationToken)
.ConfigureAwait(false);
}
}
public void Parse_ValidAbsoluteSpecialCharactersStringContainingSpace_ReturnsInstance()
{
var identity = Dummy.CreateIdentity();
var resourceNameWithSpace = $"{Dummy.CreateRandomStringSpecial(5)} {Dummy.CreateRandomStringSpecial(5)}";
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, Uri.EscapeDataString(resourceNameWithSpace));
var actual = LimeUri.Parse(absolutePath);
actual.Path.ShouldNotBe(null);
actual.Path.ShouldBe(absolutePath);
actual.IsRelative.ShouldBe(false);
}
public override void WriteJson(global::Newtonsoft.Json.JsonWriter writer, object value, global::Newtonsoft.Json.JsonSerializer serializer)
{
if (value != null)
{
LimeUri identity = (LimeUri)value;
writer.WriteValue(identity.ToString());
}
else
{
writer.WriteNull();
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, global::Newtonsoft.Json.JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.String)
{
var tokenValue = reader.Value.ToString();
return(LimeUri.Parse(tokenValue));
}
else
{
return(null);
}
}
private async Task GetContactsAsync()
{
var contactCollection = await _clientChannel.GetResourceAsync <DocumentCollection>(
LimeUri.Parse(UriTemplates.CONTACTS),
_receiveTimeout.ToCancellationToken());
Contacts.Clear();
foreach (Contact contact in contactCollection.Items)
{
Contacts.Add(new ContactViewModel(contact, _clientChannel));
}
}
private async Task SetReceiptAsync(IClientChannel clientChannel, CancellationToken cancellationToken = default(CancellationToken))
{
if (IsGuest(clientChannel.LocalNode.Name) ||
ReceiptEvents.Length == 0)
{
return;
}
await clientChannel.SetResourceAsync(
LimeUri.Parse(UriTemplates.RECEIPT),
new Receipt { Events = ReceiptEvents },
cancellationToken)
.ConfigureAwait(false);
}
public void ToUri_AbsoluteInstance_ReturnsUri()
{
var identity = Dummy.CreateIdentity();
var resourceName = Dummy.CreateRandomString(10);
var absolutePath = string.Format("{0}://{1}/{2}", LimeUri.LIME_URI_SCHEME, identity, resourceName);
var limeUri = LimeUri.Parse(absolutePath);
// Act
var uri = limeUri.ToUri();
// Assert
uri.Scheme.ShouldBe(LimeUri.LIME_URI_SCHEME);
uri.UserInfo.ShouldBe(identity.Name);
uri.Authority.ShouldBe(identity.Domain);
uri.PathAndQuery.ShouldBe("/" + resourceName);
}
public Task RejectPendingContactAsync()
{
return(ExecuteAsync(async() =>
{
var selectedContact = SelectedContact;
if (selectedContact != null &&
selectedContact.Contact != null)
{
await _clientChannel.DeleteResourceAsync(
LimeUri.Parse(UriTemplates.CONTACT.NamedFormat(new { contactIdentity = selectedContact.Contact.Identity })),
_receiveTimeout.ToCancellationToken());
await GetContactsAsync();
}
}));
}
private Task RemoveContactAsync()
{
return(ExecuteAsync(async() =>
{
var selectedContact = SelectedContact;
if (selectedContact != null &&
selectedContact.Contact != null)
{
await _clientChannel.DeleteResourceAsync(
LimeUri.Parse(Smart.Format(UriTemplates.CONTACT, new { contactIdentity = SelectedContact.Contact })),
_receiveTimeout.ToCancellationToken());
await GetContactsAsync();
}
}));
}
/// <summary>
/// Sets the resource value asynchronous.
/// </summary>
/// <typeparam name="TResource">The type of the resource.</typeparam>
/// <param name="channel">The channel.</param>
/// <param name="uri">The resource uri.</param>
/// <param name="resource">The resource.</param>
/// <param name="from">From.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">channel</exception>
/// <exception cref="LimeException"></exception>
public static async Task SetResourceAsync <TResource>(this IChannel channel, LimeUri uri, TResource resource, Node from, CancellationToken cancellationToken) where TResource : Document
{
if (channel == null)
{
throw new ArgumentNullException("channel");
}
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (resource == null)
{
throw new ArgumentNullException("resource");
}
var requestCommand = new Command()
{
From = from,
Method = CommandMethod.Set,
Uri = uri,
Resource = resource
};
var responseCommand = await ProcessCommandAsync(channel, requestCommand, cancellationToken).ConfigureAwait(false);
if (responseCommand.Status != CommandStatus.Success)
{
if (responseCommand.Reason != null)
{
throw new LimeException(responseCommand.Reason.Code, responseCommand.Reason.Description);
}
else
{
#if DEBUG
if (requestCommand == responseCommand)
{
throw new InvalidOperationException("The request and the response are the same instance");
}
#endif
throw new InvalidOperationException("An invalid command response was received");
}
}
}
static ServiceStackSerializer()
{
JsConfig.ExcludeTypeInfo = true;
JsConfig.EmitCamelCaseNames = true;
JsConfig <Message> .IncludeTypeInfo = false;
JsConfig <Notification> .IncludeTypeInfo = false;
JsConfig <Command> .IncludeTypeInfo = false;
JsConfig <Session> .IncludeTypeInfo = false;
JsConfig <MediaType> .SerializeFn = m => m.ToString();
JsConfig <MediaType> .DeSerializeFn = s => MediaType.Parse(s);
JsConfig <Node> .SerializeFn = n => n.ToString();
JsConfig <Node> .DeSerializeFn = s => Node.Parse(s);
JsConfig <Identity> .SerializeFn = i => i.ToString();
JsConfig <Identity> .DeSerializeFn = s => Identity.Parse(s);
JsConfig <Guid> .SerializeFn = g => g.ToString();
JsConfig <Guid> .DeSerializeFn = s => Guid.Parse(s);
JsConfig <LimeUri> .SerializeFn = u => u.ToString();
JsConfig <LimeUri> .DeSerializeFn = u => LimeUri.Parse(u);
JsConfig <Document> .RawSerializeFn = d =>
{
var mediaType = d.GetMediaType();
if (mediaType.IsJson)
{
return(global::ServiceStack.Text.JsonSerializer.SerializeToString(d));
}
else
{
return(string.Format("\"{0}\"", d.ToString()));
}
};
foreach (var enumType in TypeUtil.GetEnumTypes())
{
var jsonConfigEnumType = typeof(JsConfig <>).MakeGenericType(enumType);
var serializeProperty = jsonConfigEnumType.GetProperty("SerializeFn");
var serializeFuncType = typeof(Func <,>).MakeGenericType(enumType, typeof(string));
var methodInfo = typeof(ServiceStackSerializer).GetMethod("ToCamelCase", BindingFlags.Static | BindingFlags.NonPublic);
var enumToCamelCaseMethod = methodInfo.MakeGenericMethod(enumType);
var serializeFunc = Delegate.CreateDelegate(serializeFuncType, enumToCamelCaseMethod);
serializeProperty.SetValue(null, serializeFunc, BindingFlags.Static, null, null, CultureInfo.InvariantCulture);
}
}
public void Deserialize_CapabilityRequestCommand_ReturnsValidInstance()
{
var target = GetTarget();
var contentType1 = DataUtil.CreateJsonMediaType();
var contentType2 = DataUtil.CreateJsonMediaType();
var contentType3 = DataUtil.CreateJsonMediaType();
var resourceType1 = DataUtil.CreateJsonMediaType();
var resourceType2 = DataUtil.CreateJsonMediaType();
var resourceType3 = DataUtil.CreateJsonMediaType();
var method = CommandMethod.Get;
var id = Guid.NewGuid();
var from = DataUtil.CreateNode();
var pp = DataUtil.CreateNode();
var to = DataUtil.CreateNode();
string randomKey1 = "randomString1";
string randomKey2 = "randomString2";
string randomString1 = DataUtil.CreateRandomString(50);
string randomString2 = DataUtil.CreateRandomString(50);
var resourceUri = new LimeUri("/capability");
string json = string.Format(
"{{\"uri\":\"{0}\",\"type\":\"application/vnd.lime.capability+json\",\"resource\":{{\"contentTypes\":[\"{1}\",\"{2}\",\"{3}\"],\"resourceTypes\":[\"{4}\",\"{5}\",\"{6}\"]}},\"method\":\"{7}\",\"id\":\"{8}\",\"from\":\"{9}\",\"pp\":\"{10}\",\"to\":\"{11}\",\"metadata\":{{\"{12}\":\"{13}\",\"{14}\":\"{15}\"}}}}",
resourceUri,
contentType1,
contentType2,
contentType3,
resourceType1,
resourceType2,
resourceType3,
method.ToString().ToCamelCase(),
id,
from,
pp,
to,
randomKey1,
randomString1,
randomKey2,
randomString2);
var envelope = target.Deserialize(json);
Assert.IsTrue(envelope is Command);
var command = (Command)envelope;
Assert.AreEqual(id, command.Id);
Assert.AreEqual(from, command.From);
Assert.AreEqual(pp, command.Pp);
Assert.AreEqual(to, command.To);
Assert.AreEqual(method, command.Method);
Assert.IsNotNull(command.Metadata);
Assert.IsTrue(command.Metadata.ContainsKey(randomKey1));
Assert.AreEqual(command.Metadata[randomKey1], randomString1);
Assert.IsTrue(command.Metadata.ContainsKey(randomKey2));
Assert.AreEqual(command.Metadata[randomKey2], randomString2);
Assert.IsTrue(command.Resource is Capability);
var capability = (Capability)command.Resource;
Assert.IsTrue(capability.ContentTypes.Any(c => c.Equals(contentType1)));
Assert.IsTrue(capability.ContentTypes.Any(c => c.Equals(contentType2)));
Assert.IsTrue(capability.ContentTypes.Any(c => c.Equals(contentType3)));
Assert.IsTrue(capability.ResourceTypes.Any(c => c.Equals(resourceType1)));
Assert.IsTrue(capability.ResourceTypes.Any(c => c.Equals(resourceType2)));
Assert.IsTrue(capability.ResourceTypes.Any(c => c.Equals(resourceType3)));
Assert.IsNotNull(command.Uri);
Assert.AreEqual(command.Uri, resourceUri);
}
