public async Task SendMessage(string user, string message)
{
if (string.IsNullOrWhiteSpace(user) || string.IsNullOrWhiteSpace(message))
{
return;
}
var chatroomMessage = new ChatRoomMessage
{
Username = user,
PublishedOn = DateTime.Now,
Content = message
};
this.db.ChatRoomMessages.Add(chatroomMessage);
this.db.SaveChanges();
await Clients.All.SendAsync("ReceiveMessage", user, message);
}
/// <summary>
/// 通过审核.
/// </summary>
/// <param name="group"></param>
/// <param name="messageID"></param>
public void PassMessage(string group, long messageID)
{
// 取得当前用户.
// 查询用户。
var user = GetCurrentChatRoomUser();
// 取得用户 ip地址.
string ipAddress = IpGetter.GetIpAddress(HttpContext.Current.Request);
if (!user.IsAdmin)
{
Clients.Client(Context.ConnectionId).showErrorMessage("权限不足!");
return;
}
string resultMsg = null;
// 通过审核.
bool result = chatRoomMessageService.PassMessage(messageID, user.DisplayUserNickName, ipAddress, ref resultMsg);
if (!result)
{
// 失败的情况下.
Clients.Client(Context.ConnectionId).showErrorMessage(resultMsg);
return;
}
// 成功的情况下， 通知所有的 客户端， 显示消息.
// 查询数据库中的指定消息， 目的， 查询出关联信息.
ChatRoomMessage dbMsg = chatRoomMessageService.GetChatRoomMessage(messageID);
// 类型转换.
var clientMsg = GetClientMessage(dbMsg);
// 调用 客户端的 showNewMessage 方法.
Clients.Group(group).showNewMessage(clientMsg);
// 调用 管理员组的 PassMessageFinish(messageID) 方法.
Clients.Group(GetAdminGroupCode(group)).passMessageFinish(messageID);
}
protected override async void Run(Session session, C2G_AddChatRoomMessage message, Action <G2C_AddChatRoomMessage> reply)
{
G2C_AddChatRoomMessage response = new G2C_AddChatRoomMessage();
response.IsSuccess = false;
try
{
DBProxyComponent dBProxyComponent = Game.Scene.GetComponent <DBProxyComponent>();
ChatRoomMessage relationInfo = ComponentFactory.Create <ChatRoomMessage>();
relationInfo._InvAccountID = message.AccountID;
relationInfo._SendDate = message.SendDate;
relationInfo._ChatRoomID = message.ChatRoomID;
relationInfo._Message = RepeatedFieldAndListChangeTool.RepeatedFieldToList(message.Message);
await dBProxyComponent.Save(relationInfo);
//添加到对应的聊天室中，并广播给聊天室中的所有成员
var acounts = await dBProxyComponent.Query <ChatRoom>("{ '_id': " + message.ChatRoomID + "}");
if (acounts.Count > 0)
{
ChatRoom chatRoom = acounts[0] as ChatRoom;
chatRoom._DateMessageIDList.Add(relationInfo._SendDate + "|" + relationInfo.Id);
foreach (long item in chatRoom._UserList)
{
//广播给所有该聊天室用户
Log.Debug(MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + MethodBase.GetCurrentMethod().Name + "广播给：" + item);
}
}
reply(response);
}
catch (Exception e)
{
response.Message = MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + MethodBase.GetCurrentMethod().Name + "好友列表获取或创建失败，服务器维护中。";
ReplyError(response, e, reply);
}
}
public bool RefuseMessage(long messageID, string user, string ip, ref string resultMsg)
{
bool result = false;
try
{
using (MyChatRoomContext context = new MyChatRoomContext())
{
ChatRoomMessage message = context.ChatRoomMessages.Find(messageID);
if (message == null)
{
resultMsg = String.Format("消息 {0} 不存在！", messageID);
return(result);
}
message.AuditingBy = user;
message.AuditingIp = ip;
message.AuditingRefuse();
message.BeforeUpdateOperation(user);
// 物理保存.
context.SaveChanges();
// 如果能执行到这里， 认为处理成功.
result = true;
}
}
catch (Exception ex)
{
logger.Error(ex.Message, ex);
result = false;
resultMsg = ex.Message;
}
return(result);
}
public List <ChatRoomMessage> GetChatRoomMessageList(string houseID, string auditingFlag = null, long lastID = 0, int lastN = 50, int nearMin = 120)
{
using (MyChatRoomContext context = new MyChatRoomContext())
{
// 只查询 最近2小时的数据.
DateTime minDateTime = DateTime.Now.AddMinutes(-1 * nearMin);
var query =
from data in context.ChatRoomMessages
.Include("MessageSender.UserLevel").Include("ReplyMessage")
where
// 有效数据.
data.Status == ChatRoomMessage.STATUS_IS_ACTIVE
// 指定房间.
&& data.HouseID == houseID
// 时间范围.
&& data.LastUpdateTime > minDateTime
// 仅仅获取 全部的消息，忽略点对点消息。
// && data.MessageReceiverId == null
select data;
// 最近一条消息.
if (lastID > 0)
{
ChatRoomMessage lastData = context.ChatRoomMessages.Find(lastID);
if (lastData != null)
{
// 最近一条数据存在.
DateTime lastDateTime = lastData.LastUpdateTime;
query = query.Where(p => p.LastUpdateTime >= lastDateTime && p.MessageID != lastID);
}
}
// 审核标志.
if (auditingFlag != null)
{
query = query.Where(p => p.AuditingFlag == auditingFlag);
}
// 创建时间逆序.
query = query.OrderByDescending(p => p.LastUpdateTime);
// 查询.
List <ChatRoomMessage> resultList = query.Take(lastN).ToList();
// 顺序反转.
// 查询的时候， 是时间逆序， 取前 lastN 行.
// 但是显示的时候， 还是需要 旧的消息放上面， 新的消息放下面.
resultList.Reverse();
return(resultList);
}
}
/// <summary>
/// 创建一个消息.
/// </summary>
/// <param name="message"></param>
/// <param name="resultMsg"></param>
/// <returns></returns>
public bool CreateNewMessage(ChatRoomMessage message, ref string resultMsg)
{
bool result = false;
try
{
using (MyChatRoomContext context = new MyChatRoomContext())
{
// 检查 发消息用户.
ChatRoomUser user = context.ChatRoomUsers.Find(message.MessageSenderId);
if (user == null)
{
resultMsg = String.Format("用户 {0} 不存在！", message.MessageSenderId);
return(result);
}
if (user.IsGag)
{
resultMsg = String.Format("用户 {0} 已经被禁言！", user.UserName);
return(result);
}
// 如果指定了 接受者， 那么检查是否存在.
if (message.MessageReceiverId != null)
{
ChatRoomUser userTo = context.ChatRoomUsers.Find(message.MessageReceiverId);
if (userTo == null)
{
resultMsg = String.Format("用户 {0} 不存在！", message.MessageReceiverId);
return(result);
}
}
// 如果指定了 回复消息。 检查 回复消息是否存在.
if (message.ReplyMessageId != null)
{
ChatRoomMessage replyMessag = context.ChatRoomMessages.Find(message.ReplyMessageId.Value);
if (replyMessag == null)
{
resultMsg = String.Format("回复的消息 {0} 不存在！", message.ReplyMessageId);
return(result);
}
// 填写回复的 用户ID 与 昵称.
message.MessageReceiverId = replyMessag.MessageSenderId;
message.MessageReceiverNickName = replyMessag.MessageSenderNickName;
}
// 获取消息发送的房间.
var house = context.ChatRoomHouses.Find(message.HouseID);
if (house == null)
{
resultMsg = String.Format("直播室房间 {0} 不存在！", message.HouseID);
return(result);
}
// 判断指定房间， 消息是否需要审核.
if (house.IsChatRoomMessageAutoPass)
{
// 直播室房间， 自动审核通过.
message.AuditingPass();
message.AuditingIp = "-";
message.AuditingBy = "AUTO";
}
else
{
// 直播室房间， 要求审核.
// 检查用户的属性.
if (user.IsAutoPass)
{
// 帐户能够直接审核通过.
message.AuditingPass();
message.AuditingIp = "-";
message.AuditingBy = "AUTO";
}
else
{
// 待审核.
message.AuditingFlag = "WAIT";
}
}
// 发送者头像， 按照用户等级来处理.
message.MessageSenderPhoto = "/images/level/" + user.UserLevel.UserLevelIcon;
// 发信人昵称.
if (String.IsNullOrEmpty(message.MessageSenderNickName))
{
message.MessageSenderNickName = user.UserNickName;
}
// 当前时间 - 两条短消息之间的间隔 秒数.
DateTime disableTime = DateTime.Now.AddSeconds(-1 * TwoMessageSecondLimit);
// 两条短消息之间的间隔 秒数.
var prevMessageQuery =
from data in context.ChatRoomMessages
where
// 同一 发送人.
data.MessageSenderId == message.MessageSenderId &&
data.MessageSenderNickName == message.MessageSenderNickName
// 仅仅判断今天的.
&& data.CreateTime > disableTime
orderby
data.CreateTime descending
select data;
if (prevMessageQuery.Count() > 0)
{
// 存在有重复提交的情况.
resultMsg = "您消息发送得太频繁了......";
return(result);
}
message.BeforeInsertOperation("Web");
// 插入.
context.ChatRoomMessages.Add(message);
// 物理保存.
context.SaveChanges();
// 如果能执行到这里， 认为处理成功.
result = true;
}
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbErr)
{
logger.Info(message);
foreach (var errItem in dbErr.EntityValidationErrors)
{
foreach (var err in errItem.ValidationErrors)
{
logger.InfoFormat("{0} : {1}", err.PropertyName, err.ErrorMessage);
}
}
logger.Error(dbErr.Message, dbErr);
result = false;
resultMsg = dbErr.Message;
}
catch (Exception ex)
{
logger.Error(ex.Message, ex);
result = false;
resultMsg = ex.Message;
}
return(result);
}
/// <summary>
/// 发送消息.
/// </summary>
/// <param name="group"></param>
/// <param name="message"></param>
public void NewMessage(string group, string message, long?replyMessageId = null)
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("NewMessage ( {0}, {1}, {2} ) Start!", group, message, replyMessageId);
}
if (String.IsNullOrEmpty(message) || String.IsNullOrWhiteSpace(message))
{
Clients.Client(Context.ConnectionId).showErrorMessage("消息为空!");
return;
}
message = message.Trim();
message = message.Replace("\n", "<br/>\n");
if (message.Length > 500)
{
Clients.Client(Context.ConnectionId).showErrorMessage("消息超长!");
return;
}
// 取得当前用户.
// 查询用户。
var user = UserList.SingleOrDefault(u => u.ContextID == Context.ConnectionId);
// 取得用户 ip地址.
string ipAddress = IpGetter.GetIpAddress(HttpContext.Current.Request);
// 匿名用户的情况下，需要检查黑名单.
//if (user.UserID == 1)
//{
// if (this.chatRoomBlackNameList.Contains(ipAddress))
// {
// // 在黑名单里面.
// Clients.Client(Context.ConnectionId).showErrorMessage("网络连接上存在一些问题，请稍候再尝试！");
// if (logger.IsInfoEnabled)
// {
// logger.InfoFormat("黑名单用户 {0}，尝试发送消息：{1} ", ipAddress, message);
// }
// return;
// }
//}
ChatRoomMessage chatroomMessage = new ChatRoomMessage()
{
// 房间ID.
HouseID = group,
// 发信人.
MessageSenderId = user.UserID,
// 发件人昵称.
MessageSenderNickName = user.NickName,
// 回复消息ID.
ReplyMessageId = replyMessageId,
// 消息内容.
MessageContent = message,
// IP.
IpAddress = ipAddress,
// 数据有效.
IsActive = true,
};
string resultMsg = null;
bool result = chatRoomMessageService.CreateNewMessage(chatroomMessage, ref resultMsg);
if (!result)
{
// 消息发送失败.
Clients.Client(Context.ConnectionId).showErrorMessage(resultMsg);
return;
}
// 查询数据库中的指定消息， 目的， 查询出关联信息.
ChatRoomMessage dbMsg = chatRoomMessageService.GetChatRoomMessage(chatroomMessage.MessageID);
// 类型转换.
var clientMsg = GetClientMessage(dbMsg);
// 消息发送成功
if (dbMsg.AuditingFlag == ChatRoomMessage.AUDITING_IS_PASS)
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("房间{0}, 用户{1}, 昵称{2}, 发送的消息{3}, 自动审核通过了！",
group, user.UserID, user.NickName, message);
}
// 调用 客户端的 showNewMessage 方法.
Clients.Group(group).showNewMessage(clientMsg);
}
else
{
// 需要审核的.
if (logger.IsDebugEnabled)
{
logger.DebugFormat("房间{0}, 用户{1}, 昵称{2}, 发送的消息{3}, 等待审核通过！",
group, user.UserID, user.NickName, message);
}
// 调用 管理员组端的 showTodoMessage 方法.
Clients.Group(GetAdminGroupCode(group)).showTodoMessage(clientMsg);
}
}
public void Add(ChatRoomMessage msg)
{
_appDbContext.Add(msg);
_appDbContext.SaveChanges();
}
public async Task <ChatRoomMessage> CreateAsync(ChatRoomMessage chatRoomMessage)
{
chatRoomMessage.Id = await _chatRoomMessageRepository.InsertAndGetIdAsync(chatRoomMessage);
return(chatRoomMessage);
}
public static async Task Seed(IServiceScope serviceScope)
{
var redis = serviceScope.ServiceProvider.GetService <IConnectionMultiplexer>();
var redisDatabase = redis.GetDatabase();
// We store a counter for the total users and increment it on each register
var totalUsersKeyExist = await redisDatabase.KeyExistsAsync("total_users");
if (!totalUsersKeyExist)
{
// This counter is used for the id
await redisDatabase.StringSetAsync("total_users", 0);
// Some rooms have pre-defined names. When the clients attempts to fetch a room, an additional lookup
// is handled to resolve the name.
// Rooms with private messages don't have a name
await redisDatabase.StringSetAsync("room:0:name", "General");
// Create demo data with the default users
{
var rnd = new Random();
Func <double> rand = () => rnd.NextDouble();
Func <int> getTimestamp = () => (int)DateTimeOffset.Now.ToUnixTimeSeconds();
var demoPassword = "******";
var demoUsers = new List <string>()
{
"Pablo", "Joe", "Mary", "Alex"
};
var greetings = new List <string>()
{
"Hello", "Hi", "Yo", "Hola"
};
var messages = new List <string>()
{
"Hello!",
"Hi, How are you? What about our next meeting?",
"Yeah everything is fine",
"Next meeting tomorrow 10.00AM",
"Wow that's great"
};
Func <string> getGreeting = () => greetings[(int)Math.Floor(rand() * greetings.Count)];
var addMessage = new Func <string, string, string, int, Task>(async(string roomId, string fromId, string content, int timeStamp) =>
{
var roomKey = $"room:{roomId}";
var message = new ChatRoomMessage()
{
From = fromId,
Date = timeStamp,
Message = content,
RoomId = roomId
};
await redisDatabase.SortedSetAddAsync(roomKey, JsonSerializer.Serialize(message), message.Date);
});
var createUser = new Func <string, string, Task <User> >(async(string username, string password) =>
{
var usernameKey = $"username:{username}";
// Yeah, bcrypt generally ins't used in .NET, this one is mainly added to be compatible with Node and Python demo servers.
var hashedPassword = BCrypt.Net.BCrypt.HashPassword(password);
var nextId = await redisDatabase.StringIncrementAsync("total_users");
var userKey = $"user:{nextId}";
await redisDatabase.StringSetAsync(usernameKey, userKey);
await redisDatabase.HashSetAsync(userKey, new HashEntry[] {
new HashEntry("username", username),
new HashEntry("password", hashedPassword)
});
await redisDatabase.SetAddAsync($"user:{nextId}:rooms", "0");
return(new User()
{
Id = (int)nextId,
Username = username,
Online = false
});
});
var getPrivateRoomId = new Func <int, int, string>((user1, user2) =>
{
var minUserId = user1 > user2 ? user2 : user1;
var maxUserId = user1 > user2 ? user1 : user2;
return($"{minUserId}:{maxUserId}");
});
var createPrivateRoom = new Func <int, int, Task <ChatRoom> >(async(user1, user2) =>
{
var roomId = getPrivateRoomId(user1, user2);
await redisDatabase.SetAddAsync($"user:{user1}:rooms", roomId);
await redisDatabase.SetAddAsync($"user:{user2}:rooms", roomId);
return(new ChatRoom()
{
Id = roomId,
Names = new List <string> {
(await redisDatabase.HashGetAsync($"user:{user1}", "username")).ToString(),
(await redisDatabase.HashGetAsync($"user:{user2}", "username")).ToString(),
}
});
});
var users = new List <User>();
// For each name create a user.
foreach (var demoUser in demoUsers)
{
var user = await createUser(demoUser, demoPassword);
// This one should go to the session
users.Add(user);
}
var rooms = new Dictionary <string, ChatRoom>();
foreach (var user in users)
{
var otherUsers = users.Where(x => x.Id != user.Id);
foreach (var otherUser in otherUsers)
{
var privateRoomId = getPrivateRoomId(user.Id, otherUser.Id);
ChatRoom room = null;
if (!rooms.ContainsKey(privateRoomId))
{
room = await createPrivateRoom(user.Id, otherUser.Id);
rooms.Add(privateRoomId, room);
}
else
{
room = rooms[privateRoomId];
}
await addMessage(privateRoomId, otherUser.Id.ToString(), getGreeting(), (int)(getTimestamp() - rand() * 222));
}
}
var getRandomUserId = new Func <int>(() => users[(int)Math.Floor(users.Count * rand())].Id);
for (var messageIndex = 0; messageIndex < messages.Count; messageIndex++)
{
await addMessage("0", getRandomUserId().ToString(), messages[messageIndex], getTimestamp() - ((messages.Count - messageIndex) * 200));
}
}
}
}
public MessageData(ChatRoomMessage m)
{
Message = m.Message;
User = m.User;
Date = m.Date;
}
public ChatRoomMessageDAL(ChatRoomMessage Ca)
{
_ChatRoomMessages = Ca;
}
public ChatRoomMessageDAL(int Id)
{
Db = new SOKNAEntities();
_ChatRoomMessages = Db.ChatRoomMessage.Single(r => r.Id == Id);
}
public ChatRoomMessageDAL()
{
_ChatRoomMessages = new ChatRoomMessage();
}
