Mute log events, remute if user rejoins

src/NadekoBot/Migrations/20161213025624_mutedusers.Designer.cs

@@ -0,0 +1,825 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using NadekoBot.Services.Database;
+using NadekoBot.Services.Database.Models;
+using NadekoBot.Modules.Music.Classes;
+
+namespace NadekoBot.Migrations
+{
+    [DbContext(typeof(NadekoContext))]
+    [Migration("20161213025624_mutedusers")]
+    partial class mutedusers
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+            modelBuilder
+                .HasAnnotation("ProductVersion", "1.1.0-rtm-22752");
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.BlacklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("BotConfigId");
+
+                    b.Property<ulong>("ItemId");
+
+                    b.Property<int>("Type");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BotConfigId");
+
+                    b.ToTable("BlacklistItem");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.BotConfig", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("BufferSize");
+
+                    b.Property<float>("CurrencyGenerationChance");
+
+                    b.Property<int>("CurrencyGenerationCooldown");
+
+                    b.Property<string>("CurrencyName");
+
+                    b.Property<string>("CurrencyPluralName");
+
+                    b.Property<string>("CurrencySign");
+
+                    b.Property<string>("DMHelpString");
+
+                    b.Property<bool>("ForwardMessages");
+
+                    b.Property<bool>("ForwardToAllOwners");
+
+                    b.Property<string>("HelpString");
+
+                    b.Property<int>("MigrationVersion");
+
+                    b.Property<string>("RemindMessageFormat");
+
+                    b.Property<bool>("RotatingStatuses");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BotConfig");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ClashCaller", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("BaseDestroyed");
+
+                    b.Property<string>("CallUser");
+
+                    b.Property<int>("ClashWarId");
+
+                    b.Property<int?>("SequenceNumber");
+
+                    b.Property<int>("Stars");
+
+                    b.Property<DateTime>("TimeAdded");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClashWarId");
+
+                    b.ToTable("ClashCallers");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ClashWar", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<string>("EnemyClan");
+
+                    b.Property<ulong>("GuildId");
+
+                    b.Property<int>("Size");
+
+                    b.Property<DateTime>("StartedAt");
+
+                    b.Property<int>("WarState");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ClashOfClans");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.CommandCooldown", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("CommandName");
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.Property<int>("Seconds");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.ToTable("CommandCooldown");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ConvertUnit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("InternalTrigger");
+
+                    b.Property<decimal>("Modifier");
+
+                    b.Property<string>("UnitType");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ConversionUnits");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Currency", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<long>("Amount");
+
+                    b.Property<ulong>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Currency");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.CurrencyTransaction", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<long>("Amount");
+
+                    b.Property<string>("Reason");
+
+                    b.Property<ulong>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CurrencyTransactions");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.CustomReaction", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong?>("GuildId");
+
+                    b.Property<bool>("IsRegex");
+
+                    b.Property<bool>("OwnerOnly");
+
+                    b.Property<string>("Response");
+
+                    b.Property<string>("Trigger");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CustomReactions");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Donator", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Amount");
+
+                    b.Property<string>("Name");
+
+                    b.Property<ulong>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("Donators");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.EightBallResponse", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("BotConfigId");
+
+                    b.Property<string>("Text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BotConfigId");
+
+                    b.ToTable("EightBallResponses");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.FilterChannelId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.Property<int?>("GuildConfigId1");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.HasIndex("GuildConfigId1");
+
+                    b.ToTable("FilterChannelId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.FilteredWord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.Property<string>("Word");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.ToTable("FilteredWord");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.FollowedStream", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.Property<ulong>("GuildId");
+
+                    b.Property<int>("Type");
+
+                    b.Property<string>("Username");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.ToTable("FollowedStream");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.GCChannelId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.ToTable("GCChannelId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.GuildConfig", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("AutoAssignRoleId");
+
+                    b.Property<bool>("AutoDeleteByeMessages");
+
+                    b.Property<int>("AutoDeleteByeMessagesTimer");
+
+                    b.Property<bool>("AutoDeleteGreetMessages");
+
+                    b.Property<int>("AutoDeleteGreetMessagesTimer");
+
+                    b.Property<bool>("AutoDeleteSelfAssignedRoleMessages");
+
+                    b.Property<ulong>("ByeMessageChannelId");
+
+                    b.Property<string>("ChannelByeMessageText");
+
+                    b.Property<string>("ChannelGreetMessageText");
+
+                    b.Property<bool>("CleverbotEnabled");
+
+                    b.Property<float>("DefaultMusicVolume");
+
+                    b.Property<bool>("DeleteMessageOnCommand");
+
+                    b.Property<string>("DmGreetMessageText");
+
+                    b.Property<bool>("ExclusiveSelfAssignedRoles");
+
+                    b.Property<bool>("FilterInvites");
+
+                    b.Property<bool>("FilterWords");
+
+                    b.Property<ulong>("GreetMessageChannelId");
+
+                    b.Property<ulong>("GuildId");
+
+                    b.Property<int?>("LogSettingId");
+
+                    b.Property<string>("MuteRoleName");
+
+                    b.Property<string>("PermissionRole");
+
+                    b.Property<int?>("RootPermissionId");
+
+                    b.Property<bool>("SendChannelByeMessage");
+
+                    b.Property<bool>("SendChannelGreetMessage");
+
+                    b.Property<bool>("SendDmGreetMessage");
+
+                    b.Property<bool>("VerbosePermissions");
+
+                    b.Property<bool>("VoicePlusTextEnabled");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId")
+                        .IsUnique();
+
+                    b.HasIndex("LogSettingId");
+
+                    b.HasIndex("RootPermissionId");
+
+                    b.ToTable("GuildConfigs");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredLogChannel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<int?>("LogSettingId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LogSettingId");
+
+                    b.ToTable("IgnoredLogChannels");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredVoicePresenceChannel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<int?>("LogSettingId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LogSettingId");
+
+                    b.ToTable("IgnoredVoicePresenceCHannels");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.LogSetting", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("ChannelCreated");
+
+                    b.Property<bool>("ChannelDestroyed");
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<bool>("ChannelUpdated");
+
+                    b.Property<bool>("IsLogging");
+
+                    b.Property<bool>("LogUserPresence");
+
+                    b.Property<bool>("LogVoicePresence");
+
+                    b.Property<bool>("MessageDeleted");
+
+                    b.Property<bool>("MessageUpdated");
+
+                    b.Property<bool>("UserBanned");
+
+                    b.Property<bool>("UserJoined");
+
+                    b.Property<bool>("UserLeft");
+
+                    b.Property<ulong>("UserPresenceChannelId");
+
+                    b.Property<bool>("UserUnbanned");
+
+                    b.Property<bool>("UserUpdated");
+
+                    b.Property<ulong>("VoicePresenceChannelId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LogSettings");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ModulePrefix", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("BotConfigId");
+
+                    b.Property<string>("ModuleName");
+
+                    b.Property<string>("Prefix");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BotConfigId");
+
+                    b.ToTable("ModulePrefixes");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.MusicPlaylist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Author");
+
+                    b.Property<ulong>("AuthorId");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MusicPlaylists");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.MutedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.Property<ulong>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.ToTable("MutedUserId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Permission", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("NextId");
+
+                    b.Property<int>("PrimaryTarget");
+
+                    b.Property<ulong>("PrimaryTargetId");
+
+                    b.Property<int>("SecondaryTarget");
+
+                    b.Property<string>("SecondaryTargetName");
+
+                    b.Property<bool>("State");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NextId")
+                        .IsUnique();
+
+                    b.ToTable("Permission");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.PlayingStatus", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("BotConfigId");
+
+                    b.Property<string>("Status");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BotConfigId");
+
+                    b.ToTable("PlayingStatus");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.PlaylistSong", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("MusicPlaylistId");
+
+                    b.Property<string>("Provider");
+
+                    b.Property<int>("ProviderType");
+
+                    b.Property<string>("Query");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("Uri");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicPlaylistId");
+
+                    b.ToTable("PlaylistSong");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Quote", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("AuthorId");
+
+                    b.Property<string>("AuthorName")
+                        .IsRequired();
+
+                    b.Property<ulong>("GuildId");
+
+                    b.Property<string>("Keyword")
+                        .IsRequired();
+
+                    b.Property<string>("Text")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Quotes");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.RaceAnimal", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("BotConfigId");
+
+                    b.Property<string>("Icon");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BotConfigId");
+
+                    b.ToTable("RaceAnimals");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Reminder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<bool>("IsPrivate");
+
+                    b.Property<string>("Message");
+
+                    b.Property<ulong>("ServerId");
+
+                    b.Property<ulong>("UserId");
+
+                    b.Property<DateTime>("When");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Reminders");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Repeater", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("ChannelId");
+
+                    b.Property<ulong>("GuildId");
+
+                    b.Property<TimeSpan>("Interval");
+
+                    b.Property<string>("Message");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId")
+                        .IsUnique();
+
+                    b.ToTable("Repeaters");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.SelfAssignedRole", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("GuildId");
+
+                    b.Property<ulong>("RoleId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildId", "RoleId")
+                        .IsUnique();
+
+                    b.ToTable("SelfAssignableRoles");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.UserPokeTypes", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<ulong>("UserId");
+
+                    b.Property<string>("type");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("PokeGame");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.BlacklistItem", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.BotConfig")
+                        .WithMany("Blacklist")
+                        .HasForeignKey("BotConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ClashCaller", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.ClashWar", "ClashWar")
+                        .WithMany("Bases")
+                        .HasForeignKey("ClashWarId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.CommandCooldown", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("CommandCooldowns")
+                        .HasForeignKey("GuildConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.EightBallResponse", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.BotConfig")
+                        .WithMany("EightBallResponses")
+                        .HasForeignKey("BotConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.FilterChannelId", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("FilterInvitesChannelIds")
+                        .HasForeignKey("GuildConfigId");
+
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("FilterWordsChannelIds")
+                        .HasForeignKey("GuildConfigId1");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.FilteredWord", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("FilteredWords")
+                        .HasForeignKey("GuildConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.FollowedStream", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("FollowedStreams")
+                        .HasForeignKey("GuildConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.GCChannelId", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("GenerateCurrencyChannelIds")
+                        .HasForeignKey("GuildConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.GuildConfig", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.LogSetting", "LogSetting")
+                        .WithMany()
+                        .HasForeignKey("LogSettingId");
+
+                    b.HasOne("NadekoBot.Services.Database.Models.Permission", "RootPermission")
+                        .WithMany()
+                        .HasForeignKey("RootPermissionId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredLogChannel", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.LogSetting", "LogSetting")
+                        .WithMany("IgnoredChannels")
+                        .HasForeignKey("LogSettingId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.IgnoredVoicePresenceChannel", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.LogSetting", "LogSetting")
+                        .WithMany("IgnoredVoicePresenceChannelIds")
+                        .HasForeignKey("LogSettingId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.ModulePrefix", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.BotConfig")
+                        .WithMany("ModulePrefixes")
+                        .HasForeignKey("BotConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.MutedUserId", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("MutedUsers")
+                        .HasForeignKey("GuildConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.Permission", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.Permission", "Next")
+                        .WithOne("Previous")
+                        .HasForeignKey("NadekoBot.Services.Database.Models.Permission", "NextId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.PlayingStatus", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.BotConfig")
+                        .WithMany("RotatingStatusMessages")
+                        .HasForeignKey("BotConfigId");
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.PlaylistSong", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.MusicPlaylist")
+                        .WithMany("Songs")
+                        .HasForeignKey("MusicPlaylistId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.RaceAnimal", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.BotConfig")
+                        .WithMany("RaceAnimals")
+                        .HasForeignKey("BotConfigId");
+                });
+        }
+    }
+}

src/NadekoBot/Migrations/20161213025624_mutedusers.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace NadekoBot.Migrations
+{
+    public partial class mutedusers : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "MutedUserId",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    GuildConfigId = table.Column<int>(nullable: true),
+                    UserId = table.Column<ulong>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MutedUserId", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_MutedUserId_GuildConfigs_GuildConfigId",
+                        column: x => x.GuildConfigId,
+                        principalTable: "GuildConfigs",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MutedUserId_GuildConfigId",
+                table: "MutedUserId",
+                column: "GuildConfigId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "MutedUserId");
+        }
+    }
+}

src/NadekoBot/Migrations/NadekoSqliteContextModelSnapshot.cs

@@ -492,6 +492,22 @@ namespace NadekoBot.Migrations
                     b.ToTable("MusicPlaylists");
                 });
 
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.MutedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("GuildConfigId");
+
+                    b.Property<ulong>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GuildConfigId");
+
+                    b.ToTable("MutedUserId");
+                });
+
             modelBuilder.Entity("NadekoBot.Services.Database.Models.Permission", b =>
                 {
                     b.Property<int>("Id")
@@ -663,7 +679,7 @@ namespace NadekoBot.Migrations
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd();
 
-                    b.Property<long>("UserId");
+                    b.Property<ulong>("UserId");
 
                     b.Property<string>("type");
 
@@ -768,6 +784,13 @@ namespace NadekoBot.Migrations
                         .HasForeignKey("BotConfigId");
                 });
 
+            modelBuilder.Entity("NadekoBot.Services.Database.Models.MutedUserId", b =>
+                {
+                    b.HasOne("NadekoBot.Services.Database.Models.GuildConfig")
+                        .WithMany("MutedUsers")
+                        .HasForeignKey("GuildConfigId");
+                });
+
             modelBuilder.Entity("NadekoBot.Services.Database.Models.Permission", b =>
                 {
                     b.HasOne("NadekoBot.Services.Database.Models.Permission", "Next")

src/NadekoBot/Modules/Administration/Administration.cs

@@ -16,6 +16,8 @@ using System.IO;
 using static NadekoBot.Modules.Permissions.Permissions;
 using System.Collections.Concurrent;
 using NLog;
+using NadekoBot.Services.Database;
+using Microsoft.EntityFrameworkCore;
 
 namespace NadekoBot.Modules.Administration
 {
@@ -25,7 +27,7 @@ namespace NadekoBot.Modules.Administration
 
         private static ConcurrentDictionary<ulong, string> GuildMuteRoles { get; } = new ConcurrentDictionary<ulong, string>();
 
-        private static Logger _log { get; }
+        private new static Logger _log { get; }
 
         public Administration() : base()
         {
@@ -36,13 +38,7 @@ namespace NadekoBot.Modules.Administration
             _log = LogManager.GetCurrentClassLogger();
             NadekoBot.CommandHandler.CommandExecuted += DelMsgOnCmd_Handler;
 
-            using (var uow = DbHandler.UnitOfWork())
-            {
-                var configs = NadekoBot.AllGuildConfigs;
-                GuildMuteRoles = new ConcurrentDictionary<ulong, string>(configs
-                        .Where(c=>!string.IsNullOrWhiteSpace(c.MuteRoleName))
-                        .ToDictionary(c => c.GuildId, c => c.MuteRoleName));
-            }
+            
         }
 
         private static async Task DelMsgOnCmd_Handler(IUserMessage msg, Command cmd)
@@ -69,39 +65,6 @@ namespace NadekoBot.Modules.Administration
             }
         }
 
-        private static async Task<IRole> GetMuteRole(IGuild guild)
-        {
-            const string defaultMuteRoleName = "nadeko-mute";
-
-            var muteRoleName = GuildMuteRoles.GetOrAdd(guild.Id, defaultMuteRoleName);
-
-            var muteRole = guild.Roles.FirstOrDefault(r => r.Name == muteRoleName);
-            if (muteRole == null)
-            {
-
-                //if it doesn't exist, create it 
-                try { muteRole = await guild.CreateRoleAsync(muteRoleName, GuildPermissions.None).ConfigureAwait(false); }
-                catch
-                {
-                    //if creations fails,  maybe the name is not correct, find default one, if doesn't work, create default one
-                    muteRole = guild.Roles.FirstOrDefault(r => r.Name == muteRoleName) ??
-                        await guild.CreateRoleAsync(defaultMuteRoleName, GuildPermissions.None).ConfigureAwait(false);
-                }
-
-                foreach (var toOverwrite in guild.GetTextChannels())
-                {
-                    try
-                    {
-                        await toOverwrite.AddPermissionOverwriteAsync(muteRole, new OverwritePermissions(sendMessages: PermValue.Deny, attachFiles: PermValue.Deny))
-                                .ConfigureAwait(false);
-                    }
-                    catch { }
-                    await Task.Delay(200).ConfigureAwait(false);
-                }
-            }
-            return muteRole;
-        }
-
         [NadekoCommand, Usage, Description, Aliases]
         [RequireContext(ContextType.Guild)]
         [RequirePermission(GuildPermission.Administrator)]
@@ -391,145 +354,6 @@ namespace NadekoBot.Modules.Administration
             }
         }
 
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.ManageRoles)]
-        [Priority(1)]
-        public async Task SetMuteRole(IUserMessage imsg, [Remainder] string name)
-        {
-            var channel = (ITextChannel)imsg.Channel;
-            name = name.Trim();
-            if (string.IsNullOrWhiteSpace(name))
-                return;
-            
-            using (var uow = DbHandler.UnitOfWork())
-            {
-                var config = uow.GuildConfigs.For(channel.Guild.Id, set => set);
-                config.MuteRoleName = name;
-                GuildMuteRoles.AddOrUpdate(channel.Guild.Id, name, (id, old) => name);
-                await uow.CompleteAsync().ConfigureAwait(false);
-            }
-            await channel.SendConfirmAsync("☑️ **New mute role set.**").ConfigureAwait(false);
-        }
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.ManageRoles)]
-        [Priority(0)]
-        public Task SetMuteRole(IUserMessage imsg, [Remainder] IRole role)
-            => SetMuteRole(imsg, role.Name);
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.ManageRoles)]
-        [RequirePermission(GuildPermission.MuteMembers)]
-        public async Task Mute(IUserMessage umsg, IGuildUser user)
-        {
-            var channel = (ITextChannel)umsg.Channel;
-
-            try
-            {
-                await user.ModifyAsync(usr => usr.Mute = true).ConfigureAwait(false);
-                await user.AddRolesAsync(await GetMuteRole(channel.Guild).ConfigureAwait(false)).ConfigureAwait(false);
-                await channel.SendConfirmAsync($"🔇 **{user}** has been **muted** from text and voice chat successfully.").ConfigureAwait(false);
-            }
-            catch
-            {
-                await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
-            }
-        }
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.ManageRoles)]
-        [RequirePermission(GuildPermission.MuteMembers)]
-        public async Task Unmute(IUserMessage umsg, IGuildUser user)
-        {
-            var channel = (ITextChannel)umsg.Channel;
-
-            try
-            {
-                await user.ModifyAsync(usr => usr.Mute = false).ConfigureAwait(false);
-                await user.RemoveRolesAsync(await GetMuteRole(channel.Guild).ConfigureAwait(false)).ConfigureAwait(false);
-                await channel.SendConfirmAsync($"🔉 **{user}** has been **unmuted** from text and voice chat successfully.").ConfigureAwait(false);
-            }
-            catch
-            {
-                await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
-            }
-        }
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.ManageRoles)]
-        public async Task ChatMute(IUserMessage umsg, IGuildUser user)
-        {
-            var channel = (ITextChannel)umsg.Channel;
-
-            try
-            {
-                await user.AddRolesAsync(await GetMuteRole(channel.Guild).ConfigureAwait(false)).ConfigureAwait(false);
-                await channel.SendConfirmAsync($"✏️🚫 **{user}** has been **muted** from chatting successfully.").ConfigureAwait(false);
-            }
-            catch
-            {
-                await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
-            }
-        }
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.ManageRoles)]
-        public async Task ChatUnmute(IUserMessage umsg, IGuildUser user)
-        {
-            var channel = (ITextChannel)umsg.Channel;
-
-            try
-            {
-                await user.RemoveRolesAsync(await GetMuteRole(channel.Guild).ConfigureAwait(false)).ConfigureAwait(false);
-                await channel.SendConfirmAsync($"✏️✅ **{user}** has been **unmuted** from chatting successfully.").ConfigureAwait(false);
-            }
-            catch
-            {
-                await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
-            }
-        }
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.MuteMembers)]
-        public async Task VoiceMute(IUserMessage umsg, IGuildUser user)
-        {
-            var channel = (ITextChannel)umsg.Channel;
-
-            try
-            {
-                await user.ModifyAsync(usr => usr.Mute = true).ConfigureAwait(false);
-                await channel.SendConfirmAsync($"🎙🚫 **{user}** has been **voice muted** successfully.").ConfigureAwait(false);
-            }
-            catch
-            {
-                await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
-            }
-        }
-
-        [NadekoCommand, Usage, Description, Aliases]
-        [RequireContext(ContextType.Guild)]
-        [RequirePermission(GuildPermission.MuteMembers)]
-        public async Task VoiceUnmute(IUserMessage umsg, IGuildUser user)
-        {
-            var channel = (ITextChannel)umsg.Channel;
-            try
-            {
-                await user.ModifyAsync(usr => usr.Mute = false).ConfigureAwait(false);
-                await channel.SendConfirmAsync($"🎙✅ **{user}** has been **voice unmuted** successfully.").ConfigureAwait(false);
-            }
-            catch
-            {
-                await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
-            }
-        }
-
         [NadekoCommand, Usage, Description, Aliases]
         [RequireContext(ContextType.Guild)]
         [RequirePermission(GuildPermission.DeafenMembers)]

src/NadekoBot/Modules/Administration/Commands/AntiRaidCommands.cs

@@ -106,7 +106,7 @@ namespace NadekoBot.Modules.Administration
                             {
                                 if (spamSettings.UserStats.TryRemove(msg.Author.Id, out stats))
                                 {
-                                    await PunishUsers(spamSettings.Action, await GetMuteRole(channel.Guild), ProtectionType.Spamming, (IGuildUser)msg.Author)
+                                    await PunishUsers(spamSettings.Action, ProtectionType.Spamming, (IGuildUser)msg.Author)
                                         .ConfigureAwait(false);
                                 }
                             }
@@ -137,7 +137,7 @@ namespace NadekoBot.Modules.Administration
                             var users = settings.RaidUsers.ToArray();
                             settings.RaidUsers.Clear();
 
-                            await PunishUsers(settings.Action, await GetMuteRole(usr.Guild), ProtectionType.Raiding, users).ConfigureAwait(false);
+                            await PunishUsers(settings.Action, ProtectionType.Raiding, users).ConfigureAwait(false);
                         }
                         await Task.Delay(1000 * settings.Seconds).ConfigureAwait(false);
 
@@ -149,7 +149,7 @@ namespace NadekoBot.Modules.Administration
                 };
             }
 
-            private static async Task PunishUsers(PunishmentAction action, IRole muteRole, ProtectionType pt, params IGuildUser[] gus)
+            private static async Task PunishUsers(PunishmentAction action, ProtectionType pt, params IGuildUser[] gus)
             {
                 foreach (var gu in gus)
                 {
@@ -158,21 +158,21 @@ namespace NadekoBot.Modules.Administration
                         case PunishmentAction.Mute:
                             try
                             {
-                                await gu.AddRolesAsync(muteRole);
+                                await MuteCommands.Mute(gu).ConfigureAwait(false);
                             }
                             catch (Exception ex) { _log.Warn(ex, "I can't apply punishement"); }
                             break;
                         case PunishmentAction.Kick:
                             try
                             {
-                                await gu.Guild.AddBanAsync(gu, 7);
+                                await gu.Guild.AddBanAsync(gu, 7).ConfigureAwait(false);
                                 try
                                 {
-                                    await gu.Guild.RemoveBanAsync(gu);
+                                    await gu.Guild.RemoveBanAsync(gu).ConfigureAwait(false);
                                 }
                                 catch
                                 {
-                                    await gu.Guild.RemoveBanAsync(gu);
+                                    await gu.Guild.RemoveBanAsync(gu).ConfigureAwait(false);
                                     // try it twice, really don't want to ban user if 
                                     // only kick has been specified as the punishement
                                 }
@@ -182,7 +182,7 @@ namespace NadekoBot.Modules.Administration
                         case PunishmentAction.Ban:
                             try
                             {
-                                await gu.Guild.AddBanAsync(gu, 7);
+                                await gu.Guild.AddBanAsync(gu, 7).ConfigureAwait(false);
                             }
                             catch (Exception ex) { _log.Warn(ex, "I can't apply punishment"); }
                             break;
@@ -215,7 +215,7 @@ namespace NadekoBot.Modules.Administration
 
                 try
                 {
-                    await GetMuteRole(channel.Guild).ConfigureAwait(false);
+                    await MuteCommands.GetMuteRole(channel.Guild).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -257,7 +257,7 @@ namespace NadekoBot.Modules.Administration
                 {
                     try
                     {
-                        await GetMuteRole(channel.Guild).ConfigureAwait(false);
+                        await MuteCommands.GetMuteRole(channel.Guild).ConfigureAwait(false);
                     }
                     catch (Exception ex)
                     {

src/NadekoBot/Modules/Administration/Commands/AutoAssignRoleCommands.cs

@@ -27,11 +27,7 @@ namespace NadekoBot.Modules.Administration
                     {
                         try
                         {
-                            GuildConfig conf;
-                            using (var uow = DbHandler.UnitOfWork())
-                            {
-                                conf = uow.GuildConfigs.For(user.Guild.Id, set => set);
-                            }
+                            GuildConfig conf = NadekoBot.AllGuildConfigs.FirstOrDefault(gc => gc.GuildId == user.Guild.Id);
 
                             if (conf.AutoAssignRoleId == 0)
                                 return;

src/NadekoBot/Modules/Administration/Commands/LogCommand.cs

@@ -79,6 +79,73 @@ namespace NadekoBot.Modules.Administration
                 _client.ChannelCreated += _client_ChannelCreated;
                 _client.ChannelDestroyed += _client_ChannelDestroyed;
                 _client.ChannelUpdated += _client_ChannelUpdated;
+
+                MuteCommands.UserMuted += MuteCommands_UserMuted;
+                MuteCommands.UserUnmuted += MuteCommands_UserUnmuted;
+            }
+
+            private Task MuteCommands_UserMuted(IGuildUser usr, MuteCommands.MuteType muteType)
+            {
+                LogSetting logSetting;
+                if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out logSetting)
+                    || !logSetting.IsLogging)
+                    return Task.CompletedTask;
+
+                ITextChannel logChannel;
+                if ((logChannel = TryGetLogChannel(usr.Guild, logSetting)) == null)
+                    return Task.CompletedTask;
+
+                var task = Task.Run(async () =>
+                {
+                    string mutes = "";
+                    switch (muteType)
+                    {
+                        case MuteCommands.MuteType.Voice:
+                            mutes = "voice chat";
+                            break;
+                        case MuteCommands.MuteType.Chat:
+                            mutes = "text chat";
+                            break;
+                        case MuteCommands.MuteType.All:
+                            mutes = "text and voice chat";
+                            break;
+                    }
+                    try { await logChannel.SendMessageAsync($"‼️🕕`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__🔇 **| User muted from the {mutes}. |** 🆔 `{usr.Id}`").ConfigureAwait(false); } catch (Exception ex) { _log.Warn(ex); }
+                });
+
+                return Task.CompletedTask;
+            }
+
+            private Task MuteCommands_UserUnmuted(IGuildUser usr, MuteCommands.MuteType muteType)
+            {
+                LogSetting logSetting;
+                if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out logSetting)
+                    || !logSetting.IsLogging)
+                    return Task.CompletedTask;
+
+                ITextChannel logChannel;
+                if ((logChannel = TryGetLogChannel(usr.Guild, logSetting)) == null)
+                    return Task.CompletedTask;
+
+                var task = Task.Run(async () =>
+                {
+                    string mutes = "";
+                    switch (muteType)
+                    {
+                        case MuteCommands.MuteType.Voice:
+                            mutes = "voice chat";
+                            break;
+                        case MuteCommands.MuteType.Chat:
+                            mutes = "text chat";
+                            break;
+                        case MuteCommands.MuteType.All:
+                            mutes = "text and voice chat";
+                            break;
+                    }
+                    try { await logChannel.SendMessageAsync($"‼️🕕`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__🔊 **| User unmuted from the {mutes}. |** 🆔 `{usr.Id}`").ConfigureAwait(false); } catch (Exception ex) { _log.Warn(ex); }
+                });
+
+                return Task.CompletedTask;
             }
 
             public static async Task TriggeredAntiProtection(IGuildUser[] users, PunishmentAction action, ProtectionType protection)
@@ -470,38 +537,6 @@ namespace NadekoBot.Modules.Administration
                 return Task.CompletedTask;
             }
 
-//            private Task _client_MessageReceived(IMessage imsg)
-//            {
-//                var msg = imsg as IUserMessage;
-//                if (msg == null || msg.IsAuthor())
-//                    return Task.CompletedTask;
-
-//                var channel = msg.Channel as ITextChannel;
-//                if (channel == null)
-//                    return Task.CompletedTask;
-
-//                LogSetting logSetting;
-//                if (!GuildLogSettings.TryGetValue(channel.Guild.Id, out logSetting) 
-//                    || !logSetting.IsLogging
-//                    || !logSetting.MessageReceived)
-//                    return Task.CompletedTask;
-
-//                ITextChannel logChannel;
-//                if ((logChannel = TryGetLogChannel(channel.Guild, logSetting)) == null || logChannel.Id == imsg.Channel.Id)
-//                    return Task.CompletedTask;
-
-//                var task = Task.Run(async () =>
-//                {
-//                    var str = $@"🕔`{prettyCurrentTime}` **New Message** `#{channel.Name}`
-//👤`{msg.Author.Username}`: {msg.Resolve(userHandling: UserMentionHandling.NameAndDiscriminator)}";
-//                    if (msg.Attachments.Any())
-//                        str += $"{Environment.NewLine}`Attachements`: {string.Join(", ", msg.Attachments.Select(a => a.ProxyUrl))}";
-//                    await logChannel.SendMessageAsync(str).ConfigureAwait(false);
-//                });
-                
-//                return Task.CompletedTask;
-//            }
-
             private enum LogChannelType { Text, Voice, UserPresence };
             private static ITextChannel TryGetLogChannel(IGuild guild, LogSetting logSetting, LogChannelType logChannelType = LogChannelType.Text)
             {

src/NadekoBot/Modules/Administration/Commands/MuteCommands.cs

@@ -0,0 +1,275 @@
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+using Microsoft.EntityFrameworkCore;
+using NadekoBot.Attributes;
+using NadekoBot.Extensions;
+using NadekoBot.Services;
+using NadekoBot.Services.Database.Models;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NadekoBot.Modules.Administration
+{
+    public partial class Administration
+    {
+        [Group]
+        public class MuteCommands
+        {
+            private static ConcurrentDictionary<ulong, string> GuildMuteRoles { get; } = new ConcurrentDictionary<ulong, string>();
+
+            private static ConcurrentDictionary<ulong, ConcurrentHashSet<ulong>> MutedUsers { get; } = new ConcurrentDictionary<ulong, ConcurrentHashSet<ulong>>();
+
+            public static event Func<IGuildUser, MuteType, Task> UserMuted = delegate { return Task.CompletedTask; };
+            public static event Func<IGuildUser, MuteType, Task> UserUnmuted = delegate { return Task.CompletedTask; };
+
+
+            public enum MuteType {
+                Voice,
+                Chat,
+                All
+            }
+
+            static MuteCommands() {
+                using (var uow = DbHandler.UnitOfWork())
+                {
+                    var configs = NadekoBot.AllGuildConfigs;
+                    GuildMuteRoles = new ConcurrentDictionary<ulong, string>(configs
+                            .Where(c => !string.IsNullOrWhiteSpace(c.MuteRoleName))
+                            .ToDictionary(c => c.GuildId, c => c.MuteRoleName));
+
+                    MutedUsers = new ConcurrentDictionary<ulong, ConcurrentHashSet<ulong>>(configs.ToDictionary(
+                        k => k.GuildId,
+                        v => new ConcurrentHashSet<ulong>(v.MutedUsers.Select(m => m.UserId))
+                    ));
+                }
+
+                NadekoBot.Client.UserJoined += Client_UserJoined;
+            }
+
+            private static async Task Client_UserJoined(IGuildUser usr)
+            {
+                ConcurrentHashSet<ulong> muted;
+                MutedUsers.TryGetValue(usr.Guild.Id, out muted);
+
+                if (muted == null || !muted.Contains(usr.Id))
+                    return;
+                else
+                    await Mute(usr).ConfigureAwait(false);
+                    
+            }
+
+            public static async Task Mute(IGuildUser usr)
+            {
+                await usr.ModifyAsync(x => x.Mute = true).ConfigureAwait(false);
+                await usr.AddRolesAsync(await GetMuteRole(usr.Guild)).ConfigureAwait(false);
+                using (var uow = DbHandler.UnitOfWork())
+                {
+                    var config = uow.GuildConfigs.For(usr.Guild.Id, set => set.Include(gc => gc.MutedUsers));
+                    config.MutedUsers.Add(new MutedUserId()
+                    {
+                        UserId = usr.Id
+                    });
+                    await uow.CompleteAsync().ConfigureAwait(false);
+                }
+                await UserMuted(usr, MuteType.All).ConfigureAwait(false);
+            }
+
+            public static async Task Unmute(IGuildUser usr)
+            {
+                await usr.ModifyAsync(x => x.Mute = true).ConfigureAwait(false);
+                await usr.AddRolesAsync(await GetMuteRole(usr.Guild)).ConfigureAwait(false);
+                using (var uow = DbHandler.UnitOfWork())
+                {
+                    var config = uow.GuildConfigs.For(usr.Guild.Id, set => set.Include(gc => gc.MutedUsers));
+                    config.MutedUsers.Remove(new MutedUserId()
+                    {
+                        UserId = usr.Id
+                    });
+                    await uow.CompleteAsync().ConfigureAwait(false);
+                }
+                ConcurrentHashSet<ulong> muted;
+                MutedUsers.TryGetValue(usr.Guild.Id, out muted);
+                await UserUnmuted(usr, MuteType.All).ConfigureAwait(false);
+            }
+
+            public static async Task<IRole> GetMuteRole(IGuild guild)
+            {
+                const string defaultMuteRoleName = "nadeko-mute";
+
+                var muteRoleName = GuildMuteRoles.GetOrAdd(guild.Id, defaultMuteRoleName);
+
+                var muteRole = guild.Roles.FirstOrDefault(r => r.Name == muteRoleName);
+                if (muteRole == null)
+                {
+
+                    //if it doesn't exist, create it 
+                    try { muteRole = await guild.CreateRoleAsync(muteRoleName, GuildPermissions.None).ConfigureAwait(false); }
+                    catch
+                    {
+                        //if creations fails,  maybe the name is not correct, find default one, if doesn't work, create default one
+                        muteRole = guild.Roles.FirstOrDefault(r => r.Name == muteRoleName) ??
+                            await guild.CreateRoleAsync(defaultMuteRoleName, GuildPermissions.None).ConfigureAwait(false);
+                    }
+
+                    foreach (var toOverwrite in guild.GetTextChannels())
+                    {
+                        try
+                        {
+                            await toOverwrite.AddPermissionOverwriteAsync(muteRole, new OverwritePermissions(sendMessages: PermValue.Deny, attachFiles: PermValue.Deny))
+                                    .ConfigureAwait(false);
+                        }
+                        catch { }
+                        await Task.Delay(200).ConfigureAwait(false);
+                    }
+                }
+                return muteRole;
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.ManageRoles)]
+            [Priority(1)]
+            public async Task SetMuteRole(IUserMessage imsg, [Remainder] string name)
+            {
+                var channel = (ITextChannel)imsg.Channel;
+                name = name.Trim();
+                if (string.IsNullOrWhiteSpace(name))
+                    return;
+
+                using (var uow = DbHandler.UnitOfWork())
+                {
+                    var config = uow.GuildConfigs.For(channel.Guild.Id, set => set);
+                    config.MuteRoleName = name;
+                    GuildMuteRoles.AddOrUpdate(channel.Guild.Id, name, (id, old) => name);
+                    await uow.CompleteAsync().ConfigureAwait(false);
+                }
+                await channel.SendConfirmAsync("☑️ **New mute role set.**").ConfigureAwait(false);
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.ManageRoles)]
+            [Priority(0)]
+            public Task SetMuteRole(IUserMessage imsg, [Remainder] IRole role)
+                => SetMuteRole(imsg, role.Name);
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.ManageRoles)]
+            [RequirePermission(GuildPermission.MuteMembers)]
+            public async Task Mute(IUserMessage umsg, IGuildUser user)
+            {
+                var channel = (ITextChannel)umsg.Channel;
+
+                try
+                {
+                    await Mute(user).ConfigureAwait(false);                    
+                    await channel.SendConfirmAsync($"🔇 **{user}** has been **muted** from text and voice chat.").ConfigureAwait(false);
+                }
+                catch
+                {
+                    await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
+                }
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.ManageRoles)]
+            [RequirePermission(GuildPermission.MuteMembers)]
+            public async Task Unmute(IUserMessage umsg, IGuildUser user)
+            {
+                var channel = (ITextChannel)umsg.Channel;
+
+                try
+                {
+                    await Unmute(user).ConfigureAwait(false);
+                    await channel.SendConfirmAsync($"🔉 **{user}** has been **unmuted** from text and voice chat.").ConfigureAwait(false);
+                }
+                catch
+                {
+                    await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
+                }
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.ManageRoles)]
+            public async Task ChatMute(IUserMessage umsg, IGuildUser user)
+            {
+                var channel = (ITextChannel)umsg.Channel;
+
+                try
+                {
+                    await user.AddRolesAsync(await GetMuteRole(channel.Guild).ConfigureAwait(false)).ConfigureAwait(false);
+                    await UserMuted(user, MuteType.Chat).ConfigureAwait(false);
+                    await channel.SendConfirmAsync($"✏️🚫 **{user}** has been **muted** from chatting.").ConfigureAwait(false);
+                }
+                catch
+                {
+                    await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
+                }
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.ManageRoles)]
+            public async Task ChatUnmute(IUserMessage umsg, IGuildUser user)
+            {
+                var channel = (ITextChannel)umsg.Channel;
+
+                try
+                {
+                    await user.RemoveRolesAsync(await GetMuteRole(channel.Guild).ConfigureAwait(false)).ConfigureAwait(false);
+                    await UserUnmuted(user, MuteType.Chat).ConfigureAwait(false);
+                    await channel.SendConfirmAsync($"✏️✅ **{user}** has been **unmuted** from chatting.").ConfigureAwait(false);
+                }
+                catch
+                {
+                    await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
+                }
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.MuteMembers)]
+            public async Task VoiceMute(IUserMessage umsg, IGuildUser user)
+            {
+                var channel = (ITextChannel)umsg.Channel;
+
+                try
+                {
+                    await user.ModifyAsync(usr => usr.Mute = true).ConfigureAwait(false);
+                    await UserMuted(user, MuteType.Voice).ConfigureAwait(false);
+                    await channel.SendConfirmAsync($"🎙🚫 **{user}** has been **voice muted**.").ConfigureAwait(false);
+                }
+                catch
+                {
+                    await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
+                }
+            }
+
+            [NadekoCommand, Usage, Description, Aliases]
+            [RequireContext(ContextType.Guild)]
+            [RequirePermission(GuildPermission.MuteMembers)]
+            public async Task VoiceUnmute(IUserMessage umsg, IGuildUser user)
+            {
+                var channel = (ITextChannel)umsg.Channel;
+                try
+                {
+                    await user.ModifyAsync(usr => usr.Mute = false).ConfigureAwait(false);
+                    await UserUnmuted(user, MuteType.Voice).ConfigureAwait(false);
+                    await channel.SendConfirmAsync($"🎙✅ **{user}** has been **voice unmuted**.").ConfigureAwait(false);
+                }
+                catch
+                {
+                    await channel.SendErrorAsync("⚠️ I most likely don't have the permission necessary for that.").ConfigureAwait(false);
+                }
+            }
+        }
+    }
+}

