public async Task <bool> IsChatExist(User user, User companion, MessageModel message)
{
var existChat = _context.ChatsForTwo.FirstOrDefault(x =>
(String.Equals(x.FirstUserId, user.Id) && String.Equals(x.SecondUserId, companion.Id)) ||
(String.Equals(x.FirstUserId, companion.Id) && String.Equals(x.SecondUserId, user.Id)) &&
x.Chat.IsDeleted
);
if (ReferenceEquals(existChat, null))
{
return(false);
}
existChat.Chat.IsDeleted = false;
_context.SaveChanges();
message.ChatId = existChat.ChatId;
var newChat = new ChatListModel()
{
ChatId = existChat.Id,
ChatName = companion.UserName,
ChatEnum = ChatEnum.ChatForTwo
};
await _hubContext.Clients.User(user.Id).SendAsync("NewChat", newChat);
newChat.ChatName = user.UserName;
await _hubContext.Clients.User(companion.Id).SendAsync("NewChat", newChat);
return(true);
}
private async Task <ChatListModel> GetChatListOfTeacher(int teacherId)
{
// find available courses of teacher
var lessonsOfTeacher = await _ablemusicContext.Lesson
.Where(x => x.TeacherId == teacherId && x.IsCanceled == 0 && x.IsTrial == 0 && x.EndTime >= DateTime.Now)
.Select(x => new
{
x.LessonId, x.LearnerId, x.OrgId, x.TeacherId, x.CourseInstanceId, x.GroupCourseInstanceId
})
.ToListAsync();
if (lessonsOfTeacher == null)
{
throw new Exception("No courses for this teacher right now");
}
// add data to return
var lessonList = SeparateCourseIntoGroups(lessonsOfTeacher);
ChatListModel chatList = new ChatListModel
{
OneToOneCourseList = lessonList["oneToOneLessons"],
OneToManyCourseList = lessonList["groupLessons"],
StaffList = await GetAllStaff(null)
};
return(chatList);
}
public async Task <ChatListModel> GetChatListAsync()
{
List <ChatWithNestedObjects> chatsWithNestedObjects = await _chatRepository.GetWithNestedObjectsAsync();
ChatListModel chatListModel = new ChatListModel(chatsWithNestedObjects);
return(chatListModel);
}
public async Task <string> CreateGroup(GroupModel groupModel)
{
var user = await _userManager.FindByNameAsync(Thread.CurrentPrincipal.Identity.Name);
List <string> userList = new List <string>();
userList.Add(user.Id);
var chat = new Chat {
ChatName = groupModel.Name, ChatType = ChatEnum.ChatForGroup, CreatorId = user.Id, Created = DateTime.Now
};
_context.Chats.Add(chat);
_context.Entry(chat).State = EntityState.Added;
var chatForGroup = new ChatForGroup()
{
ChatId = chat.Id,
IsPublic = groupModel.IsPublic,
CreatorMode = groupModel.CreatorMode
};
AddGroupPhoto(groupModel, chatForGroup);
_context.ChatsForGroup.Add(chatForGroup);
_context.Entry(chatForGroup).State = EntityState.Added;
_context.GroupsUsers.Add(new GroupsUsers()
{
GroupId = chatForGroup.Id, UserId = user.Id
});
foreach (var item in groupModel.Users)
{
var id = (await _userManager.FindByNameAsync(item)).Id;
userList.Add(id);
_context.GroupsUsers.Add(new GroupsUsers()
{
GroupId = chatForGroup.Id, UserId = id
});
}
await _context.SaveChangesAsync();
var newChat = new ChatListModel()
{
ChatId = chat.Id,
ChatName = groupModel.Name,
ChatEnum = ChatEnum.ChatForGroup,
PhotoPath = groupModel.PhotoPath
};
await _hubContext.Clients.Users(userList).SendAsync("NewChat", newChat);
return(chat.Id);
}
public Chat(ChatListModel Chatdetails)
{
InitializeComponent();
BindingContext = Chatdetails;
this.Chatdetails = Chatdetails;
PostId = this.Chatdetails.Post_id;
ConversationID = this.Chatdetails.id;
/*_chatViewmodel = new ChatViewmodel();
* BindingContext = this._chatViewmodel;*/
}
private async Task <ChatListModel> GetChatListOfStaff(int staffId)
{
// find org of this stuff
var orgIdOfStaff = await _ablemusicContext.StaffOrg.Where(x => x.StaffId == staffId).Select(x => x.OrgId)
.FirstOrDefaultAsync();
if (orgIdOfStaff == null)
{
throw new Exception("Staff's orgId not found");
}
// Students having lesson in his org
var studentsIdHavingLesson = await _ablemusicContext.Lesson.Where(x => x.OrgId == orgIdOfStaff)
.Include(x => x.Learner).Select(x => new
{
x.Learner.LearnerId,
x.Learner.FirstName,
x.Learner.LastName,
x.Learner.UserId,
x.Learner.Photo
}).Where(x => x.UserId != null).Distinct().ToListAsync();
// students registered in his org
var studentsRegisteredIn = await _ablemusicContext.Learner.Where(x => x.OrgId == orgIdOfStaff).Select(x => new
{
x.LearnerId,
x.FirstName,
x.LastName,
x.UserId,
x.Photo
}).Where(x => x.UserId != null).Distinct().ToListAsync();
// combine data
ChatListModel chatListModel = new ChatListModel
{
StaffList = await GetAllStaff(staffId),
TeacherList = await GetAllTeacher(),
LearnerList = studentsIdHavingLesson.Union(studentsRegisteredIn).Distinct().ToList()
};
return(chatListModel);
}
public async void CreateNewChat(User user, User companion, MessageModel message)
{
var chat = new Chat()
{
ChatType = ChatEnum.ChatForTwo,
CreatorId = user.Id,
Created = DateTime.Now
};
var chatForTwo = new ChatForTwo()
{
FirstUserId = user.Id,
SecondUserId = companion.Id,
Chat = chat
};
_context.Chats.Add(chat);
_context.ChatsForTwo.Add(chatForTwo);
_context.Entry(chat).State = EntityState.Added;
_context.SaveChanges();
// logger.Debug($"User {Context.User.Identity.Name} create chat {chat.Id}, chat type - {chat.ChatType.ToString()}");
message.ChatId = chat.Id;
var newChat = new ChatListModel()
{
ChatId = chat.Id,
ChatName = companion.UserName,
ChatEnum = ChatEnum.ChatForTwo
};
await _hubContext.Clients.User(user.Id).SendAsync("NewChat", newChat);
newChat.ChatName = user.UserName;
await _hubContext.Clients.User(companion.Id).SendAsync("NewChat", newChat);
}
private async void OnHistoryTappedAsync(object sender, ItemTappedEventArgs e)
{
ChatListModel Chatdetails = (ChatListModel)e.Item;
await Navigation.PushAsync(new Chat(Chatdetails));
}
public async Task <MessageModel> SendMessage(MessageModel message)
{
var user = await _userManager.FindByNameAsync(Thread.CurrentPrincipal.Identity.Name);
if (ReferenceEquals(message.ChatId, null))
{
var companion = await _userManager.FindByNameAsync(message.ToChatName);
if (!(await _chat.IsChatExist(user, companion, message)))
{
_chat.CreateNewChat(user, companion, message);
}
}
FileDb fileDb = null;
if (!ReferenceEquals(message.File, null))
{
fileDb = new FileDb();
fileDb.FilePath = message.File.FileFullName;
fileDb.IsImage = message.File.IsImage;
fileDb.IsAudio = message.File.IsVoice;
fileDb.IsVideo = message.File.IsVideo;
_context.Files.Add(fileDb);
_context.Entry(fileDb).State = EntityState.Added;
}
var dbMessage = new Message()
{
ChatId = message.ChatId,
Content = message.Content,
UserId = user.Id,
File = ReferenceEquals(message.File, null) ? null : fileDb?.Id,
Created = DateTime.Now
};
_context.Messages.Add(dbMessage);
_context.Entry(dbMessage).State = EntityState.Added;
await _context.SaveChangesAsync();
message.MessageId = dbMessage.Id;
message.DateCreate = dbMessage.Created;
var dbCurrentStatusMessage = new MessageStatus()
{
MessageId = dbMessage.Id,
IsRead = true,
UserId = user.Id,
};
_context.MessagesStatus.Add(dbCurrentStatusMessage);
if ((await _context.Chats.FindAsync(message.ChatId)).ChatType == ChatEnum.ChatForTwo)
{
var chatForTwo = _context.ChatsForTwo.FirstOrDefault(x => String.Equals(x.ChatId, message.ChatId));
var dbCompanionStatusMessage = new MessageStatus()
{
MessageId = dbMessage.Id,
UserId = String.Equals(Thread.CurrentPrincipal.Identity.Name, chatForTwo.FirstUser.UserName) ? chatForTwo.SecondUser.Id : chatForTwo.FirstUser.Id
};
_context.MessagesStatus.Add(dbCompanionStatusMessage);
message.ToChatName = String.Equals(user.UserName, chatForTwo.FirstUser.UserName) ? chatForTwo.FirstUser.UserName : chatForTwo.SecondUser.UserName;
await _hubContext.Clients.User(dbCompanionStatusMessage.UserId).SendAsync("ReceiveMessage", message);
message.ToChatName = user.UserName;
}
else
{
var chatForGroup = _context.ChatsForGroup.FirstOrDefault(x => String.Equals(x.ChatId, message.ChatId));
var sorted = chatForGroup.GroupsUsers.Where(x => !String.Equals(user.Id, x.UserId)).Select(x => x.UserId);
if (!chatForGroup.GroupsUsers.Any(x => String.Equals(user.Id, x.UserId)))
{
_context.GroupsUsers.Add(new GroupsUsers()
{
GroupId = chatForGroup.Id, UserId = user.Id
});
var newChat = new ChatListModel()
{
ChatId = chatForGroup.ChatId,
ChatName = chatForGroup.Chat.ChatName,
ChatEnum = ChatEnum.ChatForGroup
};
await _hubContext.Clients.User(user.Id).SendAsync("NewChat", newChat);
}
foreach (var userId in sorted)
{
var dbCompanionStatusMessage = new MessageStatus()
{
MessageId = dbMessage.Id,
UserId = userId
};
_context.MessagesStatus.Add(dbCompanionStatusMessage);
}
await _hubContext.Clients.Users(sorted.ToList()).SendAsync("ReceiveMessage", message);
}
await _context.SaveChangesAsync();
message.IsMyMessage = true;
return(message);
}
public async Task GetChatsList()
{
ChatListModel chatListModel = await _chatService.GetChatListAsync();
await Clients.Group("admin").SendAsync("chatListReceive", chatListModel);
}
