574 lines
19 KiB
C#
574 lines
19 KiB
C#
using Asp.Versioning;
|
|
using Cronos;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Data.Sqlite;
|
|
using Microsoft.Extensions.Caching.Memory;
|
|
using Microsoft.Extensions.Options;
|
|
using Mirea.Api.Dto.Common;
|
|
using Mirea.Api.Dto.Requests;
|
|
using Mirea.Api.Dto.Requests.Configuration;
|
|
using Mirea.Api.Dto.Responses;
|
|
using Mirea.Api.Dto.Responses.Configuration;
|
|
using Mirea.Api.Endpoint.Common.Attributes;
|
|
using Mirea.Api.Endpoint.Common.Exceptions;
|
|
using Mirea.Api.Endpoint.Common.Interfaces;
|
|
using Mirea.Api.Endpoint.Common.MapperDto;
|
|
using Mirea.Api.Endpoint.Common.Services;
|
|
using Mirea.Api.Endpoint.Configuration.Model;
|
|
using Mirea.Api.Endpoint.Configuration.Model.GeneralSettings;
|
|
using Mirea.Api.Endpoint.Configuration.Validation.Validators;
|
|
using Mirea.Api.Security.Common.Domain;
|
|
using Mirea.Api.Security.Services;
|
|
using MySqlConnector;
|
|
using Npgsql;
|
|
using Serilog;
|
|
using StackExchange.Redis;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Mail;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security;
|
|
using System.Security.Cryptography;
|
|
using PasswordPolicy = Mirea.Api.Dto.Common.PasswordPolicy;
|
|
|
|
namespace Mirea.Api.Endpoint.Controllers.Configuration;
|
|
|
|
[ApiVersion("1.0")]
|
|
[MaintenanceModeIgnore]
|
|
[ApiExplorerSettings(IgnoreApi = true)]
|
|
public class SetupController(
|
|
ISetupToken setupToken,
|
|
IMaintenanceModeNotConfigureService notConfigureService,
|
|
IMemoryCache cache,
|
|
PasswordHashService passwordHashService,
|
|
IOptionsSnapshot<Admin> user) : BaseController
|
|
{
|
|
private const string CacheGeneralKey = "config_general";
|
|
private const string CacheAdminKey = "config_admin";
|
|
|
|
private GeneralConfig GeneralConfig
|
|
{
|
|
get => cache.Get<GeneralConfig>(CacheGeneralKey) ?? new GeneralConfig();
|
|
set => cache.Set(CacheGeneralKey, value);
|
|
}
|
|
|
|
[HttpGet("GenerateToken")]
|
|
[Localhost]
|
|
public ActionResult<string> GenerateToken()
|
|
{
|
|
if (!notConfigureService.IsMaintenanceMode)
|
|
throw new ControllerArgumentException(
|
|
"The token cannot be generated because the server has been configured. " +
|
|
$"If you need to restart the configuration, then delete the \"{GeneralConfig.FilePath}\" file and restart the application.");
|
|
|
|
var token = new byte[32];
|
|
RandomNumberGenerator.Create().GetBytes(token);
|
|
setupToken.SetToken(token);
|
|
|
|
return Ok(Convert.ToBase64String(token));
|
|
}
|
|
|
|
[HttpGet("IsConfigured")]
|
|
public ActionResult<bool> IsConfigured() =>
|
|
!notConfigureService.IsMaintenanceMode;
|
|
|
|
[HttpGet("CheckToken")]
|
|
public ActionResult<bool> CheckToken([FromQuery] string token)
|
|
{
|
|
byte[] tokenBase64;
|
|
try
|
|
{
|
|
tokenBase64 = Convert.FromBase64String(token);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
throw new ControllerArgumentException("A token of the wrong format.");
|
|
}
|
|
|
|
if (!setupToken.MatchToken(tokenBase64))
|
|
throw new SecurityException("The token is not valid");
|
|
|
|
Response.Cookies.Append(TokenAuthenticationAttribute.AuthToken, token, new CookieOptions
|
|
{
|
|
Path = UrlHelper.GetSubPathWithoutFirstApiName + "api",
|
|
Domain = HttpContext.GetCurrentDomain(),
|
|
HttpOnly = true,
|
|
#if !DEBUG
|
|
Secure = true
|
|
#endif
|
|
});
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpGet("IsConfiguredToken")]
|
|
[TokenAuthentication]
|
|
public ActionResult<bool> IsConfiguredToken() =>
|
|
Ok(true);
|
|
|
|
private void SetDatabase<TConnection, TException>(string connectionString, DatabaseType databaseType)
|
|
where TConnection : class, IDbConnection, new()
|
|
where TException : Exception
|
|
{
|
|
try
|
|
{
|
|
using (var connection = new TConnection())
|
|
{
|
|
connection.ConnectionString = connectionString;
|
|
connection.Open();
|
|
connection.Close();
|
|
|
|
if (connection is SqliteConnection)
|
|
SqliteConnection.ClearAllPools();
|
|
}
|
|
|
|
var general = GeneralConfig;
|
|
general.DbSettings = new DbSettings
|
|
{
|
|
ConnectionStringSql = connectionString,
|
|
TypeDatabase = databaseType
|
|
};
|
|
GeneralConfig = general;
|
|
}
|
|
catch (TException ex)
|
|
{
|
|
throw new ControllerArgumentException($"Error when connecting: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
[HttpPost("SetPsql")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetPsql([FromBody] DatabaseRequest request)
|
|
{
|
|
string connectionString = $"Host={request.Server}:{request.Port};Username={request.User};Database={request.Database}";
|
|
if (request.Password != null)
|
|
connectionString += $";Password={request.Password}";
|
|
if (request.Ssl)
|
|
connectionString += ";SSL Mode=Require;";
|
|
|
|
|
|
SetDatabase<NpgsqlConnection, NpgsqlException>(connectionString, DatabaseType.PostgresSql);
|
|
cache.Set("database", new DatabaseResponse
|
|
{
|
|
Type = DatabaseType.PostgresSql,
|
|
Database = request.Database,
|
|
Password = request.Password,
|
|
Ssl = request.Ssl,
|
|
Port = request.Port,
|
|
Server = request.Server,
|
|
User = request.User
|
|
});
|
|
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpPost("SetMysql")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetMysql([FromBody] DatabaseRequest request)
|
|
{
|
|
string connectionString = $"Server={request.Server}:{request.Port};Uid={request.User};Database={request.Database};";
|
|
if (request.Password != null)
|
|
connectionString += $"Pwd={request.Password};";
|
|
if (request.Ssl)
|
|
connectionString += "SslMode=Require;";
|
|
|
|
SetDatabase<MySqlConnection, MySqlException>(connectionString, DatabaseType.Mysql);
|
|
cache.Set("database", new DatabaseResponse
|
|
{
|
|
Type = DatabaseType.Mysql,
|
|
Database = request.Database,
|
|
Password = request.Password,
|
|
Ssl = request.Ssl,
|
|
Port = request.Port,
|
|
Server = request.Server,
|
|
User = request.User
|
|
});
|
|
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpPost("SetSqlite")]
|
|
[TokenAuthentication]
|
|
public ActionResult<bool> SetSqlite([FromQuery] string? path)
|
|
{
|
|
if (string.IsNullOrEmpty(path)) path = "database";
|
|
|
|
path = PathBuilder.Combine(path);
|
|
|
|
if (!Directory.Exists(path))
|
|
{
|
|
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
|
|
Directory.CreateDirectory(path);
|
|
else
|
|
Directory.CreateDirectory(path, UnixFileMode.UserRead | UnixFileMode.UserWrite);
|
|
}
|
|
else if (Directory.GetDirectories(path).Length != 0 ||
|
|
!Directory.GetFiles(path).Select(x => string.Equals(Path.GetFileName(x), "database.db3")).All(x => x))
|
|
{
|
|
throw new ControllerArgumentException("Such a folder exists. Enter a different name");
|
|
}
|
|
|
|
var filePath = Path.Combine(path, "database.db3");
|
|
var connectionString = $"Data Source={filePath}";
|
|
|
|
SetDatabase<SqliteConnection, SqliteException>(connectionString, DatabaseType.Sqlite);
|
|
|
|
foreach (var file in Directory.GetFiles(path))
|
|
System.IO.File.Delete(file);
|
|
|
|
cache.Set("database", new DatabaseResponse
|
|
{
|
|
Type = DatabaseType.Sqlite,
|
|
PathToDatabase = path
|
|
});
|
|
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpGet("DatabaseConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<DatabaseRequest> DatabaseConfiguration() =>
|
|
cache.TryGetValue<DatabaseResponse>("database", out var response) ? Ok(response) : NoContent();
|
|
|
|
[HttpPost("SetRedis")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetRedis([FromBody] CacheRequest request)
|
|
{
|
|
string connectionString = $"{request.Server}:{request.Port},ssl=false";
|
|
if (request.Password != null)
|
|
connectionString += $",password={request.Password}";
|
|
|
|
try
|
|
{
|
|
var redis = ConnectionMultiplexer.Connect(connectionString);
|
|
redis.Close();
|
|
|
|
var general = GeneralConfig;
|
|
general.CacheSettings = new CacheSettings
|
|
{
|
|
ConnectionString = connectionString,
|
|
TypeDatabase = CacheType.Redis
|
|
};
|
|
GeneralConfig = general;
|
|
|
|
cache.Set("cache", new CacheResponse
|
|
{
|
|
Type = CacheType.Redis,
|
|
Server = request.Server,
|
|
Password = request.Password,
|
|
Port = request.Port
|
|
});
|
|
return Ok(true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new ControllerArgumentException("Error when connecting to Redis: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPost("SetMemcached")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetMemcached()
|
|
{
|
|
var general = GeneralConfig;
|
|
general.CacheSettings = new CacheSettings
|
|
{
|
|
ConnectionString = null,
|
|
TypeDatabase = CacheType.Memcached
|
|
};
|
|
GeneralConfig = general;
|
|
|
|
cache.Set("cache", new CacheResponse
|
|
{
|
|
Type = CacheType.Memcached
|
|
});
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpGet("CacheConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<CacheResponse> CacheConfiguration() =>
|
|
cache.TryGetValue<CacheResponse>("cache", out var response) ? Ok(response) : NoContent();
|
|
|
|
[HttpPost("CreateAdmin")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<string> CreateAdmin([FromBody] CreateUserRequest user)
|
|
{
|
|
new PasswordPolicyService(GeneralConfig.PasswordPolicy).ValidatePasswordOrThrow(user.Password);
|
|
|
|
if (!MailAddress.TryCreate(user.Email, out _))
|
|
throw new ControllerArgumentException("The email address is incorrect.");
|
|
|
|
var (salt, hash) = passwordHashService.HashPassword(user.Password);
|
|
|
|
var admin = new Admin
|
|
{
|
|
Username = user.Username,
|
|
Email = user.Email,
|
|
PasswordHash = hash,
|
|
Salt = salt
|
|
};
|
|
|
|
cache.Set(CacheAdminKey, admin);
|
|
return Ok(true);
|
|
}
|
|
|
|
[HttpGet("UpdateAdminConfiguration")]
|
|
[TokenAuthentication]
|
|
public ActionResult UpdateAdminConfiguration()
|
|
{
|
|
if (string.IsNullOrEmpty(user.Value.Email))
|
|
return Ok();
|
|
|
|
if (!cache.TryGetValue<Admin>(CacheAdminKey, out var admin))
|
|
{
|
|
admin = user.Value;
|
|
cache.Set(CacheAdminKey, admin);
|
|
return Ok();
|
|
}
|
|
|
|
admin!.OAuthProviders = user.Value.OAuthProviders;
|
|
|
|
if (string.IsNullOrEmpty(admin.Email))
|
|
admin.Email = user.Value.Email;
|
|
|
|
if (string.IsNullOrEmpty(admin.Username))
|
|
admin.Username = user.Value.Username;
|
|
|
|
cache.Set(CacheAdminKey, admin);
|
|
return Ok();
|
|
}
|
|
|
|
[HttpGet("AdminConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<UserResponse> AdminConfiguration() =>
|
|
cache.TryGetValue<Admin>(CacheAdminKey, out var admin) ? Ok(new UserResponse()
|
|
{
|
|
Email = admin!.Email,
|
|
Username = admin.Username,
|
|
TwoFactorAuthenticatorEnabled = admin.TwoFactorAuthenticator != TwoFactorAuthenticator.None,
|
|
UsedOAuthProviders = admin.OAuthProviders == null ? [] : admin.OAuthProviders.Keys.Select(x => x.ConvertToDto())
|
|
}) : NoContent();
|
|
|
|
[HttpGet("GenerateTotpKey")]
|
|
[TokenAuthentication]
|
|
public ActionResult<string> GenerateTotpKey()
|
|
{
|
|
if (cache.TryGetValue<string>("totpSecret", out var secret))
|
|
return secret!;
|
|
|
|
secret = GeneratorKey.GenerateAlphaNumericBase32Compatible(16);
|
|
cache.Set("totpSecret", secret);
|
|
return secret;
|
|
}
|
|
|
|
[HttpGet("VerifyTotp")]
|
|
[TokenAuthentication]
|
|
public ActionResult<bool> VerifyTotp([FromQuery] string code)
|
|
{
|
|
var isCorrect = cache.TryGetValue<string>("totpSecret", out var secret) &&
|
|
new TotpService(secret!).VerifyToken(code);
|
|
|
|
if (!isCorrect || !cache.TryGetValue<Admin>(CacheAdminKey, out var admin))
|
|
return false;
|
|
|
|
admin!.Secret = secret;
|
|
admin.TwoFactorAuthenticator = TwoFactorAuthenticator.Totp;
|
|
cache.Set(CacheAdminKey, admin);
|
|
|
|
return true;
|
|
}
|
|
|
|
[HttpPost("SetLogging")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetLogging([FromBody] LoggingRequest? request = null)
|
|
{
|
|
var settings = (request == null) switch
|
|
{
|
|
true => new LogSettings
|
|
{
|
|
EnableLogToFile = true
|
|
},
|
|
false => new LogSettings
|
|
{
|
|
EnableLogToFile = request.EnableLogToFile,
|
|
LogFileName = request.LogFileName,
|
|
LogFilePath = request.LogFilePath
|
|
}
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(request?.ApiServerSeq))
|
|
{
|
|
settings.ApiServerSeq = request.ApiServerSeq;
|
|
settings.ApiKeySeq = request.ApiKeySeq;
|
|
|
|
try
|
|
{
|
|
Log.Logger = new LoggerConfiguration()
|
|
.WriteTo.Seq(settings.ApiServerSeq, apiKey: settings.ApiKeySeq)
|
|
.CreateLogger();
|
|
|
|
Log.Warning("Testing configuration Seq.");
|
|
}
|
|
catch
|
|
{
|
|
// ignoring
|
|
}
|
|
finally
|
|
{
|
|
Log.CloseAndFlush();
|
|
}
|
|
}
|
|
|
|
if (settings.EnableLogToFile)
|
|
{
|
|
if (string.IsNullOrEmpty(settings.LogFileName))
|
|
settings.LogFileName = "log-";
|
|
|
|
if (string.IsNullOrEmpty(settings.LogFilePath))
|
|
settings.LogFilePath = OperatingSystem.IsWindows() || PathBuilder.IsDefaultPath ?
|
|
PathBuilder.Combine("logs") :
|
|
"/var/log/mirea";
|
|
}
|
|
|
|
var general = GeneralConfig;
|
|
general.LogSettings = settings;
|
|
GeneralConfig = general;
|
|
|
|
cache.Set("logging", new LoggingRequest
|
|
{
|
|
EnableLogToFile = settings.EnableLogToFile,
|
|
LogFileName = settings.LogFileName,
|
|
LogFilePath = settings.LogFilePath,
|
|
ApiKeySeq = settings.ApiKeySeq,
|
|
ApiServerSeq = settings.ApiServerSeq
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
[HttpGet("LoggingConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<LoggingRequest> LoggingConfiguration() =>
|
|
cache.TryGetValue<LoggingRequest>("logging", out var data) ? Ok(data) : NoContent();
|
|
|
|
[HttpPost("SetEmail")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetEmail([FromBody] EmailRequest? request = null)
|
|
{
|
|
var settings = (request == null) switch
|
|
{
|
|
true => new EmailSettings(),
|
|
false => new EmailSettings
|
|
{
|
|
Server = request.Server,
|
|
From = request.From,
|
|
Password = request.Password,
|
|
Port = request.Port,
|
|
Ssl = request.Ssl,
|
|
User = request.User
|
|
}
|
|
};
|
|
|
|
var general = GeneralConfig;
|
|
general.EmailSettings = settings;
|
|
GeneralConfig = general;
|
|
|
|
cache.Set("email", settings);
|
|
return true;
|
|
}
|
|
|
|
[HttpGet("EmailConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<EmailRequest> EmailConfiguration() =>
|
|
cache.TryGetValue<EmailRequest>("email", out var data) ? Ok(data) : NoContent();
|
|
|
|
[HttpPost("SetSchedule")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> SetSchedule([FromBody] ScheduleConfigurationRequest request)
|
|
{
|
|
var general = GeneralConfig;
|
|
general.ScheduleSettings = new ScheduleSettings
|
|
{
|
|
// every 6 hours
|
|
CronUpdateSchedule = request.CronUpdateSchedule ?? "0 */6 * * *",
|
|
StartTerm = request.StartTerm,
|
|
PairPeriod = new Dictionary<int, ScheduleSettings.PairPeriodTime>
|
|
{
|
|
{1, new ScheduleSettings.PairPeriodTime(new TimeOnly(9, 0, 0), new TimeOnly(10, 30, 0))},
|
|
{2, new ScheduleSettings.PairPeriodTime(new TimeOnly(10, 40, 0), new TimeOnly(12, 10, 0))},
|
|
{3, new ScheduleSettings.PairPeriodTime(new TimeOnly(12, 40, 0), new TimeOnly(14, 10, 0))},
|
|
{4, new ScheduleSettings.PairPeriodTime(new TimeOnly(14, 20, 0), new TimeOnly(15, 50, 0))},
|
|
{5, new ScheduleSettings.PairPeriodTime(new TimeOnly(16, 20, 0), new TimeOnly(17, 50, 0))},
|
|
{6, new ScheduleSettings.PairPeriodTime(new TimeOnly(18, 0, 0), new TimeOnly(19, 30, 0))},
|
|
{7, new ScheduleSettings.PairPeriodTime(new TimeOnly(19, 40, 0), new TimeOnly(21, 10, 0))},
|
|
}
|
|
};
|
|
|
|
if (!CronExpression.TryParse(general.ScheduleSettings.CronUpdateSchedule, CronFormat.Standard, out _))
|
|
throw new ControllerArgumentException("The Cron task could not be parsed. Check the format of the entered data.");
|
|
|
|
GeneralConfig = general;
|
|
|
|
cache.Set("schedule", new ScheduleConfigurationRequest()
|
|
{
|
|
StartTerm = general.ScheduleSettings.StartTerm,
|
|
CronUpdateSchedule = general.ScheduleSettings.CronUpdateSchedule
|
|
});
|
|
return true;
|
|
}
|
|
|
|
[HttpGet("ScheduleConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<ScheduleConfigurationRequest> ScheduleConfiguration() =>
|
|
cache.TryGetValue<ScheduleConfigurationRequest>("schedule", out var data) ? Ok(data) : NoContent();
|
|
|
|
[HttpPost("SetPasswordPolicy")]
|
|
[TokenAuthentication]
|
|
public ActionResult<bool> SetPasswordPolicy([FromBody] PasswordPolicy? policy = null)
|
|
{
|
|
GeneralConfig.PasswordPolicy = policy?.ConvertFromDto() ?? new Security.Common.Domain.PasswordPolicy();
|
|
cache.Set("password", true);
|
|
return true;
|
|
}
|
|
|
|
[HttpGet("PasswordPolicyConfiguration")]
|
|
[TokenAuthentication]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
public ActionResult<PasswordPolicy> PasswordPolicyConfiguration() =>
|
|
cache.TryGetValue("password", out _) ? Ok(GeneralConfig.PasswordPolicy) : NoContent();
|
|
|
|
[HttpPost("Submit")]
|
|
[TokenAuthentication]
|
|
[BadRequestResponse]
|
|
public ActionResult<bool> Submit()
|
|
{
|
|
if (!new SettingsRequiredValidator(GeneralConfig).AreSettingsValid())
|
|
throw new ControllerArgumentException("The necessary data has not been configured.");
|
|
|
|
if (!cache.TryGetValue(CacheAdminKey, out Admin? admin) || admin == null)
|
|
throw new ControllerArgumentException("The administrator's data was not set.");
|
|
|
|
admin.SaveSetting();
|
|
GeneralConfig.SaveSetting();
|
|
|
|
return true;
|
|
}
|
|
} |