/// <summary>
/// Finds a list of users matching a prefix
/// </summary>
/// <returns>The users by prefix.</returns>
/// <param name="search">Search.</param>
public static string[] FindPlayersByPrefix(string search, bool includeOp = false)
{
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.Query <DbPlayer>($"select * from {TableMapper.TypeToName<DbPlayer>()} where {ColumnMapper.Enclose("Name")} like @Name", new { Name = '%' + search + '%' }, transaction: txn)
.Select(x => includeOp && x.Operator ? x.Name + " [Op]" : x.Name)
.ToArray());
}
#else
using (var ctx = new TContext())
{
#if ENTITY_FRAMEWORK_6
if (OTA.Data.EF6.OTAContext.IsSQLite)
{
var lowered = search.ToLower();
return(ctx.Players
.Where(x => x.Name.Length >= search.Length && x.Name.Substring(0, search.Length).ToLower() == lowered)
.Select(x => x.Name)
.ToArray());
}
else
{
#endif
return(ctx.Players
.Where(x => x.Name.StartsWith(search))
.Select(x => x.Name)
.ToArray());
#if ENTITY_FRAMEWORK_6
}
#endif
#endif
}
void OnPlayerDisconnected(ref HookContext ctx, ref HookArgs.PlayerLeftGame args)
{
if (Terraria.Main.ServerSideCharacter)
{
#if ENTITY_FRAMEWORK_7
using (var dbCtx = new TContext())
#elif DAPPER
using (var dbCtx = DatabaseFactory.CreateConnection())
#endif
{
using (var txn = dbCtx.BeginTransaction())
{
CharacterManager.SavePlayerData(dbCtx, txn, true, ctx.Player);
txn.Commit();
}
}
}
if (ctx.Player != null)
{
if (CommandDictionary.ContainsKey(ctx.Player.name))
{
CommandDictionary.Remove(ctx.Player.name);
}
//ProgramLog.Log("{0}", ctx.Player.name); //, args.Prefix + " " + args.ArgumentString);
}
#if TDSMServer
if (RestartWhenNoPlayers && ClientConnection.All.Count - 1 == 0)
{
PerformRestart();
}
#endif
}
/// <summary>
/// Updates a player in the database.
/// </summary>
/// <returns><c>true</c>, if user was updated, <c>false</c> otherwise.</returns>
/// <param name="name">The players name.</param>
/// <param name="password">Password.</param>
/// <param name="op">If set to <c>true</c> op.</param>
public static bool UpdatePlayer(string name, string password, bool?op = null)
{
if (name == null && op == null)
{
throw new InvalidOperationException("You have not specified anything to be updated");
}
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
var player = ctx.SingleOrDefault <DbPlayer>(new { Name = name }, transaction: txn);
if (player == null)
{
throw new InvalidOperationException("Cannot update a non-existent player");
}
if (password != null)
{
player.SetRawPassword(password);
}
if (op.HasValue)
{
player.Operator = op.Value;
}
ctx.Update(player, transaction: txn);
txn.Commit();
return(true);
}
}
#else
using (var ctx = new TContext())
{
var player = ctx.Players.SingleOrDefault(p => p.Name == name);
if (player == null)
{
throw new InvalidOperationException("Cannot update a non-existent player");
}
if (password != null)
{
player.SetRawPassword(password);
}
if (op.HasValue)
{
player.Operator = op.Value;
}
ctx.SaveChanges();
return(true);
}
#endif
}
public DbConnection InitConnection(DbProperties dbProperties)
{
Connection = DatabaseFactory.CreateConnection(dbProperties);
if (TestConnection() && dbProperties.DatabaseName != null)
{
return(Connection);
}
return(null);
}
/// <summary>
/// Finds a list of accounts matching a prefix
/// </summary>
/// <returns>The account username prefix.</returns>
/// <param name="search">Search prefix.</param>
public static string[] FindAccountsByPrefix(string search)
{
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.Query <APIAccount>($"select * from {TableMapper.TypeToName<APIAccount>()} where {ColumnMapper.Enclose("Username")} like @Username", new { Username = search + '%' }, transaction: txn)
.Select(x => x.Username)
.ToArray());
}
}
public DbProperties CreateConnection(string server, string port, string username, string password,
string dbName)
{
var properties = new DbProperties
{
Server = server, Port = port, Username = username, Password = password, DatabaseName = dbName
};
DbProperties = properties;
Connection = DatabaseFactory.CreateConnection(properties);
return(properties);
}
/// <summary>
/// Creates a user.
/// </summary>
/// <returns><c>true</c>, if user was created, <c>false</c> otherwise.</returns>
/// <param name="name">The players name.</param>
/// <param name="password">Password.</param>
/// <param name="op">If set to <c>true</c> op.</param>
public static DbPlayer CreatePlayer(string name, string password, bool op = false)
{
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
var player = new DbPlayer(name, password)
{
Operator = op,
DateAdded = DateTime.UtcNow
};
player.Id = ctx.Insert(player, transaction: txn);
var hc = new HookContext();
var ha = new Events.HookArgs.PlayerRegistered()
{
Connection = ctx,
Transaction = txn,
Player = player
};
Events.HookPoints.PlayerRegistered.Invoke(ref hc, ref ha);
if (hc.Result == HookResult.DEFAULT)
{
txn.Commit();
return(player);
}
else
{
txn.Rollback();
return(null);
}
}
}
#else
using (var ctx = new TContext())
{
DbPlayer player;
ctx.Players.Add(player = new DbPlayer(name, password)
{
Operator = op,
DateAddedUTC = DateTime.UtcNow
});
ctx.SaveChanges();
return(player);
}
#endif
}
/// <summary>
/// Checks if a player exists
/// </summary>
/// <returns><c>true</c>, if the player exists, <c>false</c> otherwise.</returns>
/// <param name="name">Player name.</param>
public static bool PlayerExists(string name)
{
#if ENTITY_FRAMEWORK_7
using (var ctx = new TContext())
{
return(ctx.Players.Any(x => x.Name == name));
}
#elif DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.Count <DbPlayer>(new { Name = name }, transaction: txn) > 0);
}
#endif
}
public static bool DeleteType(long accountId, string type, string value)
{
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
var res = ctx.Execute($"delete from {TableMapper.TypeToName<APIAccountRole>()} " +
$"where {ColumnMapper.Enclose("AccountId")} = @AccountId " +
$"and {ColumnMapper.Enclose("Type")} = @Type " +
$"and {ColumnMapper.Enclose("Value")} = @Value", new { AccountId = accountId, Type = type, Value = value }, transaction: txn);
txn.Commit();
return(res > 0);
}
}
}
public static async Task <APIAccountRole[]> GetRolesForAccount(long accountId)
{
#if ENTITY_FRAMEWORK_6 || ENTITY_FRAMEWORK_7
using (var ctx = new TContext())
{
return(await ctx.APIAccountsRoles.Where(x => x.AccountId == accountId).ToArrayAsync());
}
#elif DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return((await ctx.WhereAsync <APIAccountRole>(new { AccountId = accountId }, transaction: txn)).ToArray());
}
#else
return(null);
#endif
}
public static async Task <APIAccount> FindByNameAsync(string name)
{
#if ENTITY_FRAMEWORK_6 || ENTITY_FRAMEWORK_7
using (var ctx = new TContext())
{
return(await ctx.APIAccounts.FirstOrDefaultAsync(x => x.Username == name));
}
#elif DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(await ctx.FirstOrDefaultAsync <APIAccount>(new { Username = name }, transaction : txn));
}
#else
return(null);
#endif
}
public static void SaveAll()
{
if ((DateTime.Now - _lastSave).TotalSeconds >= SaveInterval)
{
//Don't perform any unnecessary writes
var hasPlayers = Netplay.anyClients;
if (!hasPlayers && !_hadPlayers && !EnsureSave)
{
return;
}
EnsureSave = false;
try
{
#if ENTITY_FRAMEWORK_7
using (var ctx = new TContext())
#elif DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
#endif
{
using (var txn = ctx.BeginTransaction())
{
foreach (var ply in Terraria.Main.player)
{
if (ply != null && ply.active && ply.GetSSCReadyForSave())
{
SavePlayerData(ctx, txn, false, ply);
}
}
txn.Commit();
}
#if ENTITY_FRAMEWORK_7
ctx.SaveChanges();
#endif
}
}
catch (Exception e)
{
ProgramLog.Log(e);
}
_hadPlayers = hasPlayers;
_lastSave = DateTime.Now;
}
}
public Dbclient(string connectionString, string provider)
{
_connection = DatabaseFactory.CreateConnection(connectionString, provider);
Aop = new Aop()
{
OnError = (sql, paramter) =>
{
logger.Error($"Sql: {sql}, \r\n paramter: {JsonConvert.SerializeObject(paramter)}");
//Console.WriteLine(sql);
},
OnExecuting = (sql, paramter) =>
{
//Console.WriteLine(sql);
logger.InfoFormat("Sql: \r\n{0}", sql);
},
};
}
public static bool DeleteAccount(long accountId)
{
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
//Remove all roles
ctx.Execute($"delete from {TableMapper.TypeToName<APIAccountRole>()} " +
$"where {ColumnMapper.Enclose("AccountId")} = @AccountId ", new { AccountId = accountId }, transaction: txn);
//Remove the account
var res = ctx.Execute($"delete from {TableMapper.TypeToName<APIAccount>()} " +
$"where {ColumnMapper.Enclose("Id")} = @Id ", new { Id = accountId }, transaction: txn);
txn.Commit();
return(res > 0);
}
}
}
public static APIAccount Create(string name, string password)
{
var acc = new APIAccount()
{
Username = name,
Password = password
};
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
acc.Id = ctx.Insert(acc, txn);
txn.Commit();
}
}
return(acc);
}
/// <summary>
/// Gets the players password.
/// </summary>
/// <returns>The players password.</returns>
/// <param name="name">Player name.</param>
public static string GetPlayerPasword(string name)
{
#if ENTITY_FRAMEWORK_7
using (var ctx = new TContext())
{
return(ctx.Players
.Where(x => x.Name == name)
.Select(x => x.Password)
.FirstOrDefault());
}
#elif DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.Where <DbPlayer>(new { Name = name }, transaction: txn)
.Select(x => x.Password)
.FirstOrDefault());
}
#endif
}
public static APIAccountRole AddType(long accountId, string type, string value)
{
var acc = new APIAccountRole()
{
AccountId = accountId,
Type = type,
Value = value
};
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
acc.Id = ctx.Insert(acc, txn);
txn.Commit();
}
}
return(acc);
}
public DatabaseContext CreateDatabase(string dbName)
{
if (!IsConnectionActive())
{
throw new Exception(ConnectionNotOpenMsg);
}
if (string.IsNullOrEmpty(dbName) || GetDatabases().Contains(dbName))
{
throw new Exception(InvalidDatabase);
}
Connection.Close();
DbProperties.DatabaseName = Config.DatabaseNamePrefix + dbName;
Connection = DatabaseFactory.CreateConnection(DbProperties);
try
{
return(DatabaseFactory.CreateDatabase(Connection));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception(ErrorCreatingDb);
}
}
[Hook(HookOrder.LATE)] //This is required so this can be called last, in order for us to know if it's been cancelled or not
void OnPlayerAuthenticated(ref HookContext ctx, ref TDSMHookArgs.PlayerAuthenticationChanged args)
{
if (ctx.Client.State >= 4 && CharacterManager.Mode == CharacterMode.AUTH)
{
#if ENTITY_FRAMEWORK_7
using (var dbCtx = new TContext())
#elif DAPPER
using (var dbCtx = DatabaseFactory.CreateConnection())
#endif
{
using (var txn = dbCtx.BeginTransaction())
{
CharacterManager.LoadForAuthenticated(dbCtx, txn, ctx.Player, !Config.SSC_AllowGuestInfo);
txn.Commit();
}
}
if (Config.SSC_AllowGuestInfo)
{
ctx.Player.SetSSCReadyForSave(true); //Since we aren't issuing out data, and accepting it, we can save it.
}
}
}
void OnPlayerJoin(ref HookContext ctx, ref HookArgs.PlayerEnteredGame args)
{
//The player may randomly disconnect at any time, and if it's before the point of saving then the data may be lost.
//So we must ensure the data is saved.
//ServerCharacters.CharacterManager.EnsureSave = true;
#if ENTITY_FRAMEWORK_7
using (var dbCtx = new TContext())
#elif DAPPER
using (var dbCtx = DatabaseFactory.CreateConnection())
#endif
{
using (var txn = dbCtx.BeginTransaction())
{
if (CharacterManager.Mode == CharacterMode.UUID)
{
CharacterManager.LoadForAuthenticated(dbCtx, txn, ctx.Player, !Config.SSC_AllowGuestInfo);
}
else if (CharacterManager.Mode == CharacterMode.AUTH)
{
if (!String.IsNullOrEmpty(ctx.Player.GetAuthenticatedAs()))
{
CharacterManager.LoadForAuthenticated(dbCtx, txn, ctx.Player, !Config.SSC_AllowGuestInfo);
}
else
{
if (!Config.SSC_AllowGuestInfo)
{
CharacterManager.LoadForGuest(ctx.Player);
}
}
}
txn.Commit();
}
}
}
/// <summary>
/// Gets the player from the database by name
/// </summary>
/// <returns>The player instance.</returns>
/// <param name="name">Player name.</param>
public static DbPlayer GetPlayer(string name, IDbConnection connection = null, IDbTransaction transaction = null)
{
#if ENTITY_FRAMEWORK_7
using (var ctx = new TContext())
{
return(ctx.Players
.Where(x => x.Name == name)
.FirstOrDefault());
}
#elif DAPPER
if (connection == null)
{
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.FirstOrDefault <DbPlayer>(new { Name = name }, transaction: txn));
}
}
else
{
return(connection.FirstOrDefault <DbPlayer>(new { Name = name }, transaction: transaction));
}
#endif
}
/// <summary>
/// Removes a player from the database by name
/// </summary>
/// <returns><c>true</c>, if the player was deleted, <c>false</c> otherwise.</returns>
/// <param name="name">The players name.</param>
public static bool DeletePlayer(string name)
{
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
var res = ctx.Execute($"delete from {TableMapper.TypeToName<DbPlayer>()} where Name = @Name", new { Name = name }, transaction: txn) > 0;
txn.Commit();
return(res);
}
}
#else
using (var ctx = new TContext())
{
var matches = ctx.Players.Where(x => x.Name == name);
ctx.Players.RemoveRange(matches);
ctx.SaveChanges();
return(ctx.Players.Any(x => x.Name == name));
}
#endif
}
public ApplicationClass(DatabaseFactory factory) // ctor
{
databaseFactory = factory;
connection = factory.CreateConnection();
command = factory.CreateCommand();
}
protected override void Initialized(object state)
{
ProgramLog.Log("TDSM Rebind core build {0}", this.Version);
//Register hook sources
PluginManager.RegisterHookSource(typeof(TDSMHookPoints));
PluginManager.RegisterHookSource(typeof(Events.HookPoints));
CommandDictionary = new Dictionary <string, string>();
Ops = new PairFileRegister(System.IO.Path.Combine(Globals.DataPath, "ops.txt"));
Whitelist = new DataRegister(System.IO.Path.Combine(Globals.DataPath, "whitelist.txt"), false);
string configFile;
if (!String.IsNullOrEmpty(configFile = Terraria.Initializers.LaunchInitializer.TryParameter("-config")))
{
Config.LoadFromFile(configFile);
}
Config.LoadFromArguments();
if (!String.IsNullOrEmpty(Config.DatabaseProvider))
{
OTA.Data.DatabaseFactory.Initialise(Config.DatabaseProvider, Config.DatabaseConnectionString);
Storage.IsAvailable = true;
OTA.Permissions.Permissions.SetHandler(new OTAPIPermissions());
Dapper.SqlMapper.AddTypeMap(typeof(PasswordFormat), System.Data.DbType.Int32);
Dapper.SqlMapper.AddTypeMap(typeof(Byte), System.Data.DbType.Byte);
//Test if we have a connection
try
{
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
try
{
var count = ctx.ExecuteScalar <long>($"select 1;", transaction: txn);
//#if DEBUG
// ProgramLog.Debug.EnableConsoleOutput = true;
//#endif
if (count != 1)
{
ProgramLog.Debug.Log("Failed to get a valid number from the database.");
}
else
{
ProgramLog.Debug.Log("Database connected.");
}
}
finally
{
txn.Commit();
}
}
}
}
catch (Exception ex)
{
ProgramLog.Error.Log(ex, "Failed to connect to the database.");
}
}
ProgramLog.LogRotation = Config.LogRotation;
Hook(OTA.Commands.Events.CommandEvents.Listening, OnListeningForCommands);
AddComponents <Entry>();
if (!RunComponent(ComponentEvent.Initialise))
{
this.Disable();
ProgramLog.Log("TDSM Rebind core disabled as components are not running.");
return;
}
ProgramLog.Log("TDSM Rebind core enabled");
}