Split Geekbot.net into src/Bot, src/Core, and src/Web

src/Core/Database/DatabaseContext.cs

@@ -0,0 +1,21 @@
+using Geekbot.Core.Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Geekbot.Core.Database
+{
+    public class DatabaseContext : DbContext
+    {
+        public DbSet<QuoteModel> Quotes { get; set; }
+        public DbSet<UserModel> Users { get; set; }
+        public DbSet<GuildSettingsModel> GuildSettings { get; set; }
+        public DbSet<KarmaModel> Karma { get; set; }
+        public DbSet<ShipsModel> Ships { get; set; }
+        public DbSet<RollsModel> Rolls { get; set; }
+        public DbSet<MessagesModel> Messages { get; set; }
+        public DbSet<SlapsModel> Slaps { get; set; }
+        public DbSet<GlobalsModel> Globals { get; set; }
+        public DbSet<RoleSelfServiceModel> RoleSelfService { get; set; }
+        public DbSet<CookiesModel> Cookies { get; set; }
+        public DbSet<ReactionListenerModel> ReactionListeners { get; set; }
+    }
+}

src/Core/Database/DatabaseInitializer.cs

@@ -0,0 +1,58 @@
+using System;
+using Geekbot.Core.Database.LoggingAdapter;
+using Geekbot.Core.Logger;
+using Npgsql.Logging;
+
+namespace Geekbot.Core.Database
+{
+    public class DatabaseInitializer
+    {
+        private readonly RunParameters _runParameters;
+        private readonly GeekbotLogger _logger;
+
+        public DatabaseInitializer(RunParameters runParameters, GeekbotLogger logger)
+        {
+            _runParameters = runParameters;
+            _logger = logger;
+            NpgsqlLogManager.Provider = new NpgsqlLoggingProviderAdapter(logger, runParameters);
+        }
+
+        public DatabaseContext Initialize()
+        {
+            DatabaseContext database = null;
+            try
+            {
+                if (_runParameters.InMemory)
+                {
+                    database = new InMemoryDatabase("geekbot");
+                }
+                else
+                {
+                    database = new SqlDatabase(new SqlConnectionString
+                    {
+                        Host = _runParameters.DbHost,
+                        Port = _runParameters.DbPort,
+                        Database = _runParameters.DbDatabase,
+                        Username = _runParameters.DbUser,
+                        Password = _runParameters.DbPassword,
+                        RequireSsl = _runParameters.DbSsl,
+                        TrustServerCertificate = _runParameters.DbTrustCert,
+                        RedshiftCompatibility = _runParameters.DbRedshiftCompatibility
+                    });
+                }
+            }
+            catch (Exception e)
+            {
+                _logger.Error(LogSource.Geekbot, "Could not Connect to datbase", e);
+                Environment.Exit(GeekbotExitCode.DatabaseConnectionFailed.GetHashCode());
+            }
+
+            if (_runParameters.DbLogging)
+            {
+                _logger.Information(LogSource.Database, $"Connected with {database.Database.ProviderName}");
+            }
+
+            return database;
+        }
+    }
+}

src/Core/Database/InMemoryDatabase.cs

@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace Geekbot.Core.Database
+{
+    public class InMemoryDatabase : DatabaseContext
+    {
+        private readonly string _name;
+
+        public InMemoryDatabase(string name)
+        {
+            _name = name;
+        }
+        
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+            => optionsBuilder.UseInMemoryDatabase(_name);
+    }
+}

src/Core/Database/LoggingAdapter/NpgsqlLoggingAdapter.cs

@@ -0,0 +1,68 @@
+using System;
+using Geekbot.Core.Logger;
+using Npgsql.Logging;
+using LogLevel = NLog.LogLevel;
+
+namespace Geekbot.Core.Database.LoggingAdapter
+{
+    public class NpgsqlLoggingAdapter : NpgsqlLogger
+    {
+        private readonly string _name;
+        private readonly IGeekbotLogger _geekbotLogger;
+        private readonly RunParameters _runParameters;
+
+        public NpgsqlLoggingAdapter(string name, IGeekbotLogger geekbotLogger, RunParameters runParameters)
+        {
+            _name = name.Substring(7);
+            _geekbotLogger = geekbotLogger;
+            _runParameters = runParameters;
+            geekbotLogger.Trace(LogSource.Database, $"Loaded Npgsql logging adapter: {name}");
+        }
+        
+        public override bool IsEnabled(NpgsqlLogLevel level)
+        {
+            return (_runParameters.DbLogging && _geekbotLogger.GetNLogger().IsEnabled(ToGeekbotLogLevel(level)));
+        }
+
+        public override void Log(NpgsqlLogLevel level, int connectorId, string msg, Exception exception = null)
+        {
+            var nameAndMessage = $"{_name}: {msg}";
+            switch (level)
+            {
+                case NpgsqlLogLevel.Trace:
+                    _geekbotLogger.Trace(LogSource.Database, nameAndMessage);
+                    break;
+                case NpgsqlLogLevel.Debug:
+                    _geekbotLogger.Debug(LogSource.Database, nameAndMessage);
+                    break;
+                case NpgsqlLogLevel.Info:
+                    _geekbotLogger.Information(LogSource.Database, nameAndMessage);
+                    break;
+                case NpgsqlLogLevel.Warn:
+                    _geekbotLogger.Warning(LogSource.Database, nameAndMessage, exception);
+                    break;
+                case NpgsqlLogLevel.Error:
+                case NpgsqlLogLevel.Fatal:
+                    _geekbotLogger.Error(LogSource.Database, nameAndMessage, exception);
+                    break;
+                default:
+                    _geekbotLogger.Information(LogSource.Database, nameAndMessage);
+                    break;
+            }
+        }
+
+        private static LogLevel ToGeekbotLogLevel(NpgsqlLogLevel level)
+        {
+            return level switch
+            {
+                NpgsqlLogLevel.Trace => LogLevel.Trace,
+                NpgsqlLogLevel.Debug => LogLevel.Debug,
+                NpgsqlLogLevel.Info => LogLevel.Info,
+                NpgsqlLogLevel.Warn => LogLevel.Warn,
+                NpgsqlLogLevel.Error => LogLevel.Error,
+                NpgsqlLogLevel.Fatal => LogLevel.Fatal,
+                _ => throw new ArgumentOutOfRangeException(nameof(level))
+            };
+        }
+    }
+}

src/Core/Database/LoggingAdapter/NpgsqlLoggingProviderAdapter.cs

@@ -0,0 +1,22 @@
+using Geekbot.Core.Logger;
+using Npgsql.Logging;
+
+namespace Geekbot.Core.Database.LoggingAdapter
+{
+    public class NpgsqlLoggingProviderAdapter : INpgsqlLoggingProvider
+    {
+        private readonly GeekbotLogger _geekbotLogger;
+        private readonly RunParameters _runParameters;
+
+        public NpgsqlLoggingProviderAdapter(GeekbotLogger geekbotLogger, RunParameters runParameters)
+        {
+            _geekbotLogger = geekbotLogger;
+            _runParameters = runParameters;
+        }
+        
+        public NpgsqlLogger CreateLogger(string name)
+        {
+            return new NpgsqlLoggingAdapter(name, _geekbotLogger, _runParameters);
+        }
+    }
+}

src/Core/Database/Models/CookiesModel.cs

@@ -0,0 +1,21 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class CookiesModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+
+        public int Cookies { get; set; } = 0;
+        
+        public DateTimeOffset? LastPayout { get; set; }
+    }
+}

src/Core/Database/Models/GlobalsModel.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class GlobalsModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public string Name { get; set; }
+        
+        [Required]
+        public string Value { get; set; }
+        
+        public string Meta { get; set; }
+    }
+}

src/Core/Database/Models/GuildSettingsModel.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class GuildSettingsModel
+    {
+        [Key]
+        public int Id { get; set; }
+
+        [Required]
+        public long GuildId { get; set; }
+
+        public bool Ping { get; set; } = false;
+
+        public bool Hui { get; set; } = false;
+
+        public long ModChannel { get; set; } = 0;
+
+        public string WelcomeMessage { get; set; }
+
+        public long WelcomeChannel { get; set; }
+
+        public bool ShowDelete { get; set; } = false;
+
+        public bool ShowLeave { get; set; } = false;
+
+        public string WikiLang { get; set; } = "en";
+
+        public string Language { get; set; } = "EN";
+    }
+}

src/Core/Database/Models/KarmaModel.cs

@@ -0,0 +1,21 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class KarmaModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+        
+        public int Karma { get; set; }
+        
+        public DateTimeOffset TimeOut { get; set; }
+    }
+}

src/Core/Database/Models/MessagesModel.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class MessagesModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+        
+        public int MessageCount { get; set; }
+    }
+}

src/Core/Database/Models/QuoteModel.cs

@@ -0,0 +1,28 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class QuoteModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public int InternalId { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+        
+        [Required]
+        [DataType(DataType.DateTime)]
+        public DateTime Time { get; set; }
+        
+        public string Quote { get; set; }
+        
+        public string Image { get; set; }
+    }
+}

src/Core/Database/Models/ReactionListenerModel.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class ReactionListenerModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long MessageId { get; set; }
+        
+        [Required]
+        public long RoleId { get; set; }
+
+        [Required]
+        public string Reaction { get; set; }
+    }
+}

src/Core/Database/Models/RoleSelfServiceModel.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class RoleSelfServiceModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        public long RoleId { get; set; }
+        
+        public string WhiteListName { get; set; }
+    }
+}

src/Core/Database/Models/RollsModel.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class RollsModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+        
+        public int Rolls { get; set; }
+    }
+}

src/Core/Database/Models/ShipsModel.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class ShipsModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        public long FirstUserId { get; set; }
+        
+        public long SecondUserId { get; set; }
+        
+        public int Strength { get; set; }
+    }
+}

src/Core/Database/Models/SlapsModel.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class SlapsModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long GuildId { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+        
+        public int Given { get; set; }
+        
+        public int Recieved { get; set; }
+    }
+}

src/Core/Database/Models/UserModel.cs

@@ -0,0 +1,27 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Geekbot.Core.Database.Models
+{
+    public class UserModel
+    {
+        [Key]
+        public int Id { get; set; }
+        
+        [Required]
+        public long UserId { get; set; }
+        
+        [Required]
+        public string Username { get; set; }
+        
+        [Required]
+        public string Discriminator { get; set; }
+        
+        public string AvatarUrl { get; set; }
+        
+        [Required]
+        public bool IsBot { get; set; }
+        
+        public DateTimeOffset Joined { get; set; }
+    }
+}

src/Core/Database/SqlConnectionString.cs

@@ -0,0 +1,39 @@
+using System.Text;
+
+namespace Geekbot.Core.Database
+{
+    public class SqlConnectionString
+    {
+        public string Host { get; set; }
+        public string Port { get; set; }
+        public string Database { get; set; }
+        public string Username { get; set; }
+        public string Password { get; set; }
+        public bool RequireSsl { get; set; }
+        public bool TrustServerCertificate { get; set; }
+        public bool RedshiftCompatibility { get; set; }
+
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+            sb.Append("Application Name=Geekbot;");
+            
+            sb.Append($"Host={Host};");
+            sb.Append($"Port={Port};");
+            sb.Append($"Database={Database};");
+            sb.Append($"Username={Username};");
+            sb.Append($"Password={Password};");
+            
+            var sslMode = RequireSsl ? "Require" : "Prefer";
+            sb.Append($"SSL Mode={sslMode};");
+            sb.Append($"Trust Server Certificate={TrustServerCertificate.ToString()};");
+
+            if (RedshiftCompatibility)
+            {
+                sb.Append("Server Compatibility Mode=Redshift");
+            }
+
+            return sb.ToString();
+        }
+    }
+}

src/Core/Database/SqlDatabase.cs

@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace Geekbot.Core.Database
+{
+    public class SqlDatabase : DatabaseContext
+    {
+        private readonly SqlConnectionString _connectionString;
+
+        public SqlDatabase(SqlConnectionString connectionString)
+        {
+            _connectionString = connectionString;
+        }
+        
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+            => optionsBuilder.UseNpgsql(_connectionString.ToString());
+    }
+}