Example #1
0
        static void StartServerInfoTask()
        {
            var t = new System.Timers.Timer();

            t.AutoReset = true;
            t.Elapsed  += new System.Timers.ElapsedEventHandler((s, e) =>
            {
                using (SharedDbContext shared = new SharedDbContext())
                {
                    ServerDb serverDb = shared.Servers.Where(s => s.Name == Name).FirstOrDefault();
                    if (serverDb != null)
                    {
                        serverDb.IpAddress = IpAddress;
                        serverDb.Port      = Port;
                        serverDb.BusyScore = SessionManager.Instance.GetBusyScore();
                        shared.SaveChangesEx();
                    }
                    else
                    {
                        serverDb = new ServerDb()
                        {
                            Name      = Program.Name,
                            IpAddress = Program.IpAddress,
                            Port      = Program.Port,
                            BusyScore = SessionManager.Instance.GetBusyScore()
                        };
                        shared.Servers.Add(serverDb);
                        shared.SaveChangesEx();
                    }
                }
            });
            t.Interval = 10 * 1000;
            t.Start();
        }
Example #2
0
        public Server GetServerById(int id)
        {
            Server ret;

            using (var db = new ServerDb())
            {
                lock (mutexDbAccess)
                {
                    ret = db.Servers.Find(id);
                }
            }
            return(ret);

            #region [ === Old Code : For cache memory (no DB) === ]
            //var ctx = HttpContext.Current;

            //if (ctx != null)
            //{
            //    var currentData = (Server[])ctx.Cache[CacheKey];

            //    var server = currentData.FirstOrDefault((s) => s.Id == id);
            //    if (server != default(Server))
            //        return server;
            //}

            //return null;
            #endregion
        }
Example #3
0
        // NAMIKO JOIN

        private async Task Client_JoinedGuild(SocketGuild arg)
        {
            DateTime now    = DateTime.Now;
            Server   server = ServerDb.GetServer(arg.Id) ?? new Server
            {
                GuildId  = arg.Id,
                JoinDate = now
            };

            server.LeaveDate = null;
            server.Prefix    = AppSettings.DefaultPrefix;
            await ServerDb.UpdateServer(server);

            if (server.JoinDate.Equals(now))
            {
                await BalanceDb.SetToasties(Client.CurrentUser.Id, 1000000, arg.Id);
            }

            SocketTextChannel ch = arg.SystemChannel ?? arg.DefaultChannel;

            try
            {
                await ch?.SendMessageAsync("Hi! Please take good care of me!", false, BasicUtil.GuildJoinEmbed(server.Prefix).Build());
            }
            catch { }
            await WebhookClients.GuildJoinLogChannel.SendMessageAsync($"<:TickYes:577838859107303424> {Client.CurrentUser.Username} joined `{arg.Id}` **{arg.Name}**.\nOwner: `{arg.Owner.Id}` **{arg.Owner}**");
        }
Example #4
0
        public ActionResult CreateNewTag(string title)
        {
            Tag newTag = new Tag(title);

            using (var db = new ServerDb())
            {
                var old = db.Tags.Where(m => m.title == newTag.title)
                          .FirstOrDefault();

                // Save Existing
                if (old != null)
                {
                    db.Tags.Remove(old);
                    db.Tags.Add(newTag);
                }
                // Save New
                else
                {
                    db.Tags.Add(newTag);
                }


                db.SaveChanges();
            }
            return(PartialView(newTag));
        }
Example #5
0
        public Server[] GetAllServers()
        {
            Server[] ret;
            using (var db = new ServerDb())
            {
                lock (mutexDbAccess)
                {
                    ret = db.Servers.ToArray();
                }
            }
            return(ret);

            #region [ === Old Code : For cache memory (no DB) === ]
            //var ctx = HttpContext.Current;

            //if (ctx != null)
            //{
            //    return (Server[])ctx.Cache[CacheKey];
            //}

            //return new Server[]
            //{
            //    new Server
            //    {
            //        Id = 0,
            //        Name = "Placeholder"
            //    }
            //};
            #endregion
        }
Example #6
0
        public ActionResult GetTags()
        {
            using (var db = new ServerDb())
            {
                var result = db.Tags
                             .ToList();

                return(PartialView(result));
            }
        }
Example #7
0
        public List <MasterEntity> Servers()
        {
            using (var db = new ServerDb())
            {
                var result = db.Servers
                             .Include(m => m.services)
                             .Include("applications.dependencies")
                             .ToList();

                return(result);
            }
        }
Example #8
0
        public JsonResult Entities()
        {
            using (var db = new ServerDb())
            {
                var result = db.Servers
                             .Include(m => m.services)
                             .Include("applications.dependencies")
                             .ToList();

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
        }
Example #9
0
        private async Task Client_LeftGuild(SocketGuild arg)
        {
            if (!GuildLeaveEvent)
            {
                return;
            }

            var server = ServerDb.GetServer(arg.Id);

            server.LeaveDate = DateTime.Now;
            await ServerDb.UpdateServer(server);

            await WebhookClients.GuildJoinLogChannel.SendMessageAsync($"<:TickNo:577838859077943306> {Client.CurrentUser.Username} left `{arg.Id}` **{arg.Name}**.\nOwner: `{arg.Owner.Id}` **{arg.Owner}**");
        }
Example #10
0
 void serverUpdate_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
 {
     using (var db = new ServerDb())
     {
         lock (mutexDbAccess)
         {
             DateTime now = DateTime.Now;
             foreach (Server s in db.Servers)
             {
                 s.LastUpdate = now;
             }
         }
     }
 }
        public ActionResult Details(string id)
        {
            using (var db = new ServerDb())
            {
                var result = db.Servers
                             .Include(m => m.environment)
                             .Include(m => m.services)
                             .Include(m => m.iis)
                             .Include("iis.websites.applicationPools")

                             .Where(m => m.Id == id)
                             .FirstOrDefault();
                return(View(result));
            }
        }
Example #12
0
        public async Task SetBotPrefix(string prefix)
        {
            if (prefix.Length < 1)
            {
                return;
            }

            var server = ServerDb.GetServer(Context.Guild.Id);

            server.Prefix = prefix;
            await ServerDb.UpdateServer(server);

            Program.UpdatePrefix(Context.Guild.Id, prefix);
            await Context.Channel.SendMessageAsync($"My prefix is now `{prefix}`");
        }
Example #13
0
        /// <summary>
        /// Use to update a server
        /// </summary>
        /// <param name="id">The ID of the server you want to update</param>
        /// <param name="server">The data you want to update (ID is ignored)</param>
        /// <returns>Return the updated server if it succeeded / return null if it failed and lastExceptionThrown is updated</returns>
        public Server UpdateServer(int id, Server server)
        {
            Server oldServer;

            server.Id         = id;
            server.LastUpdate = DateTime.Now;
            using (var db = new ServerDb())
            {
                lock (mutexDbAccess)
                {
                    oldServer = db.Servers.Find(id);
                    oldServer.Copy(server);

                    db.Entry(oldServer).State = EntityState.Modified;
                    db.SaveChanges();
                }
            }
            return(server);

            #region [ === Old Code : For cache memory (no DB) === ]
            //var ctx = HttpContext.Current;
            //Server newServer = null;

            //if (ctx != null)
            //{
            //    try
            //    {
            //        var currentData = ((Server[])ctx.Cache[CacheKey]).ToList();
            //        // Cannot have a double of IDs because it is handled by the DB (Id is the key)
            //        var serverToUpdate = currentData.FirstOrDefault((s) => s.Id == id);
            //        if (serverToUpdate == default(Server))
            //            throw new Exception("No server found with this ID : " + id);
            //        else
            //            newServer = updateServer(serverToUpdate, server);
            //        ctx.Cache[CacheKey] = currentData.ToArray();

            //        return newServer;
            //    }
            //    catch (Exception ex)
            //    {
            //        this.lastExceptionThrown = ex;
            //        Console.WriteLine(ex.ToString());
            //        return null;
            //    }
            //}
            //return null;
            #endregion
        }
 public ActionResult Index()
 {
     using (var db = new ServerDb())
     {
         var result = db.Servers
                      .Include(m => m.services)
                      .Include(m => m.environment)
                      .Include(m => m.owner)
                      .Include("services.dependencies")
                      .OrderByDescending(m => m.Id)
                      .Skip(0)
                      .Take(50)
                      .ToList();
         return(PartialView(result));
     }
 }
Example #15
0
        // USER JOIN

        private async Task Client_UserJoinedWelcome(SocketGuildUser arg)
        {
            if (arg?.Guild?.Id == 417064769309245471)
            {
                return;
            }

            var server = ServerDb.GetServer(arg.Guild.Id);

            if (server != null && server.WelcomeChannelId != 0)
            {
                var ch = arg.Guild.GetTextChannel(server.WelcomeChannelId);
                if (ch != null)
                {
                    await ch.SendMessageAsync(GetWelcomeMessageString(arg));
                }
            }
        }
Example #16
0
        public bool DeleteServer(int id)
        {
            Server server;

            using (var db = new ServerDb())
            {
                lock (mutexDbAccess)
                {
                    server = db.Servers.Find(id);
                    server = db.Servers.Remove(server);
                    db.SaveChanges();
                }
            }
            if (server != null)
            {
                return(true);
            }
            return(false);

            #region [ === Old Code : For cache memory (no DB) === ]
            //var ctx = HttpContext.Current;

            //if (ctx != null)
            //{
            //    try
            //    {
            //        var currentData = ((Server[])ctx.Cache[CacheKey]).ToList();
            //        var serverToDelete = currentData.FirstOrDefault((s) => s.Id == id);
            //        if (serverToDelete == default(Server))
            //            return false;
            //        currentData.Remove(serverToDelete);
            //        ctx.Cache[CacheKey] = currentData.ToArray();
            //        return true;
            //    }
            //    catch (Exception ex)
            //    {
            //        this.lastExceptionThrown = ex;
            //        Console.WriteLine(ex.ToString());
            //        return false;
            //    }
            //}
            //return false;
            #endregion
        }
Example #17
0
        public async Task SetWelcomeChannel()
        {
            var server = ServerDb.GetServer(Context.Guild.Id);

            if (server.WelcomeChannelId == Context.Channel.Id)
            {
                server.WelcomeChannelId = 0;
                await ServerDb.UpdateServer(server);

                await Context.Channel.SendMessageAsync("Welcome channel removed.");

                return;
            }

            server.WelcomeChannelId = Context.Channel.Id;
            await ServerDb.UpdateServer(server);

            await Context.Channel.SendMessageAsync("Welcome channel set.");
        }
Example #18
0
        /// <summary>
        /// Use to create a new server
        /// </summary>
        /// <param name="server">The server you want to create</param>
        /// <returns>Return null if fails and LastExceptionThrown is updated / Return the created server if succeeded</returns>
        public Server SaveServer(Server server)
        {
            Server newServer;

            server.DateCreated = DateTime.Now;
            server.LastUpdate  = DateTime.Now;
            using (var db = new ServerDb())
            {
                lock (mutexDbAccess)
                {
                    newServer = db.Servers.Add(server);
                    db.SaveChanges();
                }
            }

            return(newServer);

            #region [ === Old Code : For cache memory (no DB) === ]
            //var ctx = HttpContext.Current;

            //if (ctx != null)
            //{
            //    try
            //    {
            //        var currentData = ((Server[])ctx.Cache[CacheKey]).ToList();
            //        server.Id = currentData.Select(s => s.Id).Max();
            //        currentData.Add(server);
            //        ctx.Cache[CacheKey] = currentData.ToArray();

            //        return server;
            //    }
            //    catch (Exception ex)
            //    {
            //        this.lastExceptionThrown = ex;
            //        Console.WriteLine(ex.ToString());
            //        return null;
            //    }
            //}
            //return null;
            #endregion
        }
Example #19
0
        // SET-UP

        private static void SetUp()
        {
            switch (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"))
            {
            case "Development":
                Development = true;
                Pause       = true;
                break;

            default:
                Console.WriteLine("Entry: " + Assembly.GetEntryAssembly().Location);
                _ = ImgurAPI.ImgurSetup();
                break;
            }
            NamikoDbContext.ConnectionString = AppSettings.ConnectionString;
            _        = LootboxStats.Reload(Locations.LootboxStatsJSON);
            Prefixes = ServerDb.GetPrefixes();
            Images.ReactionImageCommands = ImageDb.GetReactionImageCommandHashSet();
            Blacklist  = BlacklistDb.GetAll();
            Waifu.Path = AppSettings.ImageUrlPath + "waifus/";
        }
        public object Post([FromBody] MasterEntity content)
        {
            var json = this.Request.Content.ReadAsStringAsync().Result;

            Console.WriteLine(json);

            using (var db = new ServerDb())
            {
                // Check if the server already exists in the DB
                var old = db.Servers.Where(m => m.Id == content.Id)
                          .Include(m => m.environment)
                          .Include(m => m.iis)
                          .FirstOrDefault();

                // Save Existing Server
                if (old != null)
                {
                    db.Servers.Remove(old);

                    db.Servers.Add(content);

                    db.SaveChanges();
                }
                // Save New Server
                else
                {
                    db.Servers.Add(content);
                    try
                    {
                        db.SaveChanges();
                    }
                    catch (System.Data.Entity.Validation.DbEntityValidationException e)
                    {
                        throw;
                    }
                }
            }

            return(Request.CreateResponse(HttpStatusCode.OK, "OK"));
        }
Example #21
0
        private async Task Client_ReactionAdded(Cacheable <IUserMessage, ulong> arg1, Cacheable <IMessageChannel, ulong> arg2, SocketReaction arg3)
        {
            if (arg3.MessageId != 700399700196458546)
            {
                return;
            }

            SocketTextChannel sch = (await arg2.GetOrDownloadAsync()) as SocketTextChannel;
            var user = sch.Guild.GetUser(arg3.UserId);
            var role = sch.Guild.GetRole(697234413360119808);

            if (RoleUtil.HasRole(user, role))
            {
                return;
            }

            await user.AddRoleAsync(role);

            var chid = ServerDb.GetServer(sch.Guild.Id).WelcomeChannelId;
            var ch   = sch.Guild.GetTextChannel(chid);
            await ch.SendMessageAsync(GetWelcomeMessageString(user));
        }
Example #22
0
        private static async Task <int> CheckJoinedGuilds(DiscordSocketClient shard = null)
        {
            IReadOnlyCollection <SocketGuild> guilds;

            if (shard == null)
            {
                guilds = Client.Guilds;
            }
            else
            {
                guilds = shard.Guilds;
            }

            var existingIds = ServerDb.GetNotLeft();
            var newIds      = guilds.Where(x => !existingIds.Contains(x.Id)).Select(x => x.Id);

            int addedBal = await BalanceDb.AddNewServerBotBalance(newIds, Client.CurrentUser.Id);

            int added = await ServerDb.AddNewServers(newIds, AppSettings.DefaultPrefix);

            return(added);
        }
Example #23
0
 void serverChecker_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
 {
     using (var db = new ServerDb())
     {
         lock (mutexDbAccess)
         {
             DateTime      now        = DateTime.Now;
             List <Server> removeList = new List <Server>();
             TimeSpan?     diff;
             foreach (Server s in db.Servers)
             {
                 if (s.LastUpdate == null)
                 {
                     diff = null;
                 }
                 else
                 {
                     diff = now - s.LastUpdate.Value;
                 }
                 Trace.Write("Checing timers", "Now is : " + now.ToString() + " && LastUpdate is : " + s.LastUpdate + " && Diff is : " + diff);
                 if (diff == null || diff.Value.TotalSeconds > SERVER_LIFETIME)
                 {
                     Trace.Write("Remove server cauz of timer", "Now is : " + now.ToString() + " && LastUpdate is : " + s.LastUpdate + " && Diff is : " + diff);
                     removeList.Add(s);
                 }
             }
             if (removeList.Count > 0)
             {
                 foreach (Server s in removeList)
                 {
                     db.Servers.Remove(s);
                 }
                 //db.Servers.RemoveRange(removeList);
                 db.SaveChanges();
             }
         }
     }
 }
Example #24
0
 static GuildService()
 {
     BotGuilds = ServerDb.GetAll();
 }
 public ServerController(ServerDb Sdb)
 {
     serverDb = Sdb;
 }
Example #26
0
        public async Task TeamKick(IUser user, [Remainder] string str = "")
        {
            var leader = RoleUtil.GetLeaderRole(Context.Guild, Context.User);

            if (leader == null)
            {
                await Context.Channel.SendMessageAsync("You're not a leader! Getting ahead of yourself eh?~");

                return;
            }

            var team       = TeamDb.TeamByLeader(leader.Id);
            var userteam   = RoleUtil.GetMemberRole(Context.Guild, user);
            var leaderteam = Context.Guild.GetRole(team.MemberRoleId);

            if (!userteam.Equals(leaderteam))
            {
                await Context.Channel.SendMessageAsync($"They're not in your team! If you just want to kick them normaly use `{Program.GetPrefix(Context)}kick`");

                return;
            }

            await Context.Guild.GetUser(user.Id).RemoveRoleAsync(userteam);

            await Context.Channel.SendMessageAsync("Ha! One less to take care of!");

            ISocketMessageChannel ch = (ISocketMessageChannel)Context.Client.GetChannel(ServerDb.GetServer(Context.Guild.Id).TeamLogChannelId);
            await ch.SendMessageAsync($":hammer: `{Context.User}` kicked `{user}` from **{userteam.Name}**.");
        }
Example #27
0
        public async Task Leave([Remainder] string str = "")
        {
            var role = RoleUtil.GetMemberRole(Context.Guild, Context.User);

            if (role == null)
            {
                await Context.Channel.SendMessageAsync("Buuut... You're not in a team.");

                return;
            }

            try
            {
                await Context.Guild.GetUser(Context.User.Id).RemoveRoleAsync(role);
            }
            catch
            {
                await Context.Channel.SendMessageAsync($"I tried removing a role that is above my own role. *Coughs blood.* Discord wouldn't let me...");

                return;
            }

            await Context.Channel.SendMessageAsync($@"Ha! You left **{role.Name}**! Too bad for them ¯\_(ツ)_/¯");

            ISocketMessageChannel ch = (ISocketMessageChannel)Context.Client.GetChannel(ServerDb.GetServer(Context.Guild.Id).TeamLogChannelId);
            await ch.SendMessageAsync($"<:TickNo:577838859077943306> `{Context.User}` left **{role.Name}**.");
        }
Example #28
0
        public async Task Join([Remainder] string teamName)
        {
            var role = await this.SelectRole(teamName, TeamDb.Teams(Context.Guild.Id).Select(x => x.MemberRoleId), respond : false);

            if (role == null)
            {
                await Context.Channel.SendMessageAsync($"*~ No teams found ~*");

                return;
            }

            if (InviteDb.IsInvited(role.Id, Context.User.Id))
            {
                var user = Context.Guild.GetUser(Context.User.Id);
                try
                {
                    await user.AddRoleAsync(role);
                } catch
                {
                    await Context.Channel.SendMessageAsync($"I tried giving a role that is above my own role. *Coughs blood.* Discord wouldn't let me...");

                    return;
                }
                await InviteDb.DeleteInvite(role.Id, user.Id);

                await Context.Channel.SendMessageAsync($"Congratulations! You joined **{role.Name}**!");

                ISocketMessageChannel ch = (ISocketMessageChannel)Context.Client.GetChannel(ServerDb.GetServer(Context.Guild.Id).TeamLogChannelId);
                await ch.SendMessageAsync($"<:TickYes:577838859107303424> `{Context.User}` joined **{role.Name}**.");

                return;
            }
            await Context.Channel.SendMessageAsync($"You're not invited to **{role.Name}**! What a shame ^^");
        }
Example #29
0
        public async Task Invite([Remainder] IUser user = null)
        {
            var channel    = Context.Channel;
            var leaderRole = RoleUtil.GetLeaderRole(Context.Guild, Context.User);

            if (leaderRole == null)
            {
                await channel.SendMessageAsync("You're not a team leader, silly.");

                return;
            }

            if (RoleUtil.IsTeamed(Context.Guild, user))
            {
                await channel.SendMessageAsync($@"**{user.Username}** is already in a team, I guess you're too late ¯\_(ツ)_/¯");

                return;
            }

            var team     = TeamDb.TeamByLeader(leaderRole.Id);
            var teamRole = Context.Guild.GetRole(team.MemberRoleId);

            if (InviteDb.IsInvited(team.MemberRoleId, user.Id))
            {
                await channel.SendMessageAsync($"You already invited **{user.Username}**, baaaaaka.");

                return;
            }

            await InviteDb.NewInvite(team.MemberRoleId, user.Id);

            await channel.SendMessageAsync($"{user.Mention} You're invited to join **{teamRole.Name}**! Type `{Program.GetPrefix(Context)}jointeam {teamRole.Name}`");

            ISocketMessageChannel ch = (ISocketMessageChannel)Context.Client.GetChannel(ServerDb.GetServer(Context.Guild.Id).TeamLogChannelId);
            await ch.SendMessageAsync($"<:KannaHype:571690048001671238> `{Context.User}` invited `{user}` to **{teamRole.Name}**.");
        }
Example #30
0
 private static SocketTextChannel GetJoinLogChannel(SocketGuild guild)
 {
     return((SocketTextChannel)guild.GetChannel(ServerDb.GetServer(guild.Id).JoinLogChannelId));
 }