private void AgregarChats(string userName)
{
UsuarioEntity usuarioOrigen = CachingManager.Instance.GetUsuarioByUsername(UserName);
List <UsuarioEntity> usuarios = CachingManager.Instance.GetAllUsuarios();
foreach (UsuarioEntity u in usuarios)
{
ChatEntity chat = new ChatEntity()
{
Nombre = "Chat",
EsGrupo = false,
Fecha = DateTime.Now
};
ChatUsuarioEntity chatUsuario = new ChatUsuarioEntity()
{
IdUsuario = u.IdUsuario,
EsOwner = false,
Fecha = DateTime.Now
};
ChatUsuarioEntity chatUsuarioDestino = new ChatUsuarioEntity()
{
IdUsuario = usuarioOrigen.IdUsuario,
EsOwner = false,
Fecha = DateTime.Now
};
chat.ChatUsuarioItems.Add(chatUsuario);
chat.ChatUsuarioItems.Add(chatUsuarioDestino);
context.Add(chat);
context.SaveChanges();
}
}
public KeyValuePair <int, string> CheckIfAtleastOneEntitywithPasscode(List <ChatSessionEntity> entityListRecognized)
{
ChatEntity entity = db.ChatEntity.Where(x => x.ChatIntentId == Node && x.EntityType.Contains("PASSCODE")).FirstOrDefault();
HttpContext httpContext = HttpContext.Current;
ChatSessionEntity entityRecognized = entityListRecognized.Where(x => x.EntityType.Contains("PASSCODE")).FirstOrDefault();
if (Message.ToLower() == "apollo")
{
ChatIntent passwordIntent = db.ChatIntent.Where(x => x.ChatIntentId == Node).FirstOrDefault();
Message = passwordIntent.Response;
Node = passwordIntent.ChatIntentId;
httpContext.Session[passwordIntent.ChatIntentId.ToString()] = null;
httpContext.Session["auth"] = true;
ChatSession chatSession = db.ChatSession.Where(x => x.SessionId == SessionId).FirstOrDefault();
chatSession.isAuth = true;
ChatSessionEntity chatSessionEntity = db.ChatSessionEntity.Where(x => x.SessionEntId == entityRecognized.SessionEntId).FirstOrDefault();
chatSessionEntity.EntityType = "recog";
chatSessionEntity.NotRecognized = false;
db.SaveChanges();
int authIntentId = (chatSession.IntentBeforeAuth != null) ? chatSession.IntentBeforeAuth.Value : 0;
if (authIntentId != 0)
{
ChatIntent authIntent = db.ChatIntent.Where(x => x.ChatIntentId == authIntentId).FirstOrDefault();
Node = authIntent.ChatIntentId;
Message = authIntent.Response;
}
return(new KeyValuePair <int, string>(Node, Message));
}
else
{
httpContext.Session[Node.ToString()] = entityListRecognized;
return(new KeyValuePair <int, string>(Node, entity.EntityDescription));
}
}
public void ShouldGetChatMessages()
{
//Given
const int userId = 123;
const int colocutorId = 124;
const int chatId = 1;
var userChat = new ChatEntity {
Id = chatId, UserId1 = userId, UserId2 = colocutorId
};
var messageEntity = new MessageEntity()
{
Id = 1, ChatId = chatId, Content = "Content", SentBy = userId, SentDateTime = DateTime.Now
};
var messageEntities = new List <MessageEntity>()
{
messageEntity
};
_chatRepositoryMock.Setup(_ => _.GetChatById(chatId)).Returns(userChat);
_chatRepositoryMock.Setup(_ => _.GetMessages(chatId)).Returns(messageEntities);
//When
var messageResponses = _chatService.GetChatMessages(userId, chatId);
//Then
messageResponses.Count.Should().Be(messageEntities.Count);
messageResponses[0].Id.Should().Be(messageEntity.Id);
messageResponses[0].Content.Should().Be(messageEntity.Content);
messageResponses[0].SenderId.Should().Be(messageEntity.SentBy);
messageResponses[0].ReceiverId.Should().Be(colocutorId);
}
private void UpdateState(object e)
{
e.Match().With <ChatCreatedEvent>(x =>
{
State = new ChatEntity(x.Id);
State.Participants = x.Participants;
Context.Become(Initialized);
if (!IsRecovering)
{
ResendToView(x);
foreach (var user in x.Participants)
{
var envelop = new ShardEnvelope(user.Id.ToString(), x);
_userRegion.Tell(envelop);
}
}
});
e.Match().With <ChatMessageAddedEvent>(x =>
{
var chatLogEntity = new ChatLogEntity(x.MessageId, x.Author, x.Message, DateTime.UtcNow);
State.Log.Add(chatLogEntity);
if (!IsRecovering)
{
ResendToView(x);
foreach (var user in State.Participants)
{
var envelop = new ShardEnvelope(user.Id.ToString(), x);
_userRegion.Tell(envelop);
}
}
});
}
public void ShouldSaveMessage()
{
//Given
const int senderId = 123;
const int colocutorId = 124;
const int chatId = 1;
var sendMessageRequest = new SendMessageRequest {
ChatId = chatId, Content = "Content"
};
var userChat = new ChatEntity {
Id = chatId, UserId1 = senderId, UserId2 = colocutorId
};
var messageEntity = new MessageEntity
{
Id = 12, Content = sendMessageRequest.Content, SentDateTime = DateTime.Now, SentBy = senderId
};
_chatRepositoryMock.Setup(_ => _.GetChatById(chatId)).Returns(userChat);
_chatRepositoryMock.Setup(_ => _.SaveMessage(userChat.Id, senderId, sendMessageRequest.Content))
.Returns(messageEntity);
//When
var messageResponse = _chatService.SaveMessage(senderId, sendMessageRequest);
//Then
messageResponse.Id.Should().Be(messageEntity.Id);
messageResponse.Content.Should().Be(messageEntity.Content);
messageResponse.ReceiverId.Should().Be(colocutorId);
}
public async Task <Chat> Handle(JoinChatCommand request, CancellationToken cancellationToken)
{
var chat = await unitOfWork.GetSingleAsync <ChatEntity>(c => c.Stock == request.Stock);
if (chat == null)
{
chat = new ChatEntity()
{
Stock = request.Stock, OwnerNickname = request.Nickname, CreateDate = dateTime.Now
};
await unitOfWork.AddAndSaveAsync(chat);
await mediator.Publish(new ChatCreatedEvent(request.Nickname, request.Stock), cancellationToken);
}
if (!(await unitOfWork.AnyAsync <ChatParticipantEntity>(p => p.Stock == request.Stock && p.Nickname == request.Nickname)))
{
await unitOfWork.AddAndSaveAsync(new ChatParticipantEntity()
{
Stock = request.Stock, Nickname = request.Nickname
});
await mediator.Publish(new UserJoinedChatEvent(request.Nickname, request.Stock));
}
return(chat);
}
/// <summary>
/// Criar um novo chat
/// </summary>
/// <param name="name">Nome do chat</param>
/// <param name="description">Descrição do chat</param>
/// <returns></returns>
public async Task <ChatEntity> NewChatAsync(string name, string description)
{
try
{
var checkChat = await _datasetChat.FirstOrDefaultAsync(p => p.Name.ToUpper() == name.ToUpper());
if (checkChat == null)
{
var newChat = new ChatEntity()
{
Name = name,
Description = description
};
await _datasetChat.AddAsync(newChat);
_context.SaveChanges();
return(newChat);
}
return(null);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task AddLastReadChatMessage(ChatEntity chatEntity, Guid personUid, long messageId)
{
using (var context = _dbContextFactory.CreateDbContext())
{
if (chatEntity.IsGroupChat.HasValue && chatEntity.IsGroupChat.Value)
{
var entity = await context.PersonToEventEntities
.Include(x => x.Event)
.Include(x => x.Person)
.SingleOrDefaultAsync(x => x.Person.PersonUid == personUid && x.Event.ChatId == chatEntity.ChatId);
if (!entity.LastReadChatMessageId.HasValue || entity.LastReadChatMessageId < messageId)
{
entity.LastReadChatMessageId = messageId;
context.PersonToEventEntities.Update(entity);
await context.SaveChangesAsync();
}
}
else if (chatEntity.IsGroupChat.HasValue && !chatEntity.IsGroupChat.Value)
{
var entity = await context.PersonToChatEntities
.Include(x => x.FirstPerson)
.SingleOrDefaultAsync(x => x.ChatId == chatEntity.ChatId && x.FirstPerson.PersonUid == personUid);
if (!entity.LastReadChatMessageId.HasValue || entity.LastReadChatMessageId < messageId)
{
entity.LastReadChatMessageId = messageId;
context.PersonToChatEntities.Update(entity);
await context.SaveChangesAsync();
}
}
}
}
public override object ExecuteCommand(InCourseRequest inCourseRequest)
{
int IdChat = ChatHelper.CrearChat(Nombre, EsGrupo);
ChatEntity chat = this.context.Chats.Find(IdChat);
if (chat != null)
{
foreach (string idUsuario in Usuarios.Split(','))
{
ChatUsuarioEntity request = new ChatUsuarioEntity()
{
IdUsuario = short.Parse(idUsuario),
Fecha = DateTime.Now,
EsOwner = false,
IdChat = IdChat
};
this.AgregarAlContextoParaAlta(request);
}
ChatUsuarioEntity owner = new ChatUsuarioEntity()
{
IdUsuario = IdUsuario,
Fecha = DateTime.Now,
EsOwner = EsGrupo,//Si es grupo es el owner, sino, no, por ser chat individual.
IdChat = IdChat
};
this.AgregarAlContextoParaAlta(owner);
}
ChatHelper.InformarNuevoGrupo(chat, Usuarios, IdUsuario);
return(null);
}
private string ExtractedEntityPhone(ChatEntity entity)
{
string phone = new string(Message.Where(Char.IsDigit).ToArray());
HttpContext context = HttpContext.Current;
context.Session[entity.EntityName] = phone;
return(phone);
}
private string ExtractedEntityDateTime(ChatEntity entity)
{
string schedule = Message;
HttpContext context = HttpContext.Current;
context.Session[entity.EntityName] = schedule;
return(schedule);
}
public void ToEntity_DefaulInitModel_DefaultInitEntity()
{
var comparer = GetEntityComparer();
var expected = new ChatEntity();
var model = new ChatModel();
var actual = model.ToEntity();
Assert.Equal(expected, actual, comparer);
}
public static ChatEntity ToEntity(this ChatModel chatModel)
{
var entity = new ChatEntity
{
Name = chatModel.Name,
Id = chatModel.Id,
};
return(entity);
}
public static ChatModel ToModel(this ChatEntity chatEntity)
{
var model = new ChatModel
{
Name = chatEntity.Name,
Id = chatEntity.Id,
};
return(model);
}
public void ToModel_DefaultInitEntity_DefaultInitModel()
{
var comparer = GetModelComparer();
var expected = new ChatModel();
var entity = new ChatEntity();
var actual = entity.ToModel();
Assert.Equal(expected, actual, comparer);
}
public IChatAspect Map(ChatEntity entity)
{
return(new ChatAspect
{
Content = entity.content,
CreatedBy = new UserReference(entity.createdBy),
CreatedOn = entity.createdOn,
Reference = new ChatReference(entity.chatId),
Room = new RoomReference(entity.roomId)
});
}
public long InitiateChatWithUser(long userId, long collocutorId)
{
ChatEntity chatEntity = _repository.GetChatByUsers(userId, collocutorId);
if (chatEntity == null)
{
chatEntity = _repository.CreateChat(userId, collocutorId);
}
return(chatEntity.Id);
}
public ChatPage(ChatEntity entity)
{
InitializeComponent();
if (statusBrushCache.Count == 0)
{
statusBrushCache.Add(OnlineStatusCategory.Online, new SolidColorBrush(Color.FromRgb(27, 195, 63)));
statusBrushCache.Add(OnlineStatusCategory.Away, new SolidColorBrush(Color.FromRgb(228, 192, 62)));
statusBrushCache.Add(OnlineStatusCategory.Busy, new SolidColorBrush(Color.FromRgb(195, 55, 4)));
statusBrushCache.Add(OnlineStatusCategory.Invisible, new SolidColorBrush(Color.FromRgb(180, 180, 180)));
}
ChangeEntity(entity);
}
public ChatPage(ChatEntity entity)
{
InitializeComponent();
if (statusBrushCache.Count == 0)
{
statusBrushCache.Add(OnlineStatusCategory.Online, new SolidColorBrush(Color.FromRgb(27, 195, 63)));
statusBrushCache.Add(OnlineStatusCategory.Away, new SolidColorBrush(Color.FromRgb(228, 192, 62)));
statusBrushCache.Add(OnlineStatusCategory.Busy, new SolidColorBrush(Color.FromRgb(195, 55, 4)));
statusBrushCache.Add(OnlineStatusCategory.Invisible, new SolidColorBrush(Color.FromRgb(180, 180, 180)));
}
ChangeEntity(entity);
}
public void ShouldReturnCorrectUserChatResponse()
{
//Given
const int userId = 123;
const int userId2 = 124;
var userChat = new ChatEntity {
Id = 1, UserId1 = userId, UserId2 = userId2
};
var chatEntities = new List <ChatEntity>()
{
userChat
};
var latestMessageOne = new MessageEntity {
ChatId = userChat.Id
};
var userOne = new User {
Id = userId, Name = "Test1"
};
var userTwo = new User {
Id = userId2, Name = "Test2"
};
_chatRepositoryMock.Setup(_ => _.GetChatsByUser(userId)).Returns(chatEntities);
_chatRepositoryMock.Setup(_ => _.GetLatestMessages(new List <long>()
{
userChat.Id
}))
.Returns(new List <MessageEntity>()
{
latestMessageOne
});
_userRepositoryMock.Setup(_ => _.FindUsers(new List <long>()
{
userId2
}))
.Returns(new List <User>()
{
userTwo
});
//When
var userChatResponses = _chatService.GetUserChats(userId);
//Then
userChatResponses.Count.Should().Be(chatEntities.Count);
userChatResponses[0].ChatId.Should().Be(userChat.Id);
}
public void ShouldInitiateExistedChatWithUser()
{
//Given
const int userId = 123;
const int colocutorId = 124;
var userChat = new ChatEntity {
Id = 1, UserId1 = userId, UserId2 = colocutorId
};
_chatRepositoryMock.Setup(_ => _.GetChatByUsers(userId, colocutorId)).Returns(userChat);
//When
var userChatId = _chatService.InitiateChatWithUser(userId, colocutorId);
//Then
userChatId.Should().Be(userChat.Id);
}
public JsonResult EntityUpdate(EntityOperation entOperation)
{
EntitytDto entitydto = entOperation.entity;
string operation = entOperation.Operation;
ChatEntity entity = new ChatEntity();
bool changed = false;
entity.UpdatedDate = DateTime.UtcNow;
try
{
if (operation == "a")
{
entity.EntityName = entitydto.EntityName;
entity.EntityDescription = entitydto.EntityDescription;
entity.EntityType = entitydto.EntityType;
entity.ChatIntentId = entitydto.ChatIntentId;
entity.UpdatedDate = DateTime.Now;
db.ChatEntity.Add(entity);
}
else if (operation == "u")
{
entity = db.ChatEntity.Where(x => x.ChatEntityId == entitydto.ChatEntityId).FirstOrDefault();
entity.EntityName = entitydto.EntityName;
entity.EntityDescription = entitydto.EntityDescription;
entity.EntityType = entitydto.EntityType;
entity.ChatIntentId = entitydto.ChatIntentId;
entity.UpdatedDate = DateTime.Now;
}
else
{
entity = db.ChatEntity.Where(x => x.ChatEntityId == entitydto.ChatEntityId).FirstOrDefault();
db.ChatEntity.Attach(entity);
db.ChatEntity.Remove(entity);
}
changed = true;
db.SaveChanges();
return(Json(changed, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(Json(changed, JsonRequestBehavior.AllowGet));
}
}
public static void InformarNuevoGrupo(ChatEntity chat, string usuarios, int idOwner)
{
//agrego el owner a participantes
usuarios += "," + idOwner.ToString();
DTONuevoChat nuevoChat = new DTONuevoChat()
{
IdChat = chat.IdChat,
Nombre = chat.Nombre,
Participantes = usuarios.Split(',').Select(x => new DTOUsuario()
{
IdUsuario = int.Parse(x)
}).ToList(),
IdOwner = idOwner,
Fecha = chat.Fecha
};
WCFHelper.ExecuteService <IChatService>(ConfiguracionSistemaURLsEnumDestino.ChatService, i => i.InformarNuevoGrupo(nuevoChat));
}
public void ToModel_InitEntity_InitModel()
{
var comparer = GetModelComparer();
var expected = new ChatModel
{
Id = 1,
Name = "ChatName"
};
var entity = new ChatEntity
{
Id = 1,
Name = "ChatName",
Messages = null
};
var actual = entity.ToModel();
Assert.Equal(expected, actual, comparer);
}
public async Task <ChatEntity> CreateChatAsync(string ids, string name)
{
ChatEntity chat = new ChatEntity();
chat.Name = name;
await this.chatRepository.AddAsync(chat);
int [] profileIds = ids.Split(',').Select(x => int.Parse(x)).ToArray();
chat.ProfileRelations = new List <ProfileChatRelationEntity>();
foreach (int id in profileIds)
{
ProfileChatRelationEntity profileRelation = new ProfileChatRelationEntity();
profileRelation.ProfileId = id;
profileRelation.ChatId = chat.Id;
chat.ProfileRelations.Add(profileRelation);
}
this.chatRepository.Save();
return(chat);
}
public MessageResponse SaveMessage(long senderId, SendMessageRequest sendMessageRequest)
{
ChatEntity chatEntity = _repository.GetChatById(sendMessageRequest.ChatId);
if (chatEntity == null)
{
throw new Exception("Chat not found");
}
var message = _repository.SaveMessage(chatEntity.Id, senderId, sendMessageRequest.Content);
return(new MessageResponse
{
Id = message.Id,
Content = message.Content,
SendTime = message.SentDateTime,
SenderId = message.SentBy,
ReceiverId = GetCollocutorId(chatEntity, message.SentBy)
});
}
public List <MessageResponse> GetChatMessages(long userId, long chatId)
{
ChatEntity chatEntity = _repository.GetChatById(chatId);
if (chatEntity == null || (chatEntity.UserId1 != userId && chatEntity.UserId2 != userId))
{
throw new Exception("Chat not found");
}
return(_repository.GetMessages(chatId)
.Select(me => new MessageResponse
{
Id = me.Id,
Content = me.Content,
SendTime = me.SentDateTime,
SenderId = me.SentBy,
ReceiverId = GetCollocutorId(chatEntity, me.SentBy)
})
.OrderBy(mr => mr.SendTime)
.ToList());
}
public string EntityPatternMatch(ChatEntity entity)
{
string extractedEntityMatch = string.Empty;
if (entity.EntityName.Contains("phone"))
{
extractedEntityMatch = ExtractedEntityPhone(entity);
}
else if (entity.EntityName.Contains("email"))
{
extractedEntityMatch = ExtractedEntityEmail(entity);
}
else if (entity.EntityName.Contains("datetime"))
{
extractedEntityMatch = ExtractedEntityDateTime(entity);
}
else if (entity.EntityName.Contains("city"))
{
extractedEntityMatch = ExtractedEntityCity(entity);
}
return(extractedEntityMatch);
}
public async Task <List <PersonEntity> > GetChatMembers(ChatEntity chat)
{
using (var context = _dbContextFactory.CreateDbContext())
{
if (chat.IsGroupChat.HasValue && chat.IsGroupChat.Value)
{
return(await context.PersonToEventEntities
.Include(x => x.Event)
.Include(x => x.Person)
.Where(x => x.Event.ChatId == chat.ChatId && x.ParticipantStatusId == (long)ParticipantStatus.Active)
.Select(x => x.Person)
.ToListAsync());
}
else
{
return(await context.PersonToChatEntities
.Include(x => x.FirstPerson)
.Where(x => x.ChatId == chat.ChatId)
.Select(x => x.FirstPerson)
.ToListAsync());
}
}
}
public EntityIdentifiedDto HasOneChildIntentWithOneEntity(ChatEntity entity, ChatIntent intent)
{
var hasEntity = db.ChatEntity.Where(x => x.ChatIntentId == Node);
EntityIdentifiedDto dto = new EntityIdentifiedDto();
string finalResponse = string.Empty;
HttpContext context = HttpContext.Current;
finalResponse = intent.Response;
dto.EntityName = entity.EntityName;
dto.EntityValue = EntityPatternMatch(entity);
dto.MatchConfidence = "high";
dto.ChatResponse = finalResponse;
dto = SetEntityinResponse(dto);
//phoneNumber = (context.Session["phone"] != null ? context.Session["phone"].ToString() : "980 000 000");
//message = (context.Session["datetime"] != null ? context.Session["datetime"].ToString() : "12:00 AM EST");
//finalResponse = finalResponse.Replace("paramphonenumber", phoneNumber);
//finalResponse = finalResponse.Replace("paramappointmenttime", message);
//dto.ChatResponse = finalResponse;
return(dto);
}
public async Task <Guid> CreatePersonalChat(Guid firstPersonUid, Guid secondPersonUid)
{
using (var context = _dbContextFactory.CreateDbContext())
{
var chatUid = Guid.NewGuid();
var firstPerson = await context.PersonEntities.SingleAsync(x => x.PersonUid == firstPersonUid);
var secondPerson = await context.PersonEntities.SingleAsync(x => x.PersonUid == secondPersonUid);
var chat = new ChatEntity {
ChatUid = chatUid, IsGroupChat = false
};
await context.ChatEntities.AddAsync(chat);
await context.PersonToChatEntities.AddAsync(new PersonToChatEntity { FirstPerson = firstPerson, SecondPerson = secondPerson, Chat = chat });
await context.PersonToChatEntities.AddAsync(new PersonToChatEntity { FirstPerson = secondPerson, SecondPerson = firstPerson, Chat = chat });
await context.SaveChangesAsync();
return(chatUid);
}
}
public void ChangeEntity(ChatEntity newEntity)
{
if (entity != null)
{
// TODO: Prevent the selection state for the listbox from being reset
if (entity is Group && groupMembersListBox != null)
{
MainGrid.Children.Remove(groupMembersListBox);
groupMembersListBox = null;
}
else if (entity is User && statusLabel != null)
{
MainGrid.Children.Remove(statusLabel);
statusLabel = null;
}
}
entity = newEntity;
if (entity != null)
{
if (entity is Group)
{
groupMembersListBox = new ListBox()
{
Background = Brushes.Transparent,
Margin = new Thickness(5),
HorizontalAlignment = HorizontalAlignment.Stretch,
VerticalAlignment = VerticalAlignment.Stretch,
};
ContactPanel.Children.Add(groupMembersListBox);
var statusOrder = new List<OnlineStatusCategory>(new OnlineStatusCategory[] { OnlineStatusCategory.Online, OnlineStatusCategory.Away, OnlineStatusCategory.Busy, OnlineStatusCategory.Invisible, OnlineStatusCategory.Unknown });
var group = entity as Group;
var sortedMembers = new List<User>(group.Members.Values);
sortedMembers.Sort((_1, _2) =>
{
int comparison = statusOrder.IndexOf(_2.OnlineStatus.Category) - statusOrder.IndexOf(_1.OnlineStatus.Category);
if (comparison == 0)
comparison = (_1.DisplayName ?? _1.Name).CompareTo(_2.DisplayName ?? _2.Name);
return comparison;
});
foreach (var member in sortedMembers)
{
var item = new ListBoxItem()
{
Content = member.DisplayName ?? member.Name,
FontSize = 16,
Foreground = statusBrushCache[member.OnlineStatus.Category],
Padding = new Thickness(4),
};
groupMembersListBox.Items.Add(item);
}
}
else if (entity is User)
{
var user = entity as User;
statusLabel = new Label()
{
Content = user.OnlineStatus.Display,
Foreground = statusBrushCache[user.OnlineStatus.Category],
FontWeight = FontWeights.Light,
HorizontalAlignment = HorizontalAlignment.Center,
};
ContactPanel.Children.Add(statusLabel);
}
}
}