src/NadekoBot/Services/Database/Models/GuildConfig.cs

@@ -54,11 +54,13 @@ namespace NadekoBot.Services.Database.Models
         public HashSet<FilteredWord> FilteredWords { get; set; } = new HashSet<FilteredWord>();
         public HashSet<FilterChannelId> FilterWordsChannelIds { get; set; } = new HashSet<FilterChannelId>();
 
+        public HashSet<MutedUserId> MutedUsers { get; set; } = new HashSet<MutedUserId>();
+
         public string MuteRoleName { get; set; }
         public bool CleverbotEnabled { get; set; }
     }
 
-    public class FilterChannelId :DbEntity
+    public class FilterChannelId : DbEntity
     {
         public ulong ChannelId { get; set; }
     }
@@ -68,6 +70,25 @@ namespace NadekoBot.Services.Database.Models
         public string Word { get; set; }
     }
 
+    public class MutedUserId : DbEntity
+    {
+        public ulong UserId { get; set; }
+
+        public override int GetHashCode()
+        {
+            return UserId.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            var mui = obj as MutedUserId;
+            if (mui == null)
+                return false;
+
+            return mui.UserId == this.UserId;
+        }
+    }
+
     public class GCChannelId : DbEntity
     {
         public ulong ChannelId { get; set; }

src/NadekoBot/Services/Database/NadekoContext.cs

@@ -44,7 +44,7 @@ namespace NadekoBot.Services.Database
             this.Database.Migrate();
             EnsureSeedData();
         }
-        //Uncomment this to db initialisation with dotnet ef migration add [module]
+        ////Uncomment this to db initialisation with dotnet ef migration add [module]
         //protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         //{
         //    optionsBuilder.UseSqlite("Filename=./data/NadekoBot.db");

src/NadekoBot/Services/Database/Repositories/Impl/GuildConfigRepository.cs

@@ -22,6 +22,7 @@ namespace NadekoBot.Services.Database.Repositories.Impl
                     .ThenInclude(gc => gc.Previous)
                 .Include(gc => gc.RootPermission)
                     .ThenInclude(gc => gc.Next)
+                .Include(gc => gc.MutedUsers)
                 .Include(gc => gc.GenerateCurrencyChannelIds)
                 .Include(gc => gc.FilterInvitesChannelIds)
                 .Include(gc => gc.FilterWordsChannelIds)