private void Search(string search)
{
ChatSession tmplChatSession = (ChatSession)myChatSessions[myChatSessionsTabControl.SelectedTab.Tag];
if (tmplChatSession != null)
{
tmplChatSession.ChatBox.ResetHTML();
ChatController.MessageTemplate tmplMessageTemplate = new MessageTemplate(MessageTemplateType.Notification);
tmplChatSession.ChatBox.AttachEvents();
List <Remwave.Client.Storage.StorageMessage> list = myClientForm.myStorage.GetMessageFromArchive(tmplChatSession.JabberUser.JID, search, 50);
if (list != null && list.Count > 0)
{
for (int i = list.Count - 1; i >= 0; i--)
{
if (list[i].Direction == StorageItemDirection.In)
{
AddToConversation(tmplChatSession.JabberUser.JID, tmplChatSession.JabberUser.JID, list[i].ContentText, list[i].ContentHTML, list[i].Created, list[i].GUID, false, false);
}
else
{
AddToConversation(tmplChatSession.JabberUser.JID, myClientForm.mUserAccount.JabberUser.JID, list[i].ContentText, list[i].ContentHTML, list[i].Created, list[i].GUID, false, false);
}
}
}
}
}
public void GetUserDataHandler(ChatSession session, CGetUserDataReqMessage message)
{
var plr = session.Player;
if (plr.Account.Id == message.AccountId)
{
session.Send(new SUserDataAckMessage(plr.Map <Player, UserDataDto>()));
return;
}
Player target;
if (plr.Channel.Players.TryGetValue(message.AccountId, out target))
{
switch (target.Settings.Get <CommunitySetting>(nameof(UserDataDto.AllowInfoRequest)))
{
case CommunitySetting.Deny:
// Not sure if there is an answer to this
return;
case CommunitySetting.FriendOnly:
// ToDo
return;
}
session.Send(new SUserDataAckMessage(target.Map <Player, UserDataDto>()));
}
}
public async Task <DbExecutionStatus> AddUserToSession(ChatSession session, int userId)
{
try
{
if (session == null)
{
return(DbExecutionStatus.NotFound);
}
// check if this user is alredy registered in this session
var mapping = _context.SessionsUsers.Where(us => us.SessionId == session.Id && us.UserId == userId).FirstOrDefault();
if (mapping != null)
{
return(DbExecutionStatus.Succeeded);
}
// else, add mapping
_context.SessionsUsers.Add(new SessionUser()
{
UserId = userId, SessionId = session.Id
});
await _context.SaveChangesAsync();
return(DbExecutionStatus.Succeeded);
}
catch (Exception ex)
{
return(DbExecutionStatus.Failed);
}
}
public void CChatMessageReq(ChatSession session, MessageChatReqMessage message)
{
switch (message.ChatType)
{
case ChatType.Channel:
session.Player.Channel.SendChatMessage(session.Player, message.Message);
break;
case ChatType.Club:
if (session.Player.Club != null)
{
var clanmembers = GameServer.Instance.PlayerManager.Where(p =>
session.Player.Club.Players.Keys.Contains(p.Account.Id));
foreach (var member in clanmembers)
{
member.ChatSession?.SendAsync(new MessageChatAckMessage(ChatType.Club, session.Player.Account.Id,
session.Player.Account.Nickname, message.Message));
}
}
break;
default:
Logger.ForAccount(session)
.Warning("Invalid chat type {chatType}", message.ChatType);
break;
}
}
public void ClubClubMemberInfoReq2(ChatSession session, ClubClubMemberInfoReq2Message message)
{
var targetplr = GameServer.Instance.PlayerManager[message.AccountId];
if (targetplr?.Club?.Id > 0)
{
var isMod = targetplr.Club.Players.Any(x =>
x.Value.Rank == ClubRank.Master && x.Key == targetplr.Account.Id);
session.SendAsync(new ClubClubMemberInfoAck2Message
{
ClanId = message.ClanId,
AccountId = targetplr.Account.Id,
Nickname = targetplr.Account.Nickname,
IsModerator = isMod ? 1 : 0
});
}
else if (session.Player != null && targetplr != null)
{
session.SendAsync(new ClubClubMemberInfoAck2Message
{
ClanId = message.ClanId,
AccountId = targetplr.Account.Id,
Nickname = targetplr.Account.Nickname
});
}
else
{
session.SendAsync(new ClubClubMemberInfoAck2Message
{
ClanId = message.ClanId,
AccountId = 0,
Nickname = "n/A"
});
}
}
public async Task <DbExecutionStatus> Add(ChatSession session)
{
try
{
_context.ChatSessions.Add(session);
await _context.SaveChangesAsync();
var strMsg = "Hi there, my name is Marley and I'm here to help you. You can ask me questions by using the @marley tag before the question. If you have a general question about the current training use the #abstract or #general tags before the question. Otherwise, no extra tags are needed and the answer to your question will be a hint based on your progress.";
var firstMessage = new Message
{
Sender = Consts.MARLEYNAME,
Text = strMsg,
ChatSessionId = session.Id,
SessionName = session.Name,
TimeStamp = DateTime.Now,
SenderType = UserType.Bot
};
_context.Messages.Add(firstMessage);
await _context.SaveChangesAsync();
return(DbExecutionStatus.Succeeded);
}
catch (Exception ex)
{
Console.WriteLine($"Failed creating new session {ex}");
return(DbExecutionStatus.Failed);
}
}
public override void Execute(ChatSession session, string[] args = null)
{
if (session.Player.RCON)
{
Execute(args);
}
}
public void ClubClubMemberInfoReq2(ChatSession session, ClubClubMemberInfoReq2Message message)
{
if (session.GameSession != null)
{
session.GameSession.SendAsync(new ServerResultAckMessage(ServerResult.ServerError));
}
}
private static async Task MainMenu(ChatSession session)
{
User usr;
switch (session.CurrentMessage)
{
case CONSULTAR_TOKEN:
usr = await DataService.Users.FindUserByUsername(session.Username);
await TelegramBotManager.SendMessage(session.ChatId, $"Tu token es : {usr.Token}");
await UserExists(session);
break;
case VER_DISPOSITIVOS:
usr = await DataService.Users.FindUserByUsername(session.Username);
var keyboard = await DevicesKeyboard(usr.UserId);
await TelegramBotManager.SendMessage(session.ChatId, "Estos son tus dispositivos:", keyboard);
session.Status = ChatStatus.DEVICES;
break;
default:
await TelegramBotManager.SendMessage(session.ChatId, "Entrada no valida");
session.Status = session.PreviousStatus;
await UserExists(session);
break;
}
}
public void GetUserDataHandler(ChatSession session, UserDataOneReqMessage message)
{
var plr = session.Player;
if (plr.Account.Id == message.AccountId)
{
return;
}
if (!plr.Channel.Players.TryGetValue(message.AccountId, out var target))
{
return;
}
/* TO DO
* switch (target.Settings.Get<CommunitySetting>("AllowInfoRequest"))
* {
* case CommunitySetting.Deny:
* // Not sure if there is an answer to this
* return;
*
* case CommunitySetting.FriendOnly:
* // ToDo
* return;
* }
*/
session.SendAsync(new UserDataFourAckMessage(25, target.Map <Player, UserDataDto>()));
}
public async Task <ArchiveCallResponse> SendChatSessionAsync(ChatSession chatSession)
{
var result = await
_tethrSession.PostAsync <ArchiveCallResponse>("/chatCapture/v1", chatSession);
return(result);
}
private static async Task AskRegister(ChatSession session)
{
if (session.CurrentMessage == SI)
{
User new_usr = new User()
{
ChatId = session.ChatId, Username = session.Username, Token = CreateToken(session.ChatId)
};
await DataService.Users.InsertUser(new_usr);
await TelegramBotManager.SendMessage(session.ChatId, $"Has sido registrado, tu token es : {new_usr.Token}");
session.Status = ChatStatus.USER_EXISTS;
await UserExists(session);
}
else if (session.CurrentMessage == NO)
{
await TelegramBotManager.SendMessage(session.ChatId, "De acuerdo, si deseas registrarte en otro momento, mandame un mensaje");
session.Status = ChatStatus.NEW;
}
else
{
await TelegramBotManager.SendMessage(session.ChatId, "Entrada no valida");
session.Status = session.PreviousStatus;
}
}
public async Task CReadNoteReq(ChatSession session, CReadNoteReqMessage message)
{
Logger.Debug()
.Account(session)
.Message("Id:{0}", message.Id)
.Write();
var mail = session.Player.Mailbox[message.Id];
if (mail == null)
{
Logger.Error()
.Account(session)
.Message("Mail {0} not found", message.Id)
.Write();
await session.SendAsync(new SReadNoteAckMessage(0, new NoteContentDto(), 1))
.ConfigureAwait(false);
return;
}
mail.IsNew = false;
await session.Player.Mailbox.UpdateReminderAsync()
.ConfigureAwait(false);
await session.SendAsync(new SReadNoteAckMessage(mail.Id, mail.Map <Mail, NoteContentDto>(), 0))
.ConfigureAwait(false);
}
public static void Handle(ChatSession session, string[] recv)
{
int namespaceid = 0;
if (!Int32.TryParse(recv[1], out namespaceid))
{
session.SendCommand(ChatError.MoreParameters, "LOGIN :Not enough parameters");
session.Disconnect();
return;
}
session.chatUserInfo.namespaceID = namespaceid;
if (recv[2] == "*")
{
// Profile login, not handled yet!
session.SendCommand(ChatError.MoreParameters, "LOGIN :Not handled yet!");
session.Disconnect();
return;
}
// Unique nickname login
session.chatUserInfo.uniqueNickname = recv[3];
//session.chatUserInfo.password = recv[4];
session.SendCommand(ChatRPL.Login, "* 1 1");
}
protected override TcpSession CreateSession()
{
ChatSession newSession = new ChatSession(this);
AddSessionToSessionList(newSession);
return(newSession);
}
void tmplCloseButton_Click(object sender, EventArgs e)
{
if (myChatSessionsTabControl.Items.Count <= 1)
{
this.Close();
}
RadElement buttonElement = sender as RadElement;
if (buttonElement.Tag != null)
{
try
{
ChatSession tmplChatSession = (ChatSession)myChatSessions[buttonElement.Tag];
myChatSessionsTabControl.Items.Remove(tmplChatSession.ChatTab);
myChatSessions.Remove(buttonElement.Tag);
}
catch (Exception)
{
}
}
if (myChatSessionsTabControl.Items.Count > 0)
{
myChatSessionsTabControl.SelectLastVisibleItem();
}
}
private static async Task ControlSelected(ChatSession session)
{
switch (session.CurrentMessage)
{
case CONTROLAR:
await TelegramBotManager.SendMessage(session.ChatId, "Que accion deseas realizar?", ControlDeviceMenu);
session.Status = ChatStatus.CONTROL_DEVICE;
break;
case ACTUALIZAR:
await TelegramBotManager.SendMessage(session.ChatId, "Cual sera el nuevo nombre del Control?");
session.Status = ChatStatus.CONTROL_RENAMING;
break;
case REGRESAR:
session.SelectedControl = null;
await TelegramBotManager.SendMessage(session.ChatId, $"Dispositivo seleccionado ({session.SelectedDevice.KeyItem})", DeviceMenuKeyboard);
session.Status = ChatStatus.DEVICE_SELECTED;
break;
case ELIMINAR:
await TelegramBotManager.SendMessage(session.ChatId, "Estas seguro que deseas eliminar este control?", SiNoKeyboard);
session.Status = ChatStatus.CONTROL_ASK_ELIMINATION;
break;
default:
await TelegramBotManager.SendMessageSameKeyboard(session.ChatId, "Entrada no valida");
break;
}
}
public void UpdatePresence(string jid, int buddyAvailability)
{
if (InvokeRequired)
{
this.Invoke(new UpdatePresenceDelegate(this.UpdatePresence), new object[] { jid, buddyAvailability });
return;
}
ChatSession tmplChatSession = (ChatSession)myChatSessions[jid];
if (tmplChatSession != null)
{
switch (buddyAvailability)
{
case 0: tmplChatSession.ChatTab.ImageIndex = 0; break; // 'offline
case 1: tmplChatSession.ChatTab.ImageIndex = 1; break; // 'online
case 2: tmplChatSession.ChatTab.ImageIndex = 2; break; // 'away
case 3: tmplChatSession.ChatTab.ImageIndex = 3; break; // 'extended away
case 4: tmplChatSession.ChatTab.ImageIndex = 4; break; // 'do not disturb
}
}
}
private static async Task ControlDevice(ChatSession session)
{
switch (session.CurrentMessage)
{
case ENCENDER:
case APAGAR:
ControlQueue controlQueueDesactivar = new ControlQueue()
{
ControlId = session.SelectedControl.ControlId,
InsertedAt = DateTime.UtcNow,
Value = session.CurrentMessage == ENCENDER ? 1 : 0
};
await DataService.ControlQueues.InsertControlQueue(controlQueueDesactivar);
await TelegramBotManager.SendMessage(session.ChatId, $"El control ({session.SelectedControl.KeyItem}) ha sido {(session.CurrentMessage == ENCENDER ? "encendido" : "apagado")}, Que deseas realizar?", ControlMenuKeyboard);
session.Status = ChatStatus.CONTROL_SELECTED;
break;
case REGRESAR:
await TelegramBotManager.SendMessage(session.ChatId, $"Control seleccionado ({session.SelectedControl.KeyItem})", ControlMenuKeyboard);
session.Status = ChatStatus.CONTROL_SELECTED;
break;
default:
await TelegramBotManager.SendMessageSameKeyboard(session.ChatId, "Entrada no valida");
break;
}
}
Task Matchmaking()
{
Console.WriteLine("Matchmaking called.");
//check if atleast two players are queued.
if (dataService.userQueue.Count < 2)
{
return(Task.CompletedTask);
}
//TODO: find users with similar interests
dataService.userQueue.Shuffle();
//pair users in pairs of two
for (int i = dataService.userQueue.Count; i > 1; i -= 2)
{
//get accounts
UserAccount user1 = dataService.userQueue.ElementAt(i - 1).Value;
UserAccount user2 = dataService.userQueue.ElementAt(i - 2).Value;
//create session & remove players from queue.
ChatSession newSession = new ChatSession(user1, user2, services);
dataService.sessions.Add(newSession);
dataService.userQueue.Remove(user1.userID);
dataService.userQueue.Remove(user2.userID);
newSession.InitializeChat(); //initialize the chat
}
return(Task.CompletedTask);
}
private static async Task WatchNaming(ChatSession session)
{
session.SelectedWatch = session.IsUpdatingWatch ? session.SelectedWatch : new Watch();
session.SelectedWatch.Name = session.CurrentMessage.Trim();
session.Status = ChatStatus.WATCH_EXPRESSION;
await TelegramBotManager.SendMessage(session.ChatId, "Que expresion se va a evaluar para mandar el mensaje? ( usar 'val' como variable de la metrica ejemplo val > 30)");
}
public async Task <ChatSession> CreateSession(IGuildUser user, IChannel channel)
{
if (!_sessions.TryGetValue(user.GuildId, out var guildSessions))
{
guildSessions = new Dictionary <ulong, ChatSession>();
_sessions.Add(user.GuildId, guildSessions);
}
if (guildSessions.TryGetValue(user.Id, out var session))
{
if (session.LastInteraction < DateTime.Now - MaxIdleTime)
{
session.End();
guildSessions.Remove(user.Id);
}
else
{
throw new SessionExistsException($"User {user.Id} already has a session on this server.");
}
}
var apiToken = await _configuration.GetChatBotApi();
session = new ChatSession(apiToken, user, channel);
guildSessions.Add(user.Id, session);
return(session);
}
private static async Task WatchExpression(ChatSession session)
{
var result = JintService.TestExpression(session.CurrentMessage.Trim());
switch (result)
{
case EvaluationResult.INVALID:
await TelegramBotManager.SendMessage(session.ChatId, "Expresion invalida, verificar identificadores");
break;
case EvaluationResult.NOT_BOOLEAN:
await TelegramBotManager.SendMessage(session.ChatId, "Esta expresion no es booleana");
break;
case EvaluationResult.NO_CONTAINS_VAL:
await TelegramBotManager.SendMessage(session.ChatId, "Esta expresion no contiene el identificador");
break;
case EvaluationResult.SUCCESS:
session.SelectedWatch.Expression = session.CurrentMessage.Trim();
await TelegramBotManager.SendMessage(session.ChatId, "Expresion valida, Que mensaje quieres que se envie al cumplirse esta condicion");
session.Status = ChatStatus.WATCH_MESSAGE;
break;
default:
break;
}
}
public override void Execute(ChatSession session, string[] args = null)
{
try
{
if (session.Player is Moderator)
{
var targetName = args[1];
Player chatUser;
if (!Chat.Chat.StorageManager.FindUserByName(targetName, out chatUser))
{
MessageController.System(session.Player, "Tried muting an invalid user");
return;
}
if (chatUser is Moderator)
{
MessageController.System(session.Player, "Can't mute moderators");
}
else
{
DateTime expiry = DateTime.Now;
var value = int.Parse(args[3]);
switch (args[2])
{
case "minutes":
expiry = expiry.AddMinutes(value);
break;
case "hours":
expiry = expiry.AddHours(value);
break;
case "days":
expiry = expiry.AddDays(value);
break;
case "months":
expiry = expiry.AddMonths(value);
break;
case "years":
expiry = expiry.AddYears(value);
break;
}
chatUser.GetSession().Mute(string.Join(" ", args.Skip(4)), expiry, session.Player.Id);
}
}
else
{
MessageController.System(session.Player, "Unauthorized to use that command.");
}
}
catch (Exception)
{
MessageController.System(session.Player, "Unable to mute");
if (session.Player is Moderator)
{
MessageController.System(session.Player, "Usage: /mute [name] [minutes/hours/days/months/years] [value] [reason]");
}
}
}
private static async Task WatchSelected(ChatSession session)
{
switch (session.CurrentMessage)
{
case ACTUALIZAR:
await TelegramBotManager.SendMessage(session.ChatId, "Cual sera el nuevo nombre del watch?");
session.IsUpdatingWatch = true;
session.Status = ChatStatus.WATCH_NAMING;
break;
case ELIMINAR:
await TelegramBotManager.SendMessage(session.ChatId, "Estas seguro que deseas eliminar este dispositivo?", SiNoKeyboard);
session.Status = ChatStatus.WATCH_ASK_ELIMINATION;
break;
case REGRESAR:
await TelegramBotManager.SendMessage(session.ChatId, $"Metrica ({session.SelectedMetric.KeyItem}), Que accion deseas realizar?", MetricsMenuKeyboard);
session.Status = ChatStatus.METRIC_SELECTED;
break;
default:
await TelegramBotManager.SendMessage(session.ChatId, "Entrada no valida", DeviceMenuKeyboard);
break;
}
}
public void ClubNoteSendReq2(ChatSession session, ClubNoteSendReq2Message message)
{
//Todo
session.GameSession?.SendAsync(new ClubNoteSendAckMessage {
Unk = 1
});
}
public async Task CSendNoteReq(ChatSession session, CSendNoteReqMessage message)
{
Logger.Debug()
.Account(session)
.Message($"{JsonConvert.SerializeObject(message, Formatting.Indented)}")
.Write();
// ToDo use config file
if (message.Title.Length > 100)
{
Logger.Error()
.Account(session)
.Message($"Title is too big({message.Title.Length})")
.Write();
return;
}
if (message.Message.Length > 112)
{
Logger.Error()
.Account(session)
.Message($"Message is too big({message.Message.Length})")
.Write();
return;
}
var result = await session.Player.Mailbox.SendAsync(message.Receiver, message.Title, message.Message);
session.SendAsync(new SSendNoteAckMessage(result ? 0 : 1));
}
public async Task <DbExecutionStatus> Add(int sessionCreatorId, ChatSession session)
{
var result = await Add(session);
if (result != DbExecutionStatus.Succeeded)
{
return(result);
}
try
{
// Since we have many to many relationship, we need to perform mapping between those entities
_context.SessionsUsers.Add(new SessionUser()
{
SessionId = session.Id, UserId = Consts.MARLEYID
}); // add Marley automatically
_context.SessionsUsers.Add(new SessionUser()
{
SessionId = session.Id, UserId = sessionCreatorId
});
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
Console.WriteLine($"Failed creating new mapping between session and user {ex}");
return(DbExecutionStatus.Failed);
}
return(DbExecutionStatus.Succeeded);
}
void toolStripSendNudge_Click(object sender, EventArgs e)
{
ChatSession tmplChatSession = (ChatSession)myChatSessions[myChatSessionsTabControl.SelectedTab.Tag];
if (tmplChatSession != null)
{
if (tmplChatSession.NudgeTimeout > 0)
{
AddNotification(
tmplChatSession.JabberUser.JID,
"INFO",
String.Format(Properties.Localization.txtChatInfoNudgeAgain, tmplChatSession.NudgeTimeout),
DateTime.Now,
Guid.NewGuid().ToString(),
false,
true
);
}
else
{
tmplChatSession.NudgeTimeout = 10;
string jabberXevent = "<x xmlns='jabber:x:event'><event-nudge/><datetime>" + DateTime.Now.ToUniversalTime().ToBinary() + "</datetime><id>" + Guid.NewGuid().ToString() + "</id></x>";
bool msgSent = myClientForm.SendJabberXevent(tmplChatSession.JabberUser.JID, jabberXevent);
AddNotification(
tmplChatSession.JabberUser.JID,
"INFO",
Properties.Localization.txtChatInfoNudgeSent,
DateTime.Now,
Guid.NewGuid().ToString(),
false,
true
);
}
}
}
public override void OnCommandExecuting(CommandExecutingContext commandContext)
{
ChatSession session = (ChatSession)commandContext.Session;
string command = commandContext.CurrentCommand.Name;
if (!session.IsLogin)
{
if (!command.Equals("Login"))
{
session.Send($"请先完成登陆，在做别的操作");
session.Close();
commandContext.Cancel = true;//取消命令，不再继续
}
else
{
}
}
else if (!session.IsOnLine)
{
session.LastHBTime = DateTime.Now;//客户端给我发消息，证明在线
}
else
{
}
}
protected void Page_Load(object sender, System.EventArgs e)
{
AddNavigationItem("对话");
if (!EnableChatFunction)
{
ShowError("管理员已关闭对话功能！");
return;
}
m_PageNumber = _Request.Get<int>("page", Method.All, 0);
m_MessagePageNumber = _Request.Get<int>("msgpage", Method.All, 0);
m_TargetUserID = _Request.Get<int>("to", Method.All, 0);
if (m_TargetUserID > 0)
{
m_SelectedChatSession = ChatBO.Instance.GetChatSession(MyUserID, m_TargetUserID);
if (m_SelectedChatSession == null)
m_TargetUserID = 0;
else
WaitForFillSimpleUser<ChatSession>(m_SelectedChatSession, 0);
bool updateIsReade = false;
if (m_MessagePageNumber == 1)
updateIsReade = true;
m_ChatMessageList = ChatBO.Instance.GetChatMessages(MyUserID, m_TargetUserID, m_MessagePageNumber, c_MessagePageSize, updateIsReade);
m_ChatMessageList.Reverse();
int totalPageNumber = (int)Math.Ceiling((double)m_ChatMessageList.TotalRecords / (double)c_MessagePageSize);
if (m_MessagePageNumber == 0)
{
m_MessagePageNumber = totalPageNumber;
}
else
{
m_MessagePageNumber = (totalPageNumber + 1) - m_MessagePageNumber;
}
WaitForFillSimpleUsers<ChatMessage>(m_ChatMessageList, 0);
SetPager("messagelist", BbsRouter.GetUrl("my/chat", "page=" + m_PageNumber + "&to=" + TargetUserID + "&msgpage={0}"), m_MessagePageNumber, c_MessagePageSize, m_ChatMessageList.TotalRecords);
}
if (_Request.IsClick("beginChat"))
{
ProcessBeginChat();
}
m_ChatSessionList = ChatBO.Instance.GetChatSessions(MyUserID, m_PageNumber, c_SessionPageSize);
WaitForFillSimpleUsers<ChatSession>(m_ChatSessionList, 0);
SetPager("chatlist", BbsRouter.GetUrl("my/chat", "page={0}"), m_PageNumber, c_SessionPageSize, m_ChatSessionList.TotalRecords);
}
protected void Page_Load(object sender, EventArgs e)
{
m_TargetUserID = _Request.Get<int>("tuid", Method.Get, 0);
if (m_TargetUserID <= 0)
ShowError(new InvalidParamError("tuid"));
if (_Request.IsClick("delete"))
{
DeleteChatSession();
}
m_ChatSession = ChatBO.Instance.GetChatSession(MyUserID, m_TargetUserID);
if (m_ChatSession == null)
ShowError(new NotExistsChatSessionError(m_TargetUserID));
WaitForFillSimpleUser<ChatSession>(m_ChatSession, 0);
}
protected void Page_Load(object sender, EventArgs e)
{
sessionID = _Request.Get<int>("sessionID", Method.Get, 0);
m_ChatSession = ChatBO.Instance.GetChatSession(sessionID);
if (m_ChatSession == null)
ShowError(new NotExistsChatSessionError(0));
if (!AllSettings.Current.BackendPermissions.Can(My, BackendPermissions.ActionWithTarget.Manage_Chat, m_ChatSession.UserID))
{
ShowError("您没有权限删除该对话记录");
return;
}
//UserBO.Instance.WaitForFillSimpleUsers<ChatSession>(new ChatSession[] { m_ChatSession }, 1);
WaitForFillSimpleUser<ChatSession>(m_ChatSession, 1);
if (_Request.IsClick("delete"))
{
DeleteChatSession();
}
}
public static ChatSessionProxy GetChatSessionProxy(ChatSession session)
{
if (session == null)
return null;
ChatSessionProxy proxy = new ChatSessionProxy();
proxy.ChatSessionID = session.ChatSessionID;
proxy.CreateDate = session.CreateDate;
proxy.LastMessage = session.LastMessage;
proxy.OwnerID = session.OwnerID;
proxy.TotalMessages = session.TotalMessages;
proxy.UnreadMessages = session.UnreadMessages;
proxy.UpdateDate = session.UpdateDate;
proxy.UserID = session.UserID;
return proxy;
}
private int GetMemeberCount(ChatSession session)
{
#if (!ISWIN)
int count = 0;
foreach (ChatSessionMember member in session.Members)
{
if (member.HasBeenAdded) count++;
}
return count;
#else
return session.Members.Count(member => member.HasBeenAdded);
#endif
}
/// <summary>
/// Create a new friend conference session
/// </summary>
/// <param name = "session"></param>
public void CreateSession(ChatSession session)
{
ChatSessions.Add(session.SessionID, session);
}
/// <summary>
/// Create a new friend conference session
/// </summary>
/// <param name="session"></param>
private void CreateSession(ChatSession session)
{
ChatSessions.Add(session.SessionID, session);
}
private int GetMemeberCount (ChatSession session)
{
int count = 0;
foreach(ChatSessionMember member in session.Members)
{
if(member.HasBeenAdded)
count++;
}
return count;
}
/// <summary>
/// Create a new friend conference session
/// </summary>
/// <param name = "session"></param>
public bool CreateSession(ChatSession session)
{
ChatSession oldSession = null;
if (ChatSessions.TryGetValue(session.SessionID, out oldSession))
if (GetMemeberCount(session) == 0)
RemoveSession(session.SessionID);
else
return false; //Already have one
ChatSessions.Add(session.SessionID, session);
return true;
}
