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 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); } } }