async Task ProcessEvent(TraceEventType type, string text)
        {
            using (var db = new ZkDataContext()) {
                db.LogEntries.Add(new LogEntry()
                {
                    Time = DateTime.UtcNow, Message = text, TraceEventType = type
                });
                await db.SaveChangesAsync();
            }

            // write error and critical logs to server
            if (type == TraceEventType.Error || type == TraceEventType.Critical)
            {
                var say = new Say()
                {
                    Place = SayPlace.Channel, Target = "zkerror", Text = text, User = GlobalConst.NightwatchName, Time = DateTime.UtcNow
                };

                if (ZkLobbyServer != null)
                {
                    // server runnin, flush queue and add new say
                    Say history;
                    while (queue.TryDequeue(out history))
                    {
                        await ZkLobbyServer.GhostSay(history);
                    }
                    await ZkLobbyServer.GhostSay(say);
                }
                else
                {
                    queue.Enqueue(say);    // server not running (stuff intiializing) store in queueu
                }
            }
        }
Esempio n. 2
0
        public async Task RemoveConnection(ClientConnection con, string reason)
        {
            bool dummy;

            if (Connections.TryRemove(con, out dummy) && (Connections.Count == 0))
            {
                // notify all channels where i am to all users that i left
                foreach (var chan in server.Channels.Values.Where(x => x.Users.ContainsKey(Name)).ToList())
                {
                    await Process(new LeaveChannel()
                    {
                        ChannelName = chan.Name
                    });
                }

                foreach (var b in server.Battles.Values.Where(x => x.Users.ContainsKey(Name)))
                {
                    await LeaveBattle(b);

                    await b.RecalcSpectators();
                }


                if (await server.MatchMaker.RemoveUser(Name, true))
                {
                    await server.UserLogSay($"{Name} disconnected, removing from MM.");
                }
                await server.PartyManager.OnUserDisconnected(Name);

                await server.PlanetWarsMatchMaker.OnUserDisconnected(Name);

                server.ForumListManager.OnUserDisconnected(User.AccountID);

                await server.Broadcast(server.ConnectedUsers.Values.Where(x => x != null && server.CanUserSee(x, this)), new UserDisconnected()
                {
                    Name = Name, Reason = reason
                });

                server.RemoveSessionsForAccountID(User.AccountID);

                ConnectedUser connectedUser;

                if (server.ConnectedUsers.TryRemove(Name, out connectedUser))
                {
                    int accountID = User.AccountID;
                    connectedUser.ResetHasSeen();
                    connectedUser.User.AccountID = 0;

                    using (var db = new ZkDataContext())
                    {
                        var acc = await db.Accounts.FindAsync(accountID);

                        acc.LastLogout   = DateTime.UtcNow;
                        acc.LastChatRead = DateTime.UtcNow;
                        await db.SaveChangesAsync();
                    }
                }
            }
        }
Esempio n. 3
0
 public async Task StoreChatHistory(Say say)
 {
     using (var db = new ZkDataContext()) {
         var historyEntry = new LobbyChatHistory();
         historyEntry.SetFromSay(say);
         db.LobbyChatHistories.Add(historyEntry);
         await db.SaveChangesAsync();
     }
 }
Esempio n. 4
0
        public async Task Process(LinkSteam linkSteam)
        {
            await Task.Delay(2000); // steam is slow to get the ticket from client .. wont verify if its checked too soon

            var steamID = state.SteamWebApi.WebValidateAuthToken(linkSteam.Token);
            var info    = state.SteamWebApi.WebGetPlayerInfo(steamID);

            using (var db = new ZkDataContext())
            {
                var acc = await db.Accounts.FindAsync(User.AccountID);

                acc.SteamID   = steamID;
                acc.SteamName = info.personaname;
                await db.SaveChangesAsync();

                await state.PublishAccountUpdate(acc);
            }
        }
Esempio n. 5
0
        public async Task RemoveConnection(ClientConnection con, string reason)
        {
            bool dummy;

            if (Connections.TryRemove(con, out dummy) && Connections.Count == 0)
            {
                // notify all channels where i am to all users that i left
                foreach (var chan in state.Rooms.Values.Where(x => x.Users.ContainsKey(Name)).ToList())
                {
                    await Process(new LeaveChannel()
                    {
                        ChannelName = chan.Name
                    });
                }

                foreach (var b in state.Battles.Values.Where(x => x.Users.ContainsKey(Name)))
                {
                    await LeaveBattle(b);
                    await RecalcSpectators(b);
                }

                await state.Broadcast(state.ConnectedUsers.Values, new UserDisconnected()
                {
                    Name = Name, Reason = reason
                });

                ConnectedUser connectedUser;
                state.ConnectedUsers.TryRemove(Name, out connectedUser);

                using (var db = new ZkDataContext())
                {
                    var acc = await db.Accounts.FindAsync(User.AccountID);

                    acc.LastLogout = DateTime.UtcNow;
                    await db.SaveChangesAsync();
                }
            }
        }