/// <summary>
/// Import config file that was sent to in API body - this act as import from backup
/// </summary>
/// <returns>APIStatus</returns>
private object ImportConfig()
{
CL_ServerSettings settings = this.Bind();
string raw_settings = settings.ToJSON();
if (raw_settings.Length != new CL_ServerSettings().ToJSON().Length)
{
string path = Path.Combine(ServerSettings.ApplicationPath, "temp.json");
File.WriteAllText(path, raw_settings, Encoding.UTF8);
try
{
ServerSettings.LoadSettingsFromFile(path, true);
return(APIStatus.OK());
}
catch
{
return(APIStatus.InternalError("Error while importing settings"));
}
}
return(APIStatus.BadRequest("Empty settings are not allowed"));
}
public ActionResult TestAniDB()
{
ShokoService.AnidbProcessor.ForceLogout();
ShokoService.AnidbProcessor.CloseConnections();
Thread.Sleep(1000);
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(ServerSettings.Instance.Culture);
ShokoService.AnidbProcessor.Init(ServerSettings.Instance.AniDb.Username, ServerSettings.Instance.AniDb.Password,
ServerSettings.Instance.AniDb.ServerAddress,
ServerSettings.Instance.AniDb.ServerPort, ServerSettings.Instance.AniDb.ClientPort);
if (!ShokoService.AnidbProcessor.Login())
{
return(APIStatus.BadRequest("Failed to log in"));
}
ShokoService.AnidbProcessor.ForceLogout();
return(APIStatus.OK());
}
public ActionResult StartServer()
{
if (ServerState.Instance.ServerOnline)
{
return(APIStatus.BadRequest("Already Running"));
}
if (ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("Already Starting"));
}
try
{
ShokoServer.RunWorkSetupDB();
}
catch (Exception e)
{
logger.Error($"There was an error starting the server: {e}");
return(APIStatus.InternalError($"There was an error starting the server: {e}"));
}
return(APIStatus.OK());
}
/// <summary>
/// Return given setting
/// </summary>
/// <returns></returns>
private object GetSetting()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
try
{
// TODO Refactor Settings to a POCO that is serialized, and at runtime, build a dictionary of types to validate against
Settings setting = this.Bind();
if (string.IsNullOrEmpty(setting?.setting))
{
return(APIStatus.BadRequest("An invalid setting was passed"));
}
try
{
var value = typeof(ServerSettings).GetProperty(setting.setting)?.GetValue(null, null);
if (value == null)
{
return(APIStatus.BadRequest("An invalid setting was passed"));
}
Settings return_setting = new Settings
{
setting = setting.setting,
value = value.ToString()
};
return(return_setting);
}
catch
{
return(APIStatus.BadRequest("An invalid setting was passed"));
}
}
catch
{
return(APIStatus.InternalError());
}
}
/// <summary>
/// Set AniDB account credentials with a Credentials object
/// </summary>
/// <returns></returns>
private object SetAniDB()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
Credentials cred = this.Bind();
var details = new List <(string, string)>();
if (string.IsNullOrEmpty(cred.login))
{
details.Add(("login", "Username missing"));
}
if (string.IsNullOrEmpty(cred.password))
{
details.Add(("password", "Password missing"));
}
if (details.Count > 0)
{
return(new APIMessage(400, "Login or Password missing", details));
}
ServerSettings.AniDB_Username = cred.login;
ServerSettings.AniDB_Password = cred.password;
if (cred.port != 0)
{
ServerSettings.AniDB_ClientPort = cred.port.ToString();
}
if (!string.IsNullOrEmpty(cred.apikey))
{
ServerSettings.AniDB_AVDumpKey = cred.apikey;
}
if (cred.apiport != 0)
{
ServerSettings.AniDB_AVDumpClientPort = cred.apiport.ToString();
}
return(APIStatus.OK());
}
public ActionResult TestDatabaseConnection()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
return(APIStatus.NotImplemented()); //TODO: Needs to be redone for EFCore.
/*if (ServerSettings.Instance.Database.Type.Equals(Constants.DatabaseType.MySQL,
* StringComparison.InvariantCultureIgnoreCase) && new MySQL().TestConnection())
* return APIStatus.OK();
*
* if (ServerSettings.Instance.Database.Type.Equals(Constants.DatabaseType.SqlServer,
* StringComparison.InvariantCultureIgnoreCase) && new SQLServer().TestConnection())
* return APIStatus.OK();
*
* if (ServerSettings.Instance.Database.Type.Equals(Constants.DatabaseType.Sqlite,
* StringComparison.InvariantCultureIgnoreCase))
* return APIStatus.OK();*/
//return APIStatus.BadRequest("Failed to Connect");
}
public ActionResult <Credentials> GetAniDB()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
try
{
return(new Credentials
{
login = ServerSettings.Instance.AniDb.Username,
port = ServerSettings.Instance.AniDb.ClientPort,
apiport = ServerSettings.Instance.AniDb.AVDumpClientPort
});
}
catch
{
return(APIStatus.InternalError(
"The ports are not set as integers. Set them and try again.\n\rThe default values are:\n\rAniDB Client Port: 4556\n\rAniDB AVDump Client Port: 4557"));
}
}
public ActionResult <DatabaseSettings> GetDatabaseSettings()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
var settings = new DatabaseSettings
{
db_type = ServerSettings.Instance.Database.Type,
mysql_hostname = ServerSettings.Instance.Database.Hostname,
mysql_password = ServerSettings.Instance.Database.Password,
mysql_schemaname = ServerSettings.Instance.Database.Schema,
mysql_username = ServerSettings.Instance.Database.Username,
sqlite_databasefile = ServerSettings.Instance.Database.SQLite_DatabaseFile,
sqlserver_databasename = ServerSettings.Instance.Database.Schema,
sqlserver_databaseserver = ServerSettings.Instance.Database.Hostname,
sqlserver_password = ServerSettings.Instance.Database.Password,
sqlserver_username = ServerSettings.Instance.Database.Username
};
return(settings);
}
public ActionResult ImportConfig(CL_ServerSettings settings)
{
string raw_settings = settings.ToJSON();
if (raw_settings.Length == new CL_ServerSettings().ToJSON().Length)
{
return(APIStatus.BadRequest("Empty settings are not allowed"));
}
string path = Path.Combine(ServerSettings.ApplicationPath, "temp.json");
System.IO.File.WriteAllText(path, raw_settings, Encoding.UTF8);
try
{
ServerSettings.LoadSettingsFromFile(path, true);
ServerSettings.Instance.SaveSettings();
return(APIStatus.OK());
}
catch
{
return(APIStatus.InternalError("Error while importing settings"));
}
}
/// <summary>
/// Get Database Settings
/// </summary>
/// <returns></returns>
private object GetDatabaseSettings()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
var settings = new DatabaseSettings
{
db_type = ServerSettings.DatabaseType,
mysql_hostname = ServerSettings.MySQL_Hostname,
mysql_password = ServerSettings.MySQL_Password,
mysql_schemaname = ServerSettings.MySQL_SchemaName,
mysql_username = ServerSettings.MySQL_Username,
sqlite_databasefile = ServerSettings.DatabaseFile,
sqlserver_databasename = ServerSettings.DatabaseName,
sqlserver_databaseserver = ServerSettings.DatabaseServer,
sqlserver_password = ServerSettings.DatabasePassword,
sqlserver_username = ServerSettings.DatabaseUsername
};
return(settings);
}
/// <summary>
/// Return existing login and ports for AniDB
/// </summary>
/// <returns></returns>
private object GetAniDB()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
try
{
Credentials cred = new Credentials
{
login = ServerSettings.AniDB_Username,
port = int.Parse(ServerSettings.AniDB_ClientPort),
apiport = int.Parse(ServerSettings.AniDB_AVDumpClientPort)
};
return(cred);
}
catch
{
return(APIStatus.InternalError(
"The ports are not set as integers. Set them and try again.\n\rThe default values are:\n\rAniDB Client Port: 4556\n\rAniDB AVDump Client Port: 4557"));
}
}
public ActionResult SetDatabaseSettings(DatabaseSettings settings)
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
DatabaseTypes?dbtype = settings?.db_type;
if (dbtype == null)
{
return(APIStatus.BadRequest("You must specify database type and use valid xml or json."));
}
if (dbtype == DatabaseTypes.MySql)
{
var details = new List <(string, string)>();
if (string.IsNullOrEmpty(settings.mysql_hostname))
{
details.Add(("mysql_hostname", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.mysql_schemaname))
{
details.Add(("mysql_schemaname", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.mysql_username))
{
details.Add(("mysql_username", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.mysql_password))
{
details.Add(("mysql_password", "Must not be empty"));
}
if (details.Count > 0)
{
return(new APIMessage(HttpStatusCode.BadRequest, "An invalid setting was passed", details));
}
ServerSettings.Instance.Database.Type = DatabaseTypes.MySql;
ServerSettings.Instance.Database.Hostname = settings.mysql_hostname;
ServerSettings.Instance.Database.Password = settings.mysql_password;
ServerSettings.Instance.Database.Schema = settings.mysql_schemaname;
ServerSettings.Instance.Database.Username = settings.mysql_username;
return(APIStatus.OK());
}
if (dbtype == DatabaseTypes.SqlServer)
{
var details = new List <(string, string)>();
if (string.IsNullOrEmpty(settings.sqlserver_databaseserver))
{
details.Add(("sqlserver_databaseserver", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.sqlserver_databasename))
{
details.Add(("sqlserver_databaseserver", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.sqlserver_username))
{
details.Add(("sqlserver_username", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.sqlserver_password))
{
details.Add(("sqlserver_password", "Must not be empty"));
}
if (details.Count > 0)
{
return(new APIMessage(HttpStatusCode.BadRequest, "An invalid setting was passed", details));
}
ServerSettings.Instance.Database.Type = DatabaseTypes.SqlServer;
ServerSettings.Instance.Database.Hostname = settings.sqlserver_databaseserver;
ServerSettings.Instance.Database.Schema = settings.sqlserver_databasename;
ServerSettings.Instance.Database.Username = settings.sqlserver_username;
ServerSettings.Instance.Database.Password = settings.sqlserver_password;
return(APIStatus.OK());
}
if (dbtype == DatabaseTypes.Sqlite)
{
ServerSettings.Instance.Database.Type = DatabaseTypes.Sqlite;
if (!string.IsNullOrEmpty(settings.sqlite_databasefile))
{
ServerSettings.Instance.Database.SQLite_DatabaseFile = settings.sqlite_databasefile;
}
return(APIStatus.OK());
}
return(APIStatus.BadRequest("An invalid setting was passed"));
}
public ActionResult <List <APIMessage> > SetSetting(List <Setting> settings)
{
// TODO Refactor Settings to a POCO that is serialized, and at runtime, build a dictionary of types to validate against
try
{
List <APIMessage> errors = new List <APIMessage>();
for (var index = 0; index < settings.Count; index++)
{
var setting = settings[index];
if (string.IsNullOrEmpty(setting.setting))
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid setting was passed"));
continue;
}
if (setting.value == null)
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid value was passed"));
continue;
}
var property = typeof(ServerSettings).GetProperty(setting.setting);
if (property == null)
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid setting was passed"));
continue;
}
if (!property.CanWrite)
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid setting was passed"));
continue;
}
var settingType = property.PropertyType;
try
{
var converter = TypeDescriptor.GetConverter(settingType);
if (!converter.CanConvertFrom(typeof(string)))
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid value was passed"));
continue;
}
var value = converter.ConvertFromInvariantString(setting.value);
if (value == null)
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid value was passed"));
continue;
}
property.SetValue(null, value);
}
catch
{
errors.Add(APIStatus.BadRequest($"{index}: An invalid value was passed"));
}
}
if (errors.Count > 0)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(errors);
}
return(APIStatus.OK());
}
catch
{
return(APIStatus.InternalError());
}
}
public ActionResult <APIMessage> TestDatabaseConnection()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
return(new Repositories.Repo().GetProvider().GetContext() != null?APIStatus.OK() : APIStatus.BadRequest("Failed to connect"));
//return APIStatus.BadRequest("Failed to Connect");
}
/// <summary>
/// Set Database Settings
/// </summary>
/// <returns></returns>
private object SetDatabaseSettings()
{
if (ServerState.Instance.ServerOnline || ServerState.Instance.ServerStarting)
{
return(APIStatus.BadRequest("You may only do this before server init"));
}
DatabaseSettings settings = this.Bind();
string dbtype = settings?.db_type?.Trim();
if (string.IsNullOrEmpty(dbtype))
{
return(APIStatus.BadRequest("You must specify database type and use valid xml or json."));
}
if (dbtype.Equals(Constants.DatabaseType.MySQL, StringComparison.InvariantCultureIgnoreCase))
{
var details = new List <(string, string)>();
if (string.IsNullOrEmpty(settings.mysql_hostname))
{
details.Add(("mysql_hostname", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.mysql_schemaname))
{
details.Add(("mysql_schemaname", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.mysql_username))
{
details.Add(("mysql_username", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.mysql_password))
{
details.Add(("mysql_password", "Must not be empty"));
}
if (details.Count > 0)
{
return(new APIMessage(HttpStatusCode.BadRequest, "An invalid setting was passed", details));
}
ServerSettings.DatabaseType = Constants.DatabaseType.MySQL;
ServerSettings.MySQL_Hostname = settings.mysql_hostname;
ServerSettings.MySQL_Password = settings.mysql_password;
ServerSettings.MySQL_SchemaName = settings.mysql_schemaname;
ServerSettings.MySQL_Username = settings.mysql_username;
return(APIStatus.OK());
}
if (dbtype.Equals(Constants.DatabaseType.SqlServer, StringComparison.InvariantCultureIgnoreCase))
{
var details = new List <(string, string)>();
if (string.IsNullOrEmpty(settings.sqlserver_databaseserver))
{
details.Add(("sqlserver_databaseserver", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.sqlserver_databasename))
{
details.Add(("sqlserver_databaseserver", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.sqlserver_username))
{
details.Add(("sqlserver_username", "Must not be empty"));
}
if (string.IsNullOrEmpty(settings.sqlserver_password))
{
details.Add(("sqlserver_password", "Must not be empty"));
}
if (details.Count > 0)
{
return(new APIMessage(HttpStatusCode.BadRequest, "An invalid setting was passed", details));
}
ServerSettings.DatabaseType = Constants.DatabaseType.SqlServer;
ServerSettings.DatabaseServer = settings.sqlserver_databaseserver;
ServerSettings.DatabaseName = settings.sqlserver_databasename;
ServerSettings.DatabaseUsername = settings.sqlserver_username;
ServerSettings.DatabasePassword = settings.sqlserver_password;
return(APIStatus.OK());
}
if (dbtype.Equals(Constants.DatabaseType.Sqlite, StringComparison.InvariantCultureIgnoreCase))
{
ServerSettings.DatabaseType = Constants.DatabaseType.Sqlite;
if (!string.IsNullOrEmpty(settings.sqlite_databasefile))
{
ServerSettings.DatabaseFile = settings.sqlite_databasefile;
}
return(APIStatus.OK());
}
return(APIStatus.BadRequest("An invalid setting was passed"));
}
