public async Task <ActionResult> Update([FromBody] ChangedMessage model)
{
var msg = await _chatService.Update(model);
SendBroadcast(msg.RoomId, "updated", msg);
return(Ok());
}
void IObserver <ChangedMessage <ITag> > .OnNext(ChangedMessage <ITag> value)
{
if (value.ChangeType.Equals(ChangeTypeValues.Modified))
{
this.OnChangingTag((Tag)value.Changed);
}
else
{
this.OnRemovingTag(value.Changed.Id);
}
}
void IObserver <ChangedMessage <IRelationship> > .OnNext(ChangedMessage <IRelationship> value)
{
if (value.ChangeType.Equals(ChangeTypeValues.Modified))
{
this.OnRelationshipChanging((Relationship)value.Changed);
}
else
{
OnRelationshipRemoving(value.Changed.Id);
}
}
void IObserver <ChangedMessage <IEntity> > .OnNext(ChangedMessage <IEntity> value)
{
if (value.ChangeType.Equals(ChangeTypeValues.Modified))
{
this.OnEntityChanging((Entity)value.Changed);
}
else
{
this.OnEntityRemoving(value.Changed.Id);
}
}
public async Task <Models.Message> Update(ChangedMessage message)
{
var entity = await _dbContext.Messages.FindAsync(message.Id);
if (!(entity.AuthorId == User.Id))
{
throw new InvalidOperationException();
}
Mapper.Map(message, entity);
_dbContext.Messages.Update(entity);
await _dbContext.SaveChangesAsync();
return(Mapper.Map <Models.Message>(entity));
}
public void SendPropertyChange(ChangedMessage message)
{
var meeting = MeetingInfoRepository.FindMeetingForAgent(Context.ConnectionId);
if (meeting == null)
{
return; // means this connection is not an agent
}
var room = meeting.Id.ToString();
try
{
Debug.WriteLine(string.Format("Propagating changed to meeting {0} property name {1}", room, message.PropertyName));
Clients.Group(room).onPropertyChanged(message);
}
catch (Exception)
{
Debug.WriteLine("Error calling onPropertyChanged");
}
}
public void MessageBus_notifies_of_removed_relationship()
{
// ARRANGE
var relationship = Mock.Of <IRelationship>();
var relationshipObserver = this.mocks.Create <IObserver <ChangedMessage <IRelationship> > >();
ChangedMessage <IRelationship> relationshipChangeMessage = null;
relationshipObserver
.Setup(o => o.OnNext(It.IsAny <ChangedMessage <IRelationship> >()))
.Callback <ChangedMessage <IRelationship> >(m => relationshipChangeMessage = m);
this.messageBus.Relationships.Subscribe(relationshipObserver.Object);
// ACT
this.messageBus.Relationships.Removed(relationship);
// ASSERT
Assert.Equal(ChangeTypeValues.Removed, relationshipChangeMessage.ChangeType);
Assert.Same(relationship, relationshipChangeMessage.Changed);
}
public void MessageBus_notifies_of_removed_tag()
{
// ARRANGE
var tag = Mock.Of <ITag>();
var tagObserver = this.mocks.Create <IObserver <ChangedMessage <ITag> > >();
ChangedMessage <ITag> tagChangeMessage = null;
tagObserver
.Setup(o => o.OnNext(It.IsAny <ChangedMessage <ITag> >()))
.Callback <ChangedMessage <ITag> >(m => tagChangeMessage = m);
this.messageBus.Tags.Subscribe(tagObserver.Object);
// ACT
this.messageBus.Tags.Removed(tag);
// ASSERT
Assert.Equal(ChangeTypeValues.Removed, tagChangeMessage.ChangeType);
Assert.Same(tag, tagChangeMessage.Changed);
}
public void MessageBus_notifies_of_removed_entity()
{
// ARRANGE
var entity = Mock.Of <IEntity>();
var entityObserver = this.mocks.Create <IObserver <ChangedMessage <IEntity> > >();
ChangedMessage <IEntity> entityChangeMessage = null;
entityObserver
.Setup(o => o.OnNext(It.IsAny <ChangedMessage <IEntity> >()))
.Callback <ChangedMessage <IEntity> >(m => entityChangeMessage = m);
this.messageBus.Entities.Subscribe(entityObserver.Object);
// ACT
this.messageBus.Entities.Removed(entity);
// ASSERT
Assert.Equal(ChangeTypeValues.Removed, entityChangeMessage.ChangeType);
Assert.Same(entity, entityChangeMessage.Changed);
}
public void ChangeMessage(string textMessage, Message editingMessage)
{
ChangedMessage.Invoke(textMessage, editingMessage);
}
public async Task <IActionResult> ChangeMessage(ChangedMessage message)
{
await chatService.ChangeMessage(message.MessageId, message.NewMessage, message.UserId);
return(Ok());
}
