public void CreateRoom(string roomName)
{
using (var db = new UserContext())
{
var room = db.Rooms.Find(roomName);
if (room == null)
{
var cr = new ConversationRoom
{
RoomName = roomName
};
//将房间加入列表
db.Rooms.Add(cr);
db.SaveChanges();
// 本人加入聊天室
JoinRoom(roomName);
//UpdateRoomList();
//Clients.All.MessageReceived(roomName, $"新增聊天室成功:{roomName}");
}
else
{
Clients.Client(Context.ConnectionId).showMessage("房间名重复!");
// 本人加入聊天室
JoinRoom(roomName);
}
}
}
public ActionResult JoinRoom(string id)
{
mutexObj.WaitOne();
id = Regex.Replace(id, @"[^A-Za-z0-9]+", "");
using (UnitOfWork db = new UnitOfWork())
{
ConversationRoom room = db.conversationRoomRepository.GetById(id);
if (room == null)
{
mutexObj.ReleaseMutex();
return(RedirectToRoute("Error", "Not exist"));
}
ApplicationUser user = db.userRepository.GetById(User.Identity.GetUserId());
if (room != null && user != null)
{
user.Rooms.Add(room);
room.Users.Add(user);
db.userRepository.Update(user);
db.conversationRoomRepository.Update(room);
db.Save();
}
else
{
mutexObj.ReleaseMutex();
return(RedirectToRoute("Error", "CantFindRoom"));
}
}
mutexObj.ReleaseMutex();
return(Redirect("/Chat/" + id));
}
public ConversationRoom GetByIdDetached(string id)
{
ConversationRoom room = db.Rooms.Find(id);
db.Entry(room).State = EntityState.Detached;
return(room);
}
public override Task OnConnected()
{
using (var db = new UserContext())
{
var name = Context.User.Identity.Name;
var user = db.Users
.Include(u => u.Rooms)
.FirstOrDefault(u => u.UserName == name);
if (user == null)
{
user = new User()
{
UserName = name,
Connections = new List <Connection>()
};
db.Users.Add(user);
db.SaveChanges();
//conexiune noua
var conn = new Connection()
{
ConnectionID = Context.ConnectionId,
UserAgent = Context.Request.Headers["User-Agent"],
Connected = true
};
user.Connections.Add(conn);
db.Connections.Add(conn);
db.SaveChanges();
//room cu el insusi
var room = db.Rooms.Where(u => u.RoomName == name).FirstOrDefault();
if (room == null)
{
room = new ConversationRoom()
{
RoomName = name,
RoomType = ChatRoomTypeEnum.PeerToPeer,
Users = new List <User>()
};
room.Users.Add(user);
db.Rooms.Add(room);
db.SaveChanges();
}
Groups.Add(Context.ConnectionId, Context.User.Identity.Name);
}
else
{
ResolveConnections(user, db);
foreach (var item in user.Rooms)
{
Groups.Add(Context.ConnectionId, item.RoomName);
}
}
}
return(base.OnConnected());
}
public void Create(ConversationRoom room)
{
if (room == null)
{
return;
}
db.Rooms.Add(room);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
ConversationRoom conversationroom = await db.ConversationRooms.FindAsync(id);
db.ConversationRooms.Remove(conversationroom);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task OnGetAsync(long roomId)
{
Messages = await _context.Messages.Where(x => x.RoomId == roomId)
.Include(c => c.Room)
.Include(c => c.CreatedBy)
.OrderByDescending(x => x.CreatedDate).ToListAsync();
Room = await _context.Rooms.FirstOrDefaultAsync(x => x.Id == roomId);
}
public async Task AddToGroup(string groupName)
{
var Claim = Context.User.Identities.FirstOrDefault();
var userName = Claim.Claims.Where(e => e.Type == "user_name").Select(e => e.Value).FirstOrDefault();
int userId = Convert.ToInt32(Claim.Claims.Where(e => e.Type == "user_id").Select(e => e.Value).FirstOrDefault());
// Retrieve Room.
var Room = _context.Rooms.Where(s => s.RoomName == groupName).FirstOrDefault();
if (Room == null)
{
Room = new ConversationRoom
{
RoomName = groupName
};
_context.Rooms.Add(Room);
_context.SaveChanges();
}
var UserRoom = _context.RoomUsers.Where(s => s.room_id == Room.id && s.user_id == userId).FirstOrDefault();
if (UserRoom == null)
{
UserRoom = new UserInRoom
{
user_id = userId,
room_id = Room.id,
GroupConnections = new List <GroupConnection>()
};
_context.RoomUsers.Add(UserRoom);
_context.SaveChanges();
}
else
{
UserRoom.GroupConnections = new List <GroupConnection>();
}
UserRoom.GroupConnections.Add(new GroupConnection
{
ConnectionID = Context.ConnectionId,
UserAgent = "User-Agent",
Connected = true
});
_context.SaveChanges();
// Add to each assigned group.
var user = _context.RoomUsers
.Include(u => u.GroupConnections)
.Where(u => u.room_id == Room.id).ToList();
await Groups.AddToGroupAsync(Context.ConnectionId, groupName);
await Clients.Group(groupName).SendAsync("Send", $"{userName} has joined the group {groupName}.");
}
public void Delete(ConversationRoom room)
{
if (room != null)
{
using (UnitOfWork unit = new UnitOfWork())
{
List <Message> messages = unit.messageRepository.GetByRoom(room);
unit.messageRepository.DeleteRange(messages);
unit.Save();
}
db.Rooms.Remove(room);
}
}
public async Task <ActionResult> Edit([Bind(Include = "ConversationRoomID,Name,User1ID,User2ID")] ConversationRoom conversationroom)
{
if (ModelState.IsValid)
{
db.Entry(conversationroom).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.User1ID = new SelectList(db.Users, "Id", "UserName", conversationroom.User1ID);
ViewBag.User2ID = new SelectList(db.Users, "Id", "UserName", conversationroom.User2ID);
return(View(conversationroom));
}
// GET: /ConversationRoomManager/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ConversationRoom conversationroom = await db.ConversationRooms.FindAsync(id);
if (conversationroom == null)
{
return(HttpNotFound());
}
return(View(conversationroom));
}
/// <summary>
/// User calls this method to join a group. The group will be created if it doesn't exist.
/// </summary>
/// <param name="groupName"></param>
/// <returns></returns>
public async Task <Object> JoinGroup(string groupName)
{
if (groupName == null)
{
groupName = Guid.NewGuid().ToString();
}
;
string name = GetNameFromClaim();
// var group = context.Rooms.FirstOrDefault(e => e.RoomName == groupName);
//Add to in-memory group
await Groups.AddAsync(Context.ConnectionId, groupName);
// Retrieve room if it exists. If it doesn't it will be created in the future.
var group = context.Rooms.FirstOrDefault(e => e.RoomName == groupName);
// Retrieve user.
var user = context.Users.Include(u => u.ApplicationUserConversationRooms).SingleOrDefault(u => u.UserName == name);
//Is the user already a member of the group? In that case, return info message to user stating this.
if (user.ApplicationUserConversationRooms.FirstOrDefault(u => u.RoomName == groupName) != null)
{
return(Clients.User(Context.ConnectionId).SendAsync("addInfoMessageFromGroup", new[] { groupName, name + " is already a participant in group " + groupName }));
}
//Create Room
if (group == null)
{
group = new ConversationRoom()
{
RoomName = groupName
};
}
ApplicationUserConversationRoom sRCR = new ApplicationUserConversationRoom()
{
ApplicationUserId = user.Id,
ApplicationUser = user,
RoomName = groupName,
ConversationRoom = group
};
group.ApplicationUserConversationRooms.Add(sRCR);
context.ApplicationUserConversationRooms.Add(sRCR);
user.ApplicationUserConversationRooms.Add(sRCR);
await context.SaveChangesAsync();
return(Clients.Group(groupName).SendAsync("userAddedToGroup", new[] { name, groupName }));
}
public async Task <IActionResult> OnGetAsync(long?id)
{
if (id == null)
{
return(NotFound());
}
Room = await _context.Rooms.FirstOrDefaultAsync(m => m.Id == id);
if (Room == null)
{
return(NotFound());
}
return(Page());
}
// GET: /ConversationRoomManager/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ConversationRoom conversationroom = await db.ConversationRooms.FindAsync(id);
if (conversationroom == null)
{
return(HttpNotFound());
}
ViewBag.User1ID = new SelectList(db.Users, "Id", "UserName", conversationroom.User1ID);
ViewBag.User2ID = new SelectList(db.Users, "Id", "UserName", conversationroom.User2ID);
return(View(conversationroom));
}
public async Task <IActionResult> OnPostAsync(long?id)
{
if (id == null)
{
return(NotFound());
}
Room = await _context.Rooms.FindAsync(id);
if (Room != null)
{
_context.Rooms.Remove(Room);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public object AddUserToARoom(string roomName, int userRoleId, bool allowed)
{
int countConversationRoom = context.ConversationRooms.Where(cr => cr.RoomName == roomName && cr.UserRoleID == userRoleId).Count();
if (countConversationRoom > 0)
{
return("User has already added to the room.");
}
else
{
ConversationRoom conversationRoom = new ConversationRoom(roomName, userRoleId, allowed);
context.ConversationRooms.Add(conversationRoom);
context.SaveChanges();
var roomWiseUsers = context.ConversationRooms.Include(cr => cr.UserRole).Select(cr => new { cr.RoomName, cr.UserRole.UserName }).OrderBy(cr => cr.RoomName).ThenBy(cr => cr.UserName).ToArray();
return(roomWiseUsers);
}
}
public ActionResult Rooms()
{
var viewModel = new ConversationRoomViewModel();
if (unitOfWork.RoomRepository.Get().Any() == false)
{
ConversationRoom room = new ConversationRoom()
{
RoomName = "TheFirstRoom",
RoomType = ChatRoomTypeEnum.UserToRoom
};
unitOfWork.RoomRepository.Insert(room);
}
viewModel.ConversationRooms = unitOfWork.RoomRepository.Get();
return(View("Rooms", viewModel));
}
/// <summary>
/// 创建聊天室
/// </summary>
/// <param name="roomName"></param>
public void CreatRoom(string roomName)
{
var room = db.Rooms.Find(a => a.RoomName == roomName);
if (room == null)
{
ConversationRoom cr = new ConversationRoom()
{
RoomName = roomName
};
//将房间加入列表
db.Rooms.Add(cr);
AddToRoom(roomName);
GetRoomList();
}
else
{
Clients.Clients(Context.ConnectionId).SendAsync("alertMsg", "名称已存在");
}
}
/// <summary>
/// 创建聊天室
/// </summary>
/// <param name="roomName"></param>
public void CreatRoom(string roomName)
{
var room = db.Rooms.Find(a => a.RoomName == roomName);
if (room == null)
{
ConversationRoom cr = new ConversationRoom()
{
RoomName = roomName
};
//将房间加入列表
db.Rooms.Add(cr);
AddToRoom(roomName);
Clients.Client(Context.ConnectionId).showMessage("房间创建完成!");
GetRoomList();
}
else
{
Clients.Client(Context.ConnectionId).showMessage("房间名重复!");
}
}
public bool AddConversationRoom(RequestUserOPDRegisterSubmitDTO request, DBEntities db = null)
{
bool dbPrivateFlag = false;
if (db == null)
{
db = CreateDb();
dbPrivateFlag = true;
}
#region 创建房间
request.ChannelID = Guid.NewGuid().ToString("N");
var room = new ConversationRoom()
{
EndTime = DateTime.Parse(request.OPDDate.ToString("yyyy-MM-dd ") + request.OPDEndTime),
BeginTime = DateTime.Parse(request.OPDDate.ToString("yyyy-MM-dd ") + request.OPDBeginTime),
TotalTime = 0,
RoomState = EnumRoomState.NoTreatment,//状态
ConversationRoomID = request.ChannelID,
ServiceID = request.OPDRegisterID,
ServiceType = request.OPDType,
//如果预约类型是挂号那么房间类型就是线下看诊，否则是线上看诊
RoomType = EnumRoomType.Group,
TriageID = long.MaxValue,
Priority = request.UserLevel,
DisableWebSdkInteroperability = true,
};
db.ConversationRooms.Add(room);
#endregion
var ret = true;
if (dbPrivateFlag)
{
db.Dispose();
ret = db.SaveChanges() > 0;
}
return(ret);
}
public ActionResult Chat(string id)
{
mutexObj.WaitOne();
if (id == null)
{
}
else
{
id = Regex.Replace(id, @"[^A-Za-z0-9]+", "");
}
ChatViewModel chat = new ChatViewModel()
{
messageHistory = new List <Message>()
};
ViewBag.userName = User.Identity.GetUserName();
ViewBag.currentRoom = id;
using (UnitOfWork db = new UnitOfWork())
{
ConversationRoom room = db.conversationRoomRepository.GetByRoomName(id);
ApplicationUser user = db.userRepository.GetById(User.Identity.GetUserId());
if (room != null && room.Users.Contains(user))
{
chat.messageHistory = db.messageRepository.GetByRoomName(id).ToList();
chat.currentRoomName = id;
chat.room = room;
chat.currentRoomTime = 0.0f;
chat.currentRoomVideo = null;
}
else if (room != null && !room.Users.Contains(user))
{
mutexObj.ReleaseMutex();
return(JoinRoom(room.RoomName));
}
}
mutexObj.ReleaseMutex();
return(View(chat));
}
public ActionResult DeleteChat(string roomName)
{
mutexObj.WaitOne();
roomName = Regex.Replace(roomName, @"[^A-Za-z0-9]+", "");
string changeRoom = null;
using (UnitOfWork db = new UnitOfWork())
{
ConversationRoom room = db.conversationRoomRepository.GetById(roomName);
if (room != null)
{
List <Message> messageHistory = db.messageRepository.GetByRoomName(roomName).OrderBy(m => m.sendDate).ToList();
if (messageHistory.Count > 0)
{
db.messageRepository.DeleteRange(messageHistory);
}
db.conversationRoomRepository.Delete(room);
}
db.Save();
List <ConversationRoom> rooms = db.conversationRoomRepository.GetByUserId(User.Identity.GetUserId()).ToList();
if (rooms.Count > 0)
{
changeRoom = rooms.First().RoomName;
}
ViewBag.userName = User.Identity.GetUserName();
}
mutexObj.ReleaseMutex();
return(UpdateGrid(changeRoom));
}
public ActionResult CreateRoom(string roomName)
{
mutexObj.WaitOne();
roomName = Regex.Replace(roomName, @"[^A-Za-z0-9]+", "");
using (UnitOfWork db = new UnitOfWork())
{
ConversationRoom room = db.conversationRoomRepository.GetById(roomName);
if (room == null)
{
room = new ConversationRoom()
{
RoomName = roomName
};
ApplicationUser user = db.userRepository.GetById(User.Identity.GetUserId());
room.currentAdmin = user;
db.userRepository.Update(user);
room.Users.Add(user);
db.conversationRoomRepository.Create(room);
user.Rooms.Add(room);
db.Save();
}
else
{
mutexObj.ReleaseMutex();
return(RedirectToRoute("Error", "CantFindRoom"));
}
mutexObj.ReleaseMutex();
return(Redirect("/Chat/" + room.RoomName));
}
}
/// <summary>
/// Creates a new chat with multiple clients. Calling client username should be included in list!
/// </summary>
/// <param name="usernames"></param>
/// <returns></returns>
public async Task <Object> StartGroupChatWithMultipleClients(string[] usernames)
{
string groupName = Guid.NewGuid().ToString();
List <ApplicationUser> users = new List <ApplicationUser>();
List <ApplicationUserConversationRoom> aUCRs = new List <ApplicationUserConversationRoom>();
//Add users to in-memory group
foreach (string usernameToAdd in usernames)
{
foreach (var connectionId in _connections.GetConnections(usernameToAdd))
{
await Groups.AddAsync(connectionId, groupName);
}
}
// Retrieve room
var group = context.Rooms.FirstOrDefault(e => e.RoomName == groupName);
if (group != null)
{
return(Clients.Client(Context.ConnectionId).SendAsync("addInfoMessageFromGroup", new[] { groupName, groupName + "already exists" }));
}
//Notify group about each user
foreach (string usernameToAdd in usernames)
{
await Clients.Group(groupName).SendAsync("userAddedToGroup", new[] { usernameToAdd, groupName });
}
// Retrieve users.
foreach (string usernameToAdd in usernames)
{
users.Add(context.Users.Include(u => u.ApplicationUserConversationRooms).SingleOrDefault(u => u.UserName == usernameToAdd));
}
//Create the new group
var newGroup = new ConversationRoom()
{
RoomName = groupName
};
//An ApplicationUserConversationRoom must be created to link each user with each group
foreach (ApplicationUser u in users)
{
aUCRs.Add(new ApplicationUserConversationRoom()
{
ApplicationUserId = u.Id,
ApplicationUser = u,
RoomName = groupName,
ConversationRoom = newGroup
});
}
//Then each AUCR must be added to the the AUCR table, the specific group and the specific user
foreach (ApplicationUserConversationRoom aUCR in aUCRs)
{
newGroup.ApplicationUserConversationRooms.Add(aUCR);
context.ApplicationUserConversationRooms.Add(aUCR);
aUCR.ApplicationUser.ApplicationUserConversationRooms.Add(aUCR); //???
}
await context.SaveChangesAsync();
return(Clients.Group(groupName).SendAsync("addInfoMessageFromGroup", new[] { groupName, groupName + "created" }));
}
/// <summary>
/// 添加好友
/// 作者：郭明
/// 日期：2017年6月23日
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Dictionary <int, ResponseConversationRoomDTO> ApplyAddFriend(RequestConversactionApplyAddFriendDTO request)
{
Dictionary <int, ResponseConversationRoomDTO> result = new Dictionary <int, ResponseConversationRoomDTO>();
using (var db = new DBEntities())
{
request.AddFriendItem.ForEach(account =>
{
var channelInfo = (from friend in db.ConversationFriends.Where(a => a.FromUserID == request.FromUserID && a.ToUserID == account.ToUserID)
join room in db.ConversationRooms on friend.ConversationRoomID equals room.ConversationRoomID
where room.RoomType == EnumRoomType.C2C
select room).FirstOrDefault();
if (channelInfo == null)
{
var ConversationRoomID = Guid.NewGuid().ToString("N");
channelInfo = new ConversationRoom()
{
ServiceID = "",
Priority = 5,
ChargingInterval = 0,
ChargingSeq = 0,
ChargingState = EnumRoomChargingState.Stoped,
ChargingTime = DateTime.Now,
Duration = 0,
TotalTime = 0,
Enable = false,
ServiceType = EnumDoctorServiceType.PicServiceType,
Secret = "",
BeginTime = DateTime.Now,
EndTime = DateTime.Now,
ConversationRoomID = ConversationRoomID,
CreateTime = DateTime.Now,
IsDeleted = false,
RoomState = EnumRoomState.NoTreatment,
RoomType = EnumRoomType.C2C,
TriageID = long.MaxValue
};
db.ConversationRooms.Add(channelInfo);
db.ConversationRoomUids.Add(new ConversationRoomUid()
{
ConversationRoomID = ConversationRoomID,
Identifier = account.ToUserIdentifier,
UserType = account.ToUserType,
IsDeleted = false,
UserMemberID = account.ToUserMemberID,
CreateUserID = request.FromUserID,
UserID = account.ToUserID,
UserCNName = account.ToUserName,
UserENName = account.ToUserName,
PhotoUrl = "",
});
if (request.FromUserIdentifier != request.FromUserIdentifier)
{
db.ConversationRoomUids.Add(new ConversationRoomUid()
{
ConversationRoomID = ConversationRoomID,
Identifier = request.FromUserIdentifier,
UserType = request.FromUserType,
IsDeleted = false,
UserMemberID = request.FromUserMemberID,
CreateUserID = request.FromUserID,
UserID = request.FromUserID,
UserCNName = account.ToUserName,
UserENName = account.ToUserName,
PhotoUrl = "",
});
}
db.ConversationFriends.Add(new ConversationFriend()
{
ConversationRoomID = ConversationRoomID,
FromUserID = request.FromUserID,
FromUserIdentifier = request.FromUserIdentifier,
ToUserIdentifier = account.ToUserIdentifier,
ToUserID = account.ToUserID,
AddWording = account.AddWording,
CreateTime = DateTime.Now,
GroupName = account.GroupName,
Remark = account.Remark,
IsDeleted = false,
FriendID = Guid.NewGuid().ToString("N")
});
db.ConversationFriends.Add(new ConversationFriend()
{
ConversationRoomID = ConversationRoomID,
FromUserID = account.ToUserID,
FromUserIdentifier = account.ToUserIdentifier,
ToUserIdentifier = request.FromUserIdentifier,
ToUserID = request.FromUserID,
AddWording = account.AddWording,
CreateTime = DateTime.Now,
GroupName = account.GroupName,
Remark = account.Remark,
IsDeleted = false,
FriendID = Guid.NewGuid().ToString("N")
});
db.SaveChanges();
result.Add(account.ToUserIdentifier, channelInfo.Map <ConversationRoom, ResponseConversationRoomDTO>());
}
else
{
result.Add(account.ToUserIdentifier, channelInfo.Map <ConversationRoom, ResponseConversationRoomDTO>());
}
});
}
return(result);
}
public ActionResult CreateChatRoom(string roomName)
{
mutexObj.WaitOne();
roomName = Regex.Replace(roomName, @"[^A-Za-z0-9]+", "");
using (UnitOfWork db = new UnitOfWork())
{
if (db.conversationRoomRepository.GetById(roomName) != null)
{
return(RedirectToRoute("Error", "AlreadyCreated"));
}
if (roomName != null)
{
ApplicationUser user = db.userRepository.GetById(User.Identity.GetUserId());
ConversationRoom room = null;
room = new ConversationRoom()
{
RoomName = roomName,
currentAdmin = user
};
user.Rooms.Add(room);
db.userRepository.Update(user);
room.Users.Add(user);
db.conversationRoomRepository.Create(room);
db.Save();
}
else
{
mutexObj.ReleaseMutex();
return(RedirectToRoute("Error", "CantFindRoom"));
}
ChatViewModel chat = new ChatViewModel()
{
messageHistory = new List <Message>()
};
List <ConversationRoom> rooms = db.conversationRoomRepository.GetByUserId(User.Identity.GetUserId());
chat.messageHistory = db.messageRepository.GetByRoomName(roomName);
chat.currentRoomName = roomName;
foreach (ConversationRoom room in rooms)
{
Message msg = db.messageRepository.GetByRoomName(room.RoomName).OrderByDescending(m => m.messageId).FirstOrDefault();
if (msg != null)
{
}
else
{
Message message = new Message()
{
Room = room,
message = "",
};
}
}
ViewBag.userName = User.Identity.GetUserName();
mutexObj.ReleaseMutex();
return(PartialView("view", chat));
}
}
public List <Message> GetByRoom(ConversationRoom room)
{
return(db.Messages.Where(m => m.Room.RoomName == room.RoomName).ToList());
}
public void Update(ConversationRoom room)
{
db.Entry(room).State = EntityState.Modified;
}
