Redesigned the DiscordBotCore by splitting it into multiple projects. Created a WebUI and preparing to remove the DiscordBot application

DiscordBotCore.Logging/DiscordBotCore.Logging.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+</Project>

DiscordBotCore.Logging/ILogMessage.cs

@@ -0,0 +1,10 @@
+namespace DiscordBotCore.Logging;
+
+public interface ILogMessage
+{
+    public string Message { get; protected set; }
+    public DateTime ThrowTime { get; protected set; }
+    public string SenderName { get; protected set; }
+    public LogType LogMessageType { get; protected set; }
+
+}

DiscordBotCore.Logging/ILogger.cs

@@ -0,0 +1,22 @@
+namespace DiscordBotCore.Logging;
+
+public interface ILogger
+{
+    public struct FormattedMessage { 
+        public string  Message;
+        public LogType Type;
+    }
+
+    string LogMessageFormat { get; set; }
+
+    void Log(string message);
+    void Log(string message, LogType logType);
+    void Log(string message, LogType logType, string format);
+    void Log(string message, object Sender);
+    void Log(string message, object Sender, LogType type);
+    void LogException(Exception exception, object Sender, bool logFullStack = false);
+
+    void SetOutFunction(Action<string,LogType> outFunction);
+
+    string GetLogsHistory();
+}

DiscordBotCore.Logging/LogMessage.cs

@@ -0,0 +1,76 @@
+namespace DiscordBotCore.Logging
+{
+    internal sealed class LogMessage : ILogMessage
+    {
+        private static readonly string _DefaultLogMessageSender = "\b";
+        public string Message { get; set; }
+        public DateTime ThrowTime { get; set; }
+        public string SenderName { get; set; }
+        public LogType LogMessageType { get; set; }
+
+        public LogMessage(string message, LogType logMessageType)
+        {
+            Message = message;
+            LogMessageType = logMessageType;
+            ThrowTime = DateTime.Now;
+            SenderName = string.Empty;
+        }
+
+        public LogMessage(string message, object sender)
+        {
+            Message = message;
+            SenderName = sender is string && sender as string == string.Empty ? _DefaultLogMessageSender : sender.GetType().FullName ?? sender.GetType().Name;
+            ThrowTime = DateTime.Now;
+            LogMessageType = LogType.Info;
+        }
+
+        public LogMessage(string message, object sender, DateTime throwTime)
+        {
+            Message = message;
+            SenderName = sender is string && sender as string == string.Empty ? _DefaultLogMessageSender : sender.GetType().FullName ?? sender.GetType().Name;
+            ThrowTime = throwTime;
+            LogMessageType = LogType.Info;
+        }
+
+        public LogMessage(string message, object sender, LogType logMessageType)
+        {
+            Message = message;
+            SenderName = sender is string && sender as string == string.Empty ? _DefaultLogMessageSender : sender.GetType().FullName ?? sender.GetType().Name;
+            ThrowTime = DateTime.Now;
+            LogMessageType = logMessageType;
+
+        }
+
+        public LogMessage(string message, DateTime throwTime, object sender, LogType logMessageType)
+        {
+            Message = message;
+            ThrowTime = throwTime;
+            SenderName = sender is string && sender as string == string.Empty ? _DefaultLogMessageSender : sender.GetType().FullName ?? sender.GetType().Name;
+            LogMessageType = logMessageType;
+        }
+
+        public LogMessage WithMessage(string message)
+        {
+            this.Message = message;
+            return this;
+        }
+
+        public LogMessage WithCurrentThrowTime()
+        {
+            this.ThrowTime = DateTime.Now;
+            return this;
+        }
+
+        public LogMessage WithMessageType(LogType logType)
+        {
+            this.LogMessageType = logType;
+            return this;
+        }
+
+        public static LogMessage CreateFromException(Exception exception, object Sender, bool logFullStack)
+        {
+            LogMessage message = new LogMessage(logFullStack? exception.ToString() : exception.Message, Sender, LogType.Error);
+            return message;
+        }
+    }
+}

DiscordBotCore.Logging/LogType.cs

@@ -0,0 +1,9 @@
+namespace DiscordBotCore.Logging;
+
+public enum LogType
+{
+    Info,
+    Warning,
+    Error,
+    Critical
+}

DiscordBotCore.Logging/Logger.cs

@@ -0,0 +1,103 @@
+namespace DiscordBotCore.Logging;
+
+public sealed class Logger : ILogger
+{
+    private FileStream _logFileStream;
+
+    private readonly List<string>             _logMessageProperties = typeof(ILogMessage).GetProperties().Select(p => p.Name).ToList();
+    private          Action<string, LogType>? _outFunction;
+    public string LogMessageFormat { get ; set; }
+
+    public Logger(string logFolder, string logMessageFormat, Action<string, LogType>? outFunction = null)
+    {
+        this.LogMessageFormat = logMessageFormat;
+        var logFile = Path.Combine(logFolder, $"{DateTime.Now:yyyy-MM-dd}.log");
+        _logFileStream = File.Open(logFile, FileMode.Append, FileAccess.Write, FileShare.Read);
+        this._outFunction = outFunction ?? DefaultLogFunction;
+    }
+
+    private void DefaultLogFunction(string message, LogType logType)
+    {
+        Console.WriteLine($"[{logType}] {message}");
+    }
+
+    /// <summary>
+    /// Generate a formatted string based on the default parameters of the ILogMessage and a string defined as model
+    /// </summary>
+    /// <param name="message">The message</param>
+    /// <returns>A formatted string with the message values</returns>
+    private string GenerateLogMessage(ILogMessage message)
+    {
+        string messageAsString = new string(LogMessageFormat);
+        foreach (var prop in _logMessageProperties)
+        {
+            Type messageType = typeof(ILogMessage);
+            messageAsString = messageAsString.Replace("{" + prop + "}", messageType.GetProperty(prop)?.GetValue(message)?.ToString());
+        }
+
+        return messageAsString;
+    }
+
+    private async void LogToFile(string message)
+    {
+        byte[] messageAsBytes = System.Text.Encoding.ASCII.GetBytes(message);
+        await _logFileStream.WriteAsync(messageAsBytes, 0, messageAsBytes.Length);
+
+        byte[] newLine = System.Text.Encoding.ASCII.GetBytes(Environment.NewLine);
+        await _logFileStream.WriteAsync(newLine, 0, newLine.Length);
+
+        await _logFileStream.FlushAsync();
+    }
+
+    private string GenerateLogMessage(ILogMessage message, string customFormat)
+    {
+        string messageAsString = customFormat;
+        foreach (var prop in _logMessageProperties)
+        {
+            Type messageType = typeof(ILogMessage);
+            messageAsString = messageAsString.Replace("{" + prop + "}", messageType.GetProperty(prop)?.GetValue(message)?.ToString());
+        }
+
+        return messageAsString;
+    }
+
+    public void Log(ILogMessage message, string format)
+    {
+        string messageAsString = GenerateLogMessage(message, format);
+        _outFunction?.Invoke(messageAsString, message.LogMessageType);
+        LogToFile(messageAsString);
+    }
+
+    public void Log(ILogMessage message)
+    {
+        string messageAsString = GenerateLogMessage(message);
+        _outFunction?.Invoke(messageAsString, message.LogMessageType);
+        LogToFile(messageAsString);
+        
+    }
+
+    public void Log(string message) => Log(new LogMessage(message, string.Empty, LogType.Info));
+    public void Log(string message, LogType logType, string format) => Log(new LogMessage(message, logType), format);
+    public void Log(string message, LogType logType) => Log(new LogMessage(message, logType));
+    public void Log(string message, object sender) => Log(new LogMessage(message, sender));
+    public void Log(string message, object sender, LogType type) => Log(new LogMessage(message, sender, type));
+    public void LogException(Exception exception, object sender, bool logFullStack = false) => Log(LogMessage.CreateFromException(exception, sender, logFullStack));
+
+    public void SetOutFunction(Action<string, LogType> outFunction)
+    {
+        this._outFunction = outFunction;
+    }
+    public string GetLogsHistory()
+    {
+        string fileName = _logFileStream.Name;
+        
+        _logFileStream.Flush();
+        _logFileStream.Close();
+        
+        string[] logs = File.ReadAllLines(fileName);
+        _logFileStream = File.Open(fileName, FileMode.Append, FileAccess.Write, FileShare.Read);
+        
+        return string.Join(Environment.NewLine, logs);
+        
+    }
+}