public HttpResponseMessage CreateNewGroup(CreateChatGroupModel model)
{
if (model != null && ModelState.IsValid)
{
var chatGroup = new ChatGroup
{
GroupName = model.GroupName,
OwnerId = new Guid(model.OwnerId)
};
var userChatGroup = new UserChatGroup
{
GroupId = new Guid(chatGroup.GroupId.ToString()),
UserId = new Guid(model.OwnerId)
};
_dataContext.ChatGroups.Add(chatGroup);
_dataContext.UserChatGroups.Add(userChatGroup);
_dataContext.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.Accepted, chatGroup.GroupId));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "invalid data"));
}
public async Task <IActionResult> FindMessageChats(int ID)
{
var currentUser = await _userManager.GetUserAsync(User);
var RequestedUser = unitOfWork.GGUsers.GetUser(ID);
var chatGroup = await unitOfWork.db.ChatGroups
.Where(cg =>
cg.UserChatGroups.Any(ucg => ucg.UserId == currentUser.Id) &&
cg.UserChatGroups.Any(ucg => ucg.UserId == RequestedUser.Id))
.Include(cg => cg.Messages)
.FirstOrDefaultAsync();
if (chatGroup == null)
{
chatGroup = new ChatGroup()
{
Name = RequestedUser.NickName,
UserChatGroups = new List <UserChatGroup>(),
Messages = new List <Message>()
};
var chatGroupRelation1 = new UserChatGroup()
{
User = currentUser,
Group = chatGroup
};
var chatGroupRelation2 = new UserChatGroup()
{
User = RequestedUser,
Group = chatGroup
};
chatGroup.UserChatGroups.Add(chatGroupRelation1);
chatGroup.UserChatGroups.Add(chatGroupRelation2);
unitOfWork.db.ChatGroups.Add(chatGroup);
await unitOfWork.Save();
chatGroup = await unitOfWork.db.ChatGroups
.Where(cg =>
cg.UserChatGroups.Any(ucg => ucg.UserId == currentUser.Id) &&
cg.UserChatGroups.Any(ucg => ucg.UserId == RequestedUser.Id))
.Include(cg => cg.Messages)
.FirstOrDefaultAsync();
}
var viewModel = new ChatGroupVM {
Group = chatGroup, CurrentUserNickName = currentUser.NickName, CurrentMessageChatID = chatGroup.Id
};
return(PartialView("_ChatBox", viewModel));
}
/// <summary>
/// Creates an admin for the system
/// </summary>
/// <param name="context"></param>
/// <param name="userManager"></param>
/// <returns></returns>
private static async Task CreateAdminAsync(ApplicationDbContext context, UserManager <ApplicationUser> userManager, RoleOptions roleOptions)
{
var admin = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Admin",
LastName = "1",
IsActive = true,
EmailConfirmed = true
};
string password = userManager.PasswordHasher.HashPassword(admin, "Password1");
admin.PasswordHash = password;
await userManager.CreateAsync(admin);
await context.SaveChangesAsync();
await userManager.AddToRoleAsync(admin, roleOptions.AdminRole);
await context.SaveChangesAsync();
// Add admin to all chatgroups
List <ChatGroup> groups = context.ChatGroups.ToList();
List <UserChatGroup> adminChatGrups = new List <UserChatGroup>();
foreach (ChatGroup group in groups)
{
UserChatGroup gr = new UserChatGroup
{
UserId = admin.Email,
ChatGroupId = group.ChatGroupId
};
adminChatGrups.Add(gr);
}
await context.AddRangeAsync(adminChatGrups);
await context.SaveChangesAsync();
}
public HttpResponseMessage AddUserToChatGroup(AddUserToChatGroupModel model)
{
if (model != null && ModelState.IsValid)
{
var users = model.UsersId.Split('_');
foreach (var userId in users)
{
var userChatGroup = new UserChatGroup
{
GroupId = new Guid(model.GroupId),
UserId = new Guid(userId)
};
_dataContext.UserChatGroups.Add(userChatGroup);
}
_dataContext.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.Accepted, ""));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "invalid data"));
}
public async Task <string> CreateUsersGroupAsync(ApplicationUser sender, ApplicationUser receiver, string groupName)
{
var isGroupAlreadyCreated = await this.chatGroupsRepository
.All()
.AnyAsync(cg => cg.Name == groupName);
if (isGroupAlreadyCreated)
{
var groupId = this.chatGroupsRepository
.All()
.FirstOrDefault(cg => cg.Name == groupName)
.Id;
return(groupId);
}
var chatGroup = new ChatGroup()
{
Name = groupName,
};
var userChatGroup = new UserChatGroup()
{
ChatGroupId = chatGroup.Id,
Client = sender,
Admin = receiver,
};
await this.chatGroupsRepository.AddAsync(chatGroup);
await this.userChatGroupsRepository.AddAsync(userChatGroup);
await this.chatGroupsRepository.SaveChangesAsync();
await this.userChatGroupsRepository.SaveChangesAsync();
return(chatGroup.Id);
}
public async Task <IActionResult> ChatWith(int currentUserId, int requestedUserID)
{
var followRelation1 = unitOfWork.FollowRelations.GetFollowRelationOfTwoUsers(currentUserId, requestedUserID);
var followRelation2 = unitOfWork.FollowRelations.GetFollowRelationOfTwoUsers(requestedUserID, currentUserId);
if (followRelation1 == null || followRelation2 == null)
{
return(NotFound());
}
var currentUser = unitOfWork.GGUsers.GetUser(currentUserId);
var RequestedUser = unitOfWork.GGUsers.GetUser(requestedUserID);
var chatGroup = await unitOfWork.db.ChatGroups
.Where(cg =>
cg.UserChatGroups.Any(ucg => ucg.UserId == currentUser.Id) &&
cg.UserChatGroups.Any(ucg => ucg.UserId == RequestedUser.Id))
.Include(cg => cg.Messages)
.FirstOrDefaultAsync();
if (chatGroup == null)
{
chatGroup = new ChatGroup()
{
Name = RequestedUser.NickName,
UserChatGroups = new List <UserChatGroup>(),
Messages = new List <Message>()
};
var chatGroupRelation1 = new UserChatGroup()
{
User = currentUser,
Group = chatGroup
};
var chatGroupRelation2 = new UserChatGroup()
{
User = RequestedUser,
Group = chatGroup
};
chatGroup.UserChatGroups.Add(chatGroupRelation1);
chatGroup.UserChatGroups.Add(chatGroupRelation2);
unitOfWork.db.ChatGroups.Add(chatGroup);
await unitOfWork.Save();
chatGroup = await unitOfWork.db.ChatGroups
.Where(cg =>
cg.UserChatGroups.Any(ucg => ucg.UserId == currentUser.Id) &&
cg.UserChatGroups.Any(ucg => ucg.UserId == RequestedUser.Id))
.Include(cg => cg.Messages)
.FirstOrDefaultAsync();
}
var chatGroupsOfCurrentUser = await unitOfWork.db.UserChatGroups
.Where(ucg => ucg.UserId == currentUser.Id)
.Include(ucg => ucg.Group)
.ThenInclude(g => g.Messages)
.Select(ucg => ucg.Group)
.ToListAsync();
var viewModel = new MessageboardVM(chatGroupsOfCurrentUser, chatGroup.Id, currentUser.NickName);
return(View("MessageBoard", viewModel));
}
public string ReplyToInvitation(int requestId, bool accept)
{
//ελέγχουμε αν υπάρχει κάποιος χρήστης που έχει κάνει login
string userEmail = GetUserEmail();
if (String.IsNullOrEmpty(userEmail))
{
return("NOK");
}
User user = db.Users.Single(x => x.Email == userEmail);
user.Requests = db.Invitations.Where(x => x.SendToUserId == user.Id).ToList();
var request = user.Requests.SingleOrDefault(x => x.Id == requestId);
if (request == null)
{
return("NOK");
}
User requestUser = db.Users.Single(x => x.Id == request.SendFromUserId);
if (accept)
{
var group = new ChatGroup()
{
CreatedAt = DateTime.UtcNow,
LogoURL = "",
Name = ""
};
db.ChatGroups.Add(group);
db.SaveChanges();
var item1 = new UserChatGroup()
{
UserId = user.Id,
ChatGroupId = group.Id
};
db.UserChatGroups.Add(item1);
db.SaveChanges();
var item2 = new UserChatGroup()
{
UserId = requestUser.Id,
ChatGroupId = group.Id
};
db.UserChatGroups.Add(item2);
db.SaveChanges();
}
db.Invitations.Remove(request);
db.SaveChanges();
return("OK");
}
public void SendChatMessage(string chatGroupId, string message, int chatSourceId, string receiverIds, int?fileId = null,
int?taskId = null, int?taskMultilevelListId = null, int?userChatGroupId = null)
{
try
{
if (string.IsNullOrEmpty(receiverIds))
{
ErrorLogBLL.Instance.SaveApplicationError("ChatHub", "ReceiverIds cannot be empty or null", "ReceiverIds cannot be empty or null", "");
Clients.Group(chatGroupId).sendChatMessageCallbackError(new ActionOutput <string>
{
Status = ActionStatus.Successfull,
Object = "ReceiverIds cannot be empty or null",
Message = chatGroupId
});
}
System.Web.HttpContextBase httpContext = Context.Request.GetHttpContext();
//int? UserChatGroupId = ChatBLL.Instance.GetUserChatGroupId(chatGroupId);
string baseurl = httpContext.Request.Url.Scheme + "://" +
httpContext.Request.Url.Authority +
httpContext.Request.ApplicationPath.TrimEnd('/') + "/";
// Getting Logged In UserID from cookie.
// FYI: Sessions are not allowed in SignalR, so have to user some other way to pass information
int SenderUserId = 0;
HttpCookie auth_cookie = httpContext.Request.Cookies[Cookies.UserId];
if (auth_cookie != null)
{
SenderUserId = Convert.ToInt32(auth_cookie.Value);
}
DataRow sender = InstallUserBLL.Instance.getuserdetails(SenderUserId).Tables[0].Rows[0];
// check for {UserTaskStepCompletedText}
if (message == "{UserTaskStepCompletedText}" && taskId.HasValue && taskId.Value > 0)
{
bool newStepCompleted = ChatBLL.Instance.SetTaskStepStatus(taskId.Value, SenderUserId);
if (!newStepCompleted)
{
message = sender["FristName"].ToString() + " " + sender["Lastname"].ToString() + "-" +
"<a href=\"/Sr_App/ViewSalesUser.aspx?id=" + SenderUserId + "\" target=\"_blank\">" + sender["UserInstallID"].ToString() + "</a> has opened their task at " +
DateTime.UtcNow.ToEST().ToString();
}
else
{
message = sender["FristName"].ToString() + " " + sender["Lastname"].ToString() + "-" +
"<a href=\"/Sr_App/ViewSalesUser.aspx?id=" + SenderUserId + "\" target=\"_blank\">" + sender["UserInstallID"].ToString() + "</a> has frozen their task at " +
DateTime.UtcNow.ToEST().ToString();
}
}
// Check for file attachment
if (fileId.HasValue && fileId.Value > 0)
{
ChatFile file = ChatBLL.Instance.GetChatFile(fileId.Value);
message = file.DisplayName + ":-:" + file.SavedName;
}
//add logger
//ChatBLL.Instance.ChatLogger(chatGroupId, message, chatSourceId, SenderUserId, httpContext.Request.UserHostAddress);
string pic = string.IsNullOrEmpty(sender["Picture"].ToString()) ? "default.jpg"
: sender["Picture"].ToString().Replace("~/UploadeProfile/", "");
pic = /*baseUrl +*/ "Employee/ProfilePictures/" + pic;
// Create TaskGroup if taskId is not null and userChatGroupId is null/0
if (taskId.HasValue && taskId.Value > 0 && userChatGroupId.Value <= 0)
{
userChatGroupId = ChatBLL.Instance.CreateTaskChatGroup(taskId.Value, taskMultilevelListId);
}
// Instatiate ChatMessage
ChatMessage chatMessage = new ChatMessage
{
UserChatGroupId = userChatGroupId,
TaskId = taskId,
TaskMultilevelListId = taskMultilevelListId,
Message = message,
FileId = fileId,
ChatSourceId = chatSourceId,
UserId = SenderUserId,
UserProfilePic = pic,
UserFullname = sender["FristName"].ToString() + " " + sender["Lastname"].ToString(),
UserInstallId = sender["UserInstallID"].ToString(),
MessageAt = DateTime.UtcNow.ToEST(),
MessageAtFormatted = DateTime.UtcNow.ToEST().ToString()
};
// Finding correct chat group in which message suppose to be posted.
ChatGroup chatGroup = SingletonUserChatGroups.Instance.ChatGroups.Where(m => m.ChatGroupId == chatGroupId).FirstOrDefault();
if (chatGroup != null && chatGroup.ChatMessages == null)
{
chatGroup.ChatMessages = new List <ChatMessage>();
}
// Adding chat message into chatGroup
// Remove old Messages from list and newly one.
chatGroup.ChatMessages.RemoveRange(0, chatGroup.ChatMessages.Count()); // May require to comment in future.
chatGroup.ChatMessages.Add(chatMessage);
// Checking in database to fetch all connectionIds of browser of this chat group
// FYI: Everytime, we reload a web page, SignalR brower connectionId gets changed, So
// we have to always look database for correct connectionIds
var newConnections = ChatBLL.Instance.GetChatUsers(chatGroup.ChatUsers.Select(m => m.UserId.Value).ToList()).Results;
List <int> onlineUserIds = newConnections.Select(m => m.UserId.Value).ToList();
// Modify existing connectionIds into particular ChatGroup and save into static "UserChatGroups" object
foreach (var user in chatGroup.ChatUsers.Where(m => onlineUserIds.Contains(m.UserId.Value)))
{
if (newConnections.Where(m => m.UserId == user.UserId).Any())
{
user.ConnectionIds = newConnections.Where(m => m.UserId == user.UserId).Select(m => m.ConnectionIds).FirstOrDefault();
user.OnlineAt = newConnections.Where(m => m.UserId == user.UserId).OrderByDescending(m => m.OnlineAt).Select(m => m.OnlineAt).FirstOrDefault();
user.OnlineAtFormatted = user.OnlineAt.HasValue ? user.OnlineAt.Value.ToEST().ToString() : null;
}
}
// Chat status to active of sender
if (SingletonUserChatGroups.Instance.ActiveUsers.Where(m => m.UserId == SenderUserId).Any())
{
SingletonUserChatGroups.Instance.ActiveUsers.Where(m => m.UserId == SenderUserId)
.First().Status = (int)ChatUserStatus.Active;
SingletonUserChatGroups.Instance.ActiveUsers.Where(m => m.UserId == SenderUserId)
.First().LastActivityAt = DateTime.UtcNow;
}
// Adding each connection into SignalR Group, so that we can send messages to all connected users.
foreach (var item in chatGroup.ChatUsers.Where(m => m.OnlineAt.HasValue))
{
foreach (string connectionId in item.ConnectionIds)
{
Groups.Add(connectionId, chatGroupId);
}
}
// merge logged in user id into ReceiverIds
receiverIds += "," + SenderUserId;
// Check if message has base64 string (images)
List <ChatMessage> imageMessages = new List <ChatMessage>();
if (message.Contains("img") && message.Contains("copy-paste-image"))
{
int imageFileId = 0;
string imageName = "";
List <string> images = new List <string>();
string regexImgSrc = @"<img[^>]*?src\s*=\s*[""']?([^'"" >]+?)[ '""][^>]*?>";
MatchCollection matchesImgSrc = Regex.Matches(message, regexImgSrc, RegexOptions.IgnoreCase | RegexOptions.Singleline);
foreach (Match m in matchesImgSrc)
{
string base64 = m.Groups[1].Value;
base64 = base64.Substring(base64.IndexOf("base64,") + 7);
images.Add(base64);
byte[] bytes = Convert.FromBase64String(base64);
Image image;
using (MemoryStream ms = new MemoryStream(bytes))
{
image = Image.FromStream(ms);
}
imageName = Guid.NewGuid().ToString().Replace("@", "-") + ".jpg";
string path = HostingEnvironment.MapPath(JGConstant.ChatFilePath + "/" + imageName);
image.Save(path);
imageFileId = ChatBLL.Instance.SaveChatFile(imageName, imageName, image.GetImageMime());
imageMessages.Add(new ChatMessage
{
UserChatGroupId = chatMessage.UserChatGroupId,
TaskId = chatMessage.TaskId,
TaskMultilevelListId = chatMessage.TaskMultilevelListId,
Message = imageName + ":-:" + imageName,
FileId = imageFileId,
ChatSourceId = chatMessage.ChatSourceId,
UserId = chatMessage.UserId,
UserProfilePic = chatMessage.UserProfilePic,
UserFullname = chatMessage.UserFullname,
UserInstallId = chatMessage.UserInstallId,
MessageAt = chatMessage.MessageAt,
MessageAtFormatted = chatMessage.MessageAtFormatted
});
chatMessage.FileId = imageFileId;
chatMessage.Message = imageName + ":-:" + imageName;
ChatBLL.Instance.SaveChatMessage(chatMessage, chatGroupId, receiverIds, SenderUserId);
}
}
// Send Email notification to all offline users
foreach (var item in chatGroup.ChatUsers)
{
if (!SingletonGlobal.Instance.ConnectedUsers.Contains(item.UserId.Value) && item.UserId != SenderUserId)
{
//if (item.UserId != SenderUserId && item.Status != (int)ChatUserStatus.Active)
// Send Chat Notification Email
ChatBLL.Instance.SendOfflineChatEmail(SenderUserId, item.UserId.Value, sender["UserInstallID"].ToString(),
chatMessage.Message, chatSourceId, baseurl, chatGroupId, userChatGroupId ?? 0);
}
}
// Saving chat into database
// Check if message does not have base64 string (images)
if (!(message.Contains("img") && message.Contains("copy-paste-image")))
{
ChatBLL.Instance.SaveChatMessage(chatMessage, chatGroupId, receiverIds, SenderUserId);
imageMessages.Add(chatMessage);
}
taskId = taskId.HasValue ? taskId.Value : 0;
taskMultilevelListId = taskMultilevelListId.HasValue ? taskMultilevelListId.Value : 0;
UserChatGroup userChatGroup = new UserChatGroup();
if (userChatGroupId.HasValue && userChatGroupId.Value > 0)
{
userChatGroup = ChatBLL.Instance.GetChatGroup(userChatGroupId.Value);
}
else
{
userChatGroup.ChatGroupType = 1;
}
Clients.Group(chatGroupId).updateClient(new ActionOutput <ChatMessage>
{
Status = ActionStatus.Successfull,
Object = chatMessage,
Results = imageMessages,
Message = chatGroupId + "`" + chatGroup.ChatGroupName + "`" + receiverIds + "`" + SenderUserId + "`" + taskId + "`" + taskMultilevelListId + "`" + userChatGroupId + "`" + userChatGroup.ChatGroupType
});
}
catch (Exception ex)
{
ErrorLogBLL.Instance.SaveApplicationError("ChatHub", ex.Message, ex.ToString(), "");
Clients.Group(chatGroupId).sendChatMessageCallbackError(new ActionOutput <string>
{
Status = ActionStatus.Successfull,
Object = ex.ToString(),
Message = chatGroupId
});
}
}
