/// <summary> /// Prevents a default instance of the ApplicationEndpoint class from being created /// </summary> public ApplicationEndpoint(IClientPlatform platform, ApplicationEndpointSettings applicationEndpointSettings, IEventChannel eventChannel) { ClientPlatform = platform; m_endpointSettings = applicationEndpointSettings; if (eventChannel != null) { m_eventChannel = eventChannel; m_eventChannel.HandleIncomingEvents += this.OnReceivedCallback; } Logger.Instance.Information("Initializing ApplicationEndpoint"); var oauthTokenIdentitifier = new OAuthTokenIdentifier( Constants.PlatformAudienceUri, applicationEndpointSettings.ApplicationEndpointId.Domain); var tokenProvider = new AADServiceTokenProvider(platform.AADClientId.ToString(), Constants.AAD_AuthorityUri, platform.AADAppCertificate, platform.AADClientSecret); if (!platform.IsInternalPartner) { TokenMapper.RegisterNameSpaceHandling(Constants.DefaultResourceNamespace, Constants.PublicServiceResourceNamespace); } TokenMapper.RegisterTypesInAssembly(Assembly.GetAssembly(typeof(ApplicationsResource))); m_tokenProvider = tokenProvider; m_oauthTokenIdentifier = oauthTokenIdentitifier; m_restfulClient = ((ClientPlatform)ClientPlatform).RestfulClientFactory.GetRestfulClient(m_oauthTokenIdentifier, m_tokenProvider); Logger.Instance.Information("ApplicationEndpoint Initialized!"); }
public static void InitializeTokenMapper() { if (!TestHelper.IsInternalApp) { TokenMapper.RegisterNameSpaceHandling(Constants.DefaultResourceNamespace, Constants.PublicServiceResourceNamespace); } TokenMapper.RegisterTypesInAssembly(Assembly.GetAssembly(typeof(ApplicationsResource))); }
public async Task MapToToken_uuid_UuidToken() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); ITokenMapper mapper = new TokenMapper(logger.Object); // Act Token token = await mapper.MapToTokenAsync("uuid"); // Assert UuidToken uuidToken = Assert.IsAssignableFrom <UuidToken>(token); }
public async Task MapToToken_utcnow_UtcNowTokenWithDefaultFormat() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); ITokenMapper mapper = new TokenMapper(logger.Object); // Act Token token = await mapper.MapToTokenAsync("utcnow()"); // Assert UtcNowToken uuidToken = Assert.IsAssignableFrom <UtcNowToken>(token); }
public async Task MapToToken_variable_VariableToken() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); ITokenMapper mapper = new TokenMapper(logger.Object); // Act Token token = await mapper.MapToTokenAsync("variable(myid)"); // Assert Assert.IsAssignableFrom <VariableToken>(token); }
public async Task <ActionResult> Index() { ViewData["IsUserLogged"] = HttpContext.Session.GetString("IsUserLogged"); usersService.TokenDto = TokenMapper.ToDto(JsonConvert.DeserializeObject <TokenData>(HttpContext.Session.GetString("TokenData"))); IList <UserDto> users = await usersService.GetUsers(); List <User> userList = users.Select(userDto => UserMapper.ToEntity(userDto)).ToList(); return(View(userList)); }
internal TfIdfVector CreateClassificationVector(TokenMapper mapper) { var result = ContentVector; if (TitleVector != null) { result = TitleVector.Add(ContentVector, 2); } result.ConvertTokenToId(mapper); return(result); }
/// <summary> /// process conversation bridge participant events /// </summary> /// <param name="eventcontext"></param> /// <returns></returns> internal override bool ProcessAndDispatchEventsToChild(EventContext eventcontext) { //No child to dispatch any more, need to dispatch to child , process locally for message type if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(BridgedParticipantResource)))) { if (eventcontext.EventEntity.Relationship == EventOperation.Added) { BridgedParticipantResource resource = this.ConvertToPlatformServiceResource <BridgedParticipantResource>(eventcontext); if (resource != null) { BridgedParticipant newBridgedParticipant = new BridgedParticipant(this.RestfulClient, resource, this.BaseUri, UriHelper.CreateAbsoluteUri(eventcontext.BaseUri, resource.SelfUri), this); TaskCompletionSource <BridgedParticipant> tcs = null; newBridgedParticipant.HandleResourceEvent(eventcontext); m_bridgedParticipants.TryAdd(UriHelper.NormalizeUri(resource.SelfUri, this.BaseUri), newBridgedParticipant); if (m_bridgedParticipantTcses.TryRemove(resource.Uri.ToLower(), out tcs)) { tcs.SetResult(newBridgedParticipant); } } } if (eventcontext.EventEntity.Relationship == EventOperation.Updated) { BridgedParticipantResource resource = this.ConvertToPlatformServiceResource <BridgedParticipantResource>(eventcontext); if (resource != null) { BridgedParticipant newBridgedParticipant = null; if (m_bridgedParticipants.TryGetValue(UriHelper.NormalizeUri(resource.SelfUri, this.BaseUri), out newBridgedParticipant)) { newBridgedParticipant.HandleResourceEvent(eventcontext); } } } if (eventcontext.EventEntity.Relationship == EventOperation.Deleted) { BridgedParticipant newBridgedParticipant = null; if (m_bridgedParticipants.TryRemove(UriHelper.NormalizeUri(eventcontext.EventEntity.Link.Href, this.BaseUri), out newBridgedParticipant)) { newBridgedParticipant.HandleResourceEvent(eventcontext); } } return(true); } else { return(false); } }
public async Task MapToToken_randomitem_RandomItem() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); ITokenMapper mapper = new TokenMapper(logger.Object); // Act Token token = await mapper.MapToTokenAsync("randomitem(info,warn,error)"); // Assert RandomItemToken randomItemToken = Assert.IsAssignableFrom <RandomItemToken>(token); Assert.Equal(new [] { "info", "warn", "error" }, randomItemToken.Items); }
public async Task MapToToken_randombetween_RandomBetweenToken() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); ITokenMapper mapper = new TokenMapper(logger.Object); // Act Token token = await mapper.MapToTokenAsync("randombetween(1,10)"); // Assert RandomBetweenToken randomBetweenToken = Assert.IsAssignableFrom <RandomBetweenToken>(token); Assert.Equal(1, randomBetweenToken.Lower); Assert.Equal(10, randomBetweenToken.Upper); }
private async Task <bool> IsValidUser(Login login) { var tokenDto = await loginService.ValidUser(LoginMapper.ToDto(login)); if (tokenDto == null) { HttpContext.Session.SetString("IsUserLogged", "false"); return(false); } HttpContext.Session.SetString("IsUserLogged", "true"); HttpContext.Session.SetString("User", tokenDto.Name); HttpContext.Session.SetString("TokenData", JsonConvert.SerializeObject(TokenMapper.ToEntity(tokenDto))); return(true); }
public async Task Extract_TemplatesWithSpecialCharacters_ExtractionSuccessfull() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); Mock <ILogger <TokenExtractor> > extractionLogger = new Mock <ILogger <TokenExtractor> >(); ITokenMapper mapper = new TokenMapper(logger.Object); ITokenExtractor tokenExtractor = new TokenExtractor(mapper, extractionLogger.Object); // Act List <Extraction> extractions = await tokenExtractor.Extract("Hello\n${uuid}"); // Assert Assert.Single(extractions); Assert.Equal("Hello\n{0}", extractions[0].Template); Assert.Equal("uuid", extractions[0].Tokens[0].Key); }
public async Task Extract_TemplatesWithJson_ExtractionSuccessfull() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); Mock <ILogger <TokenExtractor> > extractionLogger = new Mock <ILogger <TokenExtractor> >(); ITokenMapper mapper = new TokenMapper(logger.Object); ITokenExtractor tokenExtractor = new TokenExtractor(mapper, extractionLogger.Object); // Act List <Extraction> extractions = await tokenExtractor.Extract("{\"Hello\": \"World\", \"id\": \"${uuid}\"}"); // Assert Assert.Single(extractions); Assert.Equal("{{\"Hello\": \"World\", \"id\": \"{0}\"}}", extractions[0].Template); Assert.Equal("uuid", extractions[0].Tokens[0].Key); }
public async Task <ActionResult> Edit(int id) { usersService.TokenDto = TokenMapper.ToDto(JsonConvert.DeserializeObject <TokenData>(HttpContext.Session.GetString("TokenData"))); var userFound = await usersService.GetUserById(id); if (userFound == null) { return(NotFound()); } ViewData["IsUserLogged"] = HttpContext.Session.GetString("IsUserLogged"); var user = UserMapper.ToEntity(userFound); return(View(user)); }
public void ToComplexEntity_WhenSimpleEntity_ExpectCorrectMap() { // Arrange var mockPropertyMapper = new Mock<IPropertyGetSettersTyped<Token>>(); var mockClaimsMapper = new Mock<IMapper<SimpleClaim, Claim>>(); var mockClientMapper = new Mock<IMapper<SimpleClient, Client>>(); mockClaimsMapper.Setup(r => r.ToComplexEntity(It.IsAny<SimpleClaim>())).Returns(new Claim("Val1", "Val2")); mockClientMapper.Setup(r => r.ToComplexEntity(It.IsAny<SimpleClient>())).Returns(new Client()); mockPropertyMapper.Setup(r => r.GetSetters(It.IsAny<Type>())) .Returns(new Dictionary<string, TypedSetter<Token>>()); var tokenMappers = new TokenMapper<Token>(mockPropertyMapper.Object, mockClaimsMapper.Object, mockClientMapper.Object); var simpleEntity = new SimpleToken { Claims = new List<SimpleClaim>(), Client = new SimpleClient(), Type = "Type", CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)), Issuer = "Issuer", Version = 1, Audience = "Audience", Lifetime = 1, }; // Act var stopwatch = Stopwatch.StartNew(); var complexEntity = tokenMappers.ToComplexEntity(simpleEntity); stopwatch.Stop(); // Assert this.WriteTimeElapsed(stopwatch); Assert.That(complexEntity, Is.Not.Null); Assert.That(complexEntity.Claims, Is.Not.Null); Assert.That(complexEntity.Client, Is.Not.Null); Assert.That(complexEntity.Type, Is.EqualTo("Type")); Assert.That(complexEntity.CreationTime, Is.EqualTo(new DateTimeOffset(new DateTime(2016, 1, 1)))); Assert.That(complexEntity.Issuer, Is.EqualTo("Issuer")); Assert.That(complexEntity.Version, Is.EqualTo(1)); Assert.That(complexEntity.Audience, Is.EqualTo("Audience")); Assert.That(complexEntity.Lifetime, Is.EqualTo(1)); }
public async Task <ActionResult> Create(User user) { try { if (ModelState.IsValid) { usersService.TokenDto = TokenMapper.ToDto(JsonConvert.DeserializeObject <TokenData>(HttpContext.Session.GetString("TokenData"))); await usersService.AddUser(UserMapper.ToDto(user)); } return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
public async Task Extract_TemplateWithOneToken_TokenExtracted() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); Mock <ILogger <TokenExtractor> > extractionLogger = new Mock <ILogger <TokenExtractor> >(); ITokenMapper mapper = new TokenMapper(logger.Object); ITokenExtractor tokenExtractor = new TokenExtractor(mapper, extractionLogger.Object); // Act List <Extraction> extractions = await tokenExtractor.Extract("I am a log for ${uuid}"); // Assert Extraction extraction = extractions.First(); Assert.Equal("I am a log for {0}", extraction.Template); Assert.Equal("uuid", extraction.Tokens.First().Key); }
public async Task Extract_TemplateWithTwoTokenInJson_TokensExtracted() { // Arrange Mock <ILogger <TokenMapper> > logger = new Mock <ILogger <TokenMapper> >(); Mock <ILogger <TokenExtractor> > extractionLogger = new Mock <ILogger <TokenExtractor> >(); ITokenMapper mapper = new TokenMapper(logger.Object); ITokenExtractor tokenExtractor = new TokenExtractor(mapper, extractionLogger.Object); // Act List <Extraction> extractions = await tokenExtractor.Extract("{\"Hello\":\"${randomitem(world,universe)}\", \"id\": \"${uuid}\"}"); // Assert Extraction extraction = extractions.First(); Assert.Equal("{{\"Hello\":\"{0}\", \"id\": \"{1}\"}}", extraction.Template); Assert.Equal("randomitem", extraction.Tokens[0].Key); Assert.Equal("uuid", extraction.Tokens[1].Key); }
internal override bool ProcessAndDispatchEventsToChild(EventContext eventContext) { bool processed = false; if (eventContext.EventEntity.Link.Token == TokenMapper.GetTokenName(typeof(AudioVideoFlowResource))) { if (eventContext.EventEntity.Relationship == EventOperation.Added) { var audioVideoFlowResource = ConvertToPlatformServiceResource <AudioVideoFlowResource>(eventContext); AudioVideoFlow = new AudioVideoFlow(RestfulClient, audioVideoFlowResource, BaseUri, UriHelper.CreateAbsoluteUri(BaseUri, audioVideoFlowResource.SelfUri), this); // Raise event when flow state changes to connected AudioVideoFlow.HandleResourceUpdated += RaiseAudioVideoFlowConnectedEventIfConnected; // Raise event if the flow is already connected RaiseAudioVideoFlowConnectedEventIfConnected(null, null); } ((AudioVideoFlow)AudioVideoFlow).HandleResourceEvent(eventContext); if (eventContext.EventEntity.Relationship == EventOperation.Deleted) { AudioVideoFlow = null; } processed = true; } else if (eventContext.EventEntity.Link.Token == TokenMapper.GetTokenName(typeof(TransferResource))) { this.HandleTransferEvent(eventContext); processed = true; } var flow = AudioVideoFlow; if (!processed && flow != null) { processed = ((AudioVideoFlow)flow).ProcessAndDispatchEventsToChild(eventContext); } //add any new child resource under audioVideo processing here return(processed); }
/// <summary> /// ProcessAndDispatchEventsToChild : For child resources here /// </summary> /// <param name="eventContext"></param> /// <returns></returns> internal override bool ProcessAndDispatchEventsToChild(EventContext eventContext) { //No child to dispatch any more, need to dispatch to child , process locally for message type if (string.Equals(eventContext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ParticipantMessagingResource)))) { if (eventContext.EventEntity.Relationship == EventOperation.Added) { ParticipantMessagingResource participantMessaging = this.ConvertToPlatformServiceResource <ParticipantMessagingResource>(eventContext); if (participantMessaging != null) { ParticipantMessaging = new ParticipantMessaging(this.RestfulClient, participantMessaging, this.BaseUri, UriHelper.CreateAbsoluteUri(eventContext.BaseUri, participantMessaging.SelfUri), this); } m_handleParticipantModalityChange?.Invoke(this, new ParticipantModalityChangeEventArgs { AddedModalities = new List <EventableEntity> { ParticipantMessaging as ParticipantMessaging } }); } if (eventContext.EventEntity.Relationship == EventOperation.Deleted) { m_handleParticipantModalityChange?.Invoke(this, new ParticipantModalityChangeEventArgs { RemovedModalities = new List <EventableEntity> { ParticipantMessaging as ParticipantMessaging } }); ParticipantMessaging = null; } return(true); } else { return(false); } }
public async Task <ActionResult> Delete(User user) { try { usersService.TokenDto = TokenMapper.ToDto(JsonConvert.DeserializeObject <TokenData>(HttpContext.Session.GetString("TokenData"))); var userFound = await usersService.GetUserById(user.Id); if (userFound == null) { return(View()); } await usersService.DeleteUser(user.Id); return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
internal override bool ProcessAndDispatchEventsToChild(EventContext eventContext) { if (eventContext.EventEntity.Link.Token == TokenMapper.GetTokenName(typeof(ToneResource))) { var toneResource = ConvertToPlatformServiceResource <ToneResource>(eventContext); Uri audioVideoFlowLink = UriHelper.CreateAbsoluteUri(this.BaseUri, toneResource.AudioVideoFlowLink.Href); if (string.Equals(audioVideoFlowLink.ToString(), this.ResourceUri.ToString(), StringComparison.OrdinalIgnoreCase)) { var eventArgs = new ToneReceivedEventArgs(toneResource.ToneValue); m_toneReceivedEvent?.Invoke(this, eventArgs); return(true); } else { return(false); } } //No child to dispatch any more, need to dispatch to child , process locally for message type else if (string.Equals(eventContext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(PromptResource)))) { PromptResource prompt = this.ConvertToPlatformServiceResource <PromptResource>(eventContext); if (prompt != null) { if (eventContext.EventEntity.Relationship == EventOperation.Completed) { TaskCompletionSource <Prompt> tcs = null; Uri resourceAbsoluteUri = UriHelper.CreateAbsoluteUri(this.BaseUri, eventContext.EventEntity.Link.Href); m_onGoingPromptTcses.TryGetValue(resourceAbsoluteUri.ToString().ToLower(), out tcs); if (tcs != null) { Prompt p = new Prompt(this.RestfulClient, prompt, this.BaseUri, resourceAbsoluteUri, this); if (eventContext.EventEntity.Status == EventStatus.Success) { tcs.TrySetResult(p); } else if (eventContext.EventEntity.Status == EventStatus.Failure) { var errorInformation = eventContext.EventEntity.Error; string errorString = errorInformation?.GetErrorInformationString(); tcs.TrySetException( new RemotePlatformServiceException( "PlayPrompt failed with error " + errorString + eventContext.LoggingContext.ToString(), errorInformation )); } else { Logger.Instance.Error("Received invalid status code for prompt completed event"); tcs.TrySetException(new RemotePlatformServiceException("PlayPrompt failed")); } m_onGoingPromptTcses.TryRemove(eventContext.EventEntity.Link.Href.ToLower(), out tcs); } } } return(true); } else { return(false); } }
/// <summary> /// Handle current conversation events /// </summary> /// <param name="eventContext">Events to be processed</param> internal override bool ProcessAndDispatchEventsToChild(EventContext eventContext) { bool processed = false; Logger.Instance.Information(string.Format("[Conversation] get incoming communication event, sender: {0}, senderHref: {1}, EventResourceName: {2} EventFullHref: {3}, EventType: {4} ,LoggingContext: {5}", eventContext.SenderResourceName, eventContext.SenderHref, eventContext.EventResourceName, eventContext.EventFullHref, eventContext.EventEntity.Relationship.ToString(), eventContext.LoggingContext == null ? string.Empty : eventContext.LoggingContext.ToString())); // Messaging processed = this.HandleConversationChildEvents <MessagingCall, MessagingResource>(eventContext, ref m_messagingCall, TokenMapper.GetTokenName(typeof(MessagingResource)), (messagingResource) => new MessagingCall(this.RestfulClient, messagingResource, this.BaseUri, UriHelper.CreateAbsoluteUri(this.BaseUri, messagingResource.SelfUri), this)); // AudioVideo if (!processed) { processed = this.HandleConversationChildEvents <AudioVideoCall, AudioVideoResource>(eventContext, ref m_audioVideoCall, TokenMapper.GetTokenName(typeof(AudioVideoResource)), (AudioVideoResource) => new AudioVideoCall(this.RestfulClient, AudioVideoResource, this.BaseUri, UriHelper.CreateAbsoluteUri(this.BaseUri, AudioVideoResource.SelfUri), this)); } // ConversationConference if (!processed) { processed = this.HandleConversationChildEvents <ConversationConference, ConversationConferenceResource>(eventContext, ref m_conversationConference, TokenMapper.GetTokenName(typeof(ConversationConferenceResource)), (ConversationConferenceResource) => new ConversationConference(this.RestfulClient, ConversationConferenceResource, this.BaseUri, UriHelper.CreateAbsoluteUri(this.BaseUri, ConversationConferenceResource.SelfUri), this)); } // ConversationBridge if (!processed) { processed = this.HandleConversationChildEvents <ConversationBridge, ConversationBridgeResource>(eventContext, ref m_conversationBridge, TokenMapper.GetTokenName(typeof(ConversationBridgeResource)), (ConversationBridgeResource) => new ConversationBridge(this.RestfulClient, ConversationBridgeResource, this.BaseUri, UriHelper.CreateAbsoluteUri(this.BaseUri, ConversationBridgeResource.SelfUri), this)); } // Participants if (!processed) { //Here is a hack for participant. Basically we will never get the participantsResource in event, we need to leverage ParticipantsInternal to handle the participant related events processed = this.HandleConversationChildEvents <ParticipantsInternal, ParticipantsResource>(eventContext, ref m_participants, TokenMapper.GetTokenName(typeof(ParticipantsResource)), (a) => new ParticipantsInternal(this.RestfulClient, this.BaseUri, null, this)); } return(processed); }
internal override bool ProcessAndDispatchEventsToChild(EventContext eventContext) { //No child to dispatch any more, need to dispatch to child , process locally for message type if (string.Equals(eventContext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(MessageResource)))) { MessageResource message = this.ConvertToPlatformServiceResource <MessageResource>(eventContext); if (message != null) { if (message.Direction == Direction.Incoming) { // File incoming message received event IncomingMessageEventArgs args = new IncomingMessageEventArgs { HtmlMessage = message.HtmlMessage == null? null : message.HtmlMessage.Value as TextHtmlMessage, PlainMessage = message.TextMessage == null ? null : message.TextMessage.Value as TextPlainMessage }; Conversation conv = this.Parent as Conversation; Participant fromParticipant = conv.TryGetParticipant(message.ParticipantResourceLink.Href) as Participant; if (fromParticipant == null) { Logger.Instance.Warning("Get message from an unknown participant, probably client code bug or server bug"); } else { args.FromParticipantName = fromParticipant.Name; } IncomingMessageReceived?.Invoke(this, args); } else //For out going, just detect the completed event { if (eventContext.EventEntity.Relationship == EventOperation.Completed) { TaskCompletionSource <string> tcs; m_outGoingmessageTcses.TryGetValue(UriHelper.CreateAbsoluteUri(this.BaseUri, eventContext.EventEntity.Link.Href).ToString().ToLower(), out tcs); if (tcs != null) { if (eventContext.EventEntity.Status == EventStatus.Success) { tcs.TrySetResult(string.Empty); } else if (eventContext.EventEntity.Status == EventStatus.Failure) { string error = eventContext.EventEntity.Error?.GetErrorInformationString(); tcs.TrySetException(new RemotePlatformServiceException("Send Message failed with error" + error + eventContext.LoggingContext.ToString())); } else { Logger.Instance.Error("Do not get a valid status code for message complete event!"); tcs.TrySetException(new RemotePlatformServiceException("Send Message failed !")); } m_outGoingmessageTcses.TryRemove(eventContext.EventEntity.Link.Href.ToLower(), out tcs); } } } } return(true); } else { return(false); } }
private void ProcessEvents(EventsChannelContext events) { Logger.Instance.Information("[ApplicationEndpoint] Receice incoming event callback Initialized!"); Uri baseUri = null; if (!Uri.TryCreate(events.EventsEntity.BaseUri, UriKind.Absolute, out baseUri)) { Logger.Instance.Error("[ApplicationEndpoint] " + events.EventsEntity.BaseUri + "is not valid absolute url "); return; } if (Application?.Communication == null) { try { Logger.Instance.Information("[ApplicationEndpoint] application is not initilized, initialize it"); InitializeApplicationAsync(new LoggingContext()).Wait(); } catch (Exception ex) { Logger.Instance.Error(ex, "[ApplicationEndpoint] application initilized failure, ignore incoming event call back"); } } var communication = Application?.Communication as Communication; if (communication != null) { foreach (EventSenderEntity eventsender in events.EventsEntity.Senders) { List <EventContext> conversationEvents = null; foreach (EventEntity e in eventsender.Events) { EventContext eventContext = new EventContext { SenderResourceName = eventsender.Token, BaseUri = baseUri, SenderHref = eventsender.Href, EventResourceName = e.Link.Token, EventFullHref = UriHelper.CreateAbsoluteUri(baseUri, e.Link.Href), EventEntity = e, LoggingContext = events.LoggingContext == null ? null : events.LoggingContext.Clone() as LoggingContext }; Logger.Instance.Information(string.Format("[ApplicationEndpoint] get incoming event, sender: {0}, senderHref: {1}, EventResourceName: {2} EventFullHref: {3}, EventType {4}, LoggingContext: {5}", eventContext.SenderResourceName, eventContext.SenderHref, eventContext.EventResourceName, eventContext.EventFullHref, eventContext.EventEntity.Relationship.ToString(), eventContext.LoggingContext == null ? string.Empty : eventContext.LoggingContext.ToString())); if (string.Equals(eventContext.SenderResourceName, TokenMapper.GetTokenName(typeof(CommunicationResource)), StringComparison.CurrentCultureIgnoreCase)) { communication.ProcessAndDispatchEventsToChild(eventContext); } else if (string.Equals(eventContext.SenderResourceName, TokenMapper.GetTokenName(typeof(ConversationResource)), StringComparison.CurrentCultureIgnoreCase)) { // We send conversation updated and deleted events with conversation as sender now. // Since the logic to process those are in communication we will send these events to // communication.ProcessAndDispatchEventsToChild if (string.Equals(eventContext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ConversationResource)))) { communication.ProcessAndDispatchEventsToChild(eventContext); } else { if (conversationEvents == null) { conversationEvents = new List <EventContext>(); } conversationEvents.Add(eventContext); } } } if (conversationEvents != null && conversationEvents.Count > 0) { communication.DispatchConversationEvents(conversationEvents); } } } }
internal override bool ProcessAndDispatchEventsToChild(EventContext eventcontext) { ParticipantChangeEventArgs participantChangeEventArgs = null; //No child to dispatch any more, need to dispatch to child , process locally for message type if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ParticipantResource)))) { if (eventcontext.EventEntity.In != null) { //TODO: currently we do not handle in link return(true); } string normalizedUri = UriHelper.NormalizeUri(eventcontext.EventEntity.Link.Href, this.BaseUri); ParticipantResource participantResource = this.ConvertToPlatformServiceResource <ParticipantResource>(eventcontext); switch (eventcontext.EventEntity.Relationship) { case EventOperation.Added: { Participant tempParticipant = null; if (!m_participantsCache.TryGetValue(normalizedUri, out tempParticipant)) { tempParticipant = new Participant(this.RestfulClient, participantResource, this.BaseUri, UriHelper.CreateAbsoluteUri(this.BaseUri, eventcontext.EventEntity.Link.Href), this.Parent as Conversation); m_participantsCache.TryAdd(normalizedUri, tempParticipant); participantChangeEventArgs = new ParticipantChangeEventArgs(); participantChangeEventArgs.AddedParticipants = new List <IParticipant> { tempParticipant }; } else { //Should get some participant added In event , ignore currently } break; } case EventOperation.Updated: { Participant tempParticipant = null; if (!m_participantsCache.TryGetValue(normalizedUri, out tempParticipant)) { Logger.Instance.Warning("Get a participant updated event for a participant not in cache, any error happened ?"); tempParticipant = new Participant(this.RestfulClient, participantResource, this.BaseUri, UriHelper.CreateAbsoluteUri(this.BaseUri, eventcontext.EventEntity.Link.Href), this.Parent as Conversation); m_participantsCache.TryAdd(normalizedUri, tempParticipant); } tempParticipant.HandleResourceEvent(eventcontext); participantChangeEventArgs = new ParticipantChangeEventArgs(); participantChangeEventArgs.UpdatedParticipants = new List <IParticipant> { tempParticipant }; break; } case EventOperation.Deleted: { Participant tempParticipant = null; if (m_participantsCache.TryRemove(normalizedUri, out tempParticipant)) { tempParticipant.HandleResourceEvent(eventcontext); participantChangeEventArgs = new ParticipantChangeEventArgs(); participantChangeEventArgs.RemovedParticipants = new List <IParticipant> { tempParticipant }; } break; } } if (participantChangeEventArgs != null) { var conv = this.Parent as Conversation; conv.OnParticipantChange(participantChangeEventArgs); } return(true); } else if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ParticipantMessagingResource))) || string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ParticipantAudioResource))) || string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ParticipantApplicationSharingResource)))) { if (eventcontext.EventEntity.In != null) { string normalizedParticipantUri = UriHelper.NormalizeUri(eventcontext.EventEntity.In.Href, this.BaseUri); Participant tempParticipant = null; if (m_participantsCache.TryGetValue(normalizedParticipantUri, out tempParticipant)) { tempParticipant.ProcessAndDispatchEventsToChild(eventcontext); } } return(true); //We do not rely on the response of tempParticipant.ProcessAndDispatchEventsToChild since we already know this is participant modality event } else { return(false); } }
public void ToSimpleEntity_WhenComplexEntityAndExtendedComplex_ExpectCorrectMap() { // Arrange var mockPropertyMapper = new Mock<IPropertyGetSettersTyped<ExtendedToken>>(); var mockClaimsMapper = new Mock<IMapper<SimpleClaim, Claim>>(); var mockClientMapper = new Mock<IMapper<SimpleClient, Client>>(); var mockGetters = new Dictionary<string, Func<ExtendedToken, object>> { { "CustomDecimal", typeof(ExtendedToken).GetProperty("CustomDecimal").GetGetter<ExtendedToken>() } }; mockPropertyMapper.Setup(r => r.GetGetters(It.IsAny<Type>())) .Returns(mockGetters); mockClaimsMapper.Setup(r => r.ToSimpleEntity(It.IsAny<Claim>())).Returns(new SimpleClaim()); mockClientMapper.Setup(r => r.ToSimpleEntity(It.IsAny<Client>())).Returns(new SimpleClient()); var tokenMappers = new TokenMapper<ExtendedToken>( mockPropertyMapper.Object, mockClaimsMapper.Object, mockClientMapper.Object); var complexEntity = new ExtendedToken { Claims = new List<Claim>(), Client = new Client(), Type = "Type", CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)), Issuer = "Issuer", Version = 1, Audience = "Audience", Lifetime = 1, CustomDecimal = 1.25m }; // Act var stopwatch = Stopwatch.StartNew(); var simpleRefreshToken = tokenMappers.ToSimpleEntity(complexEntity); stopwatch.Stop(); // Assert this.WriteTimeElapsed(stopwatch); Assert.That(simpleRefreshToken.Claims, Is.Not.Null); Assert.That(simpleRefreshToken.Client, Is.Not.Null); Assert.That(simpleRefreshToken.Type, Is.EqualTo("Type")); Assert.That(simpleRefreshToken.CreationTime, Is.EqualTo(new DateTimeOffset(new DateTime(2016, 1, 1)))); Assert.That(simpleRefreshToken.Issuer, Is.EqualTo("Issuer")); Assert.That(simpleRefreshToken.Version, Is.EqualTo(1)); Assert.That(simpleRefreshToken.Audience, Is.EqualTo("Audience")); Assert.That(simpleRefreshToken.Lifetime, Is.EqualTo(1)); Assert.That(simpleRefreshToken.DataBag["CustomDecimal"], Is.EqualTo(1.25m)); }
/// <summary> /// ProcessAndDispatchEventsToChild implementation /// </summary> /// <param name="eventcontext"></param> /// <returns></returns> internal override bool ProcessAndDispatchEventsToChild(EventContext eventcontext) { //There is no child for events with sender = communication Logger.Instance.Information(string.Format("[Communication] get incoming communication event, sender: {0}, senderHref: {1}, EventResourceName: {2} EventFullHref: {3}, EventType: {4} ,LoggingContext: {5}", eventcontext.SenderResourceName, eventcontext.SenderHref, eventcontext.EventResourceName, eventcontext.EventFullHref, eventcontext.EventEntity.Relationship.ToString(), eventcontext.LoggingContext == null ? string.Empty : eventcontext.LoggingContext.ToString())); if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ConversationResource)))) { string conversationNormalizedUri = UriHelper.NormalizeUriWithNoQueryParameters(eventcontext.EventEntity.Link.Href, eventcontext.BaseUri); Conversation currentConversation = m_conversations.GetOrAdd(conversationNormalizedUri, (a) => { Logger.Instance.Information(string.Format("[Communication] Add conversation {0} LoggingContext: {1}", conversationNormalizedUri, eventcontext.LoggingContext == null ? string.Empty : eventcontext.LoggingContext.ToString())); ConversationResource localResource = this.ConvertToPlatformServiceResource <ConversationResource>(eventcontext); //For every conversation resource, we want to make sure it is using latest rest ful client return(new Conversation(this.RestfulClient, localResource, eventcontext.BaseUri, eventcontext.EventFullHref, this)); } ); //Remove from cache if it is a delete operation if (eventcontext.EventEntity.Relationship == EventOperation.Deleted) { Conversation removedConversation = null; Logger.Instance.Information(string.Format("[Communication] Remove conversation {0} LoggingContext: {1}", conversationNormalizedUri, eventcontext.LoggingContext == null ? string.Empty : eventcontext.LoggingContext.ToString())); m_conversations.TryRemove(conversationNormalizedUri, out removedConversation); } currentConversation.HandleResourceEvent(eventcontext); return(true); } else if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(MessagingInvitationResource)))) { this.HandleInvitationEvent <MessagingInvitationResource>( eventcontext, (localResource) => new MessagingInvitation(this.RestfulClient, localResource, eventcontext.BaseUri, eventcontext.EventFullHref, this) ); return(true); } else if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(AudioVideoInvitationResource)))) { this.HandleInvitationEvent <AudioVideoInvitationResource>( eventcontext, (localResource) => new AudioVideoInvitation(this.RestfulClient, localResource, eventcontext.BaseUri, eventcontext.EventFullHref, this) ); return(true); } else if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(OnlineMeetingInvitationResource)))) { this.HandleInvitationEvent <OnlineMeetingInvitationResource>( eventcontext, (localResource) => new OnlineMeetingInvitation(this.RestfulClient, localResource, eventcontext.BaseUri, eventcontext.EventFullHref, this) ); return(true); } else if (string.Equals(eventcontext.EventEntity.Link.Token, TokenMapper.GetTokenName(typeof(ParticipantInvitationResource)))) { this.HandleInvitationEvent <ParticipantInvitationResource>( eventcontext, (localResource) => new ParticipantInvitation(this.RestfulClient, localResource, eventcontext.BaseUri, eventcontext.EventFullHref, this) ); return(true); } //TODO: Process , audioVideoInvitation, ... else { return(false); } }