public void TestTableMigrationChangingPrimaryKey()
{
// Destroy previous table
Database.ExecuteNonQuery(string.Format("DROP TABLE IF EXISTS `{0}`", AttributesUtils.GetTableName(typeof(TestTableWithPrimaryChangingV1))));
// Get a new Database Object to Trigger Migration
var DatabaseV2 = GetDatabaseV2;
Database.RegisterDataObject(typeof(TestTableWithPrimaryChangingV1));
Database.DeleteObject(Database.SelectAllObjects <TestTableWithPrimaryChangingV1>());
Assert.IsEmpty(Database.SelectAllObjects <TestTableWithPrimaryChangingV1>(), "Test Table TestTableWithPrimaryChangingV1 should be empty to begin this tests.");
var objs = new [] { "TestObj1", "TestObj2", "TestObj3" }.Select((ent, i) => new TestTableWithPrimaryChangingV1 {
PrimaryKey = i, Value = ent
}).ToArray();
Database.AddObject(objs);
CollectionAssert.AreEquivalent(objs.Select(obj => obj.Value), Database.SelectAllObjects <TestTableWithPrimaryChangingV1>().Select(obj => obj.Value), "Test Table TestTableWithPrimaryChangingV1 Entries should be available for this test to run.");
// Trigger False Migration
DatabaseV2.RegisterDataObject(typeof(TestTableWithPrimaryChangingV2));
var newObjs = DatabaseV2.SelectAllObjects <TestTableWithPrimaryChangingV2>().ToArray();
CollectionAssert.AreEquivalent(objs.Select(obj => obj.Value), newObjs.Select(obj => obj.Value), "Test Table Migration to TestTableWithPrimaryChangingV2 should retrieve similar values that created ones...");
CollectionAssert.AreEquivalent(objs.Select(obj => obj.PrimaryKey), newObjs.Select(obj => obj.PrimaryKey), "Test Table Migration to TestTableWithPrimaryChangingV2 should retrieve similar values that created ones...");
}
public void TestTableWithBrokenPrimaryKey()
{
// Destroy previous table
Database.ExecuteNonQuery(string.Format("DROP TABLE IF EXISTS `{0}`", AttributesUtils.GetTableName(typeof(TestTableWithBrokenPrimaryV1))));
// Create Table
Database.RegisterDataObject(typeof(TestTableWithBrokenPrimaryV1));
// Break Primary Key
Database.ExecuteNonQuery(string.Format("ALTER TABLE `{0}` DROP PRIMARY KEY", AttributesUtils.GetTableName(typeof(TestTableWithBrokenPrimaryV1))));
// Get a new Database Object to Trigger Migration
var DatabaseV2 = GetDatabaseV2;
// Trigger False Migration
DatabaseV2.RegisterDataObject(typeof(TestTableWithBrokenPrimaryV2));
var adds = DatabaseV2.AddObject(new [] {
new TestTableWithBrokenPrimaryV2 {
PrimaryKey = 1
},
new TestTableWithBrokenPrimaryV2 {
PrimaryKey = 1
},
});
Assert.IsFalse(adds, "Primary Key was not restored and duplicate key were inserted !");
}
/// <summary>
/// Retrieve All DataTables Type
/// </summary>
public static IList <Type> GetAllDataTableTypes()
{
var result = new List <Type>();
try
{
// Walk through each assembly in scripts
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
// Walk through each type in the assembly
foreach (var type in asm.GetTypes())
{
if (!type.IsClass || type.IsAbstract || !typeof(DataObject).IsAssignableFrom(type))
{
continue;
}
// Don't Keep Views...
if (type.GetCustomAttributes <DataTable>(false).Any() && AttributesUtils.GetViewName(type) == null)
{
result.Add(type);
}
}
}
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
{
log.Error("Error while Listing Data Tables", ex);
}
}
return(result);
}
/// <summary>
/// Register Data Object Type if not already Registered
/// </summary>
/// <param name="dataObjectType">DataObject Type</param>
public override void RegisterDataObject(Type dataObjectType)
{
var tableName = AttributesUtils.GetTableOrViewName(dataObjectType);
var isView = AttributesUtils.GetViewName(dataObjectType) != null;
var viewAs = AttributesUtils.GetViewAs(dataObjectType);
DataTableHandler existingHandler;
if (TableDatasets.TryGetValue(tableName, out existingHandler))
{
if (dataObjectType != existingHandler.ObjectType)
{
throw new DatabaseException(string.Format("Table Handler Duplicate for Type: {2}, Table Name '{0}' Already Registered with Type : {1}", tableName, existingHandler.ObjectType, dataObjectType));
}
return;
}
var dataTableHandler = new DataTableHandler(dataObjectType);
try
{
if (isView)
{
if (!string.IsNullOrEmpty(viewAs))
{
ExecuteNonQueryImpl(string.Format("DROP VIEW IF EXISTS `{0}`", tableName));
ExecuteNonQueryImpl(string.Format("CREATE VIEW `{0}` AS {1}", tableName, string.Format(viewAs, string.Format("`{0}`", AttributesUtils.GetTableName(dataObjectType)))));
}
}
else
{
CheckOrCreateTableImpl(dataTableHandler);
}
lock (Lock)
{
TableDatasets.Add(tableName, dataTableHandler);
}
// Init PreCache
if (dataTableHandler.UsesPreCaching)
{
var primary = dataTableHandler.PrimaryKeys.Single();
var objects = MultipleSelectObjectsImpl(dataTableHandler, new [] { WhereClause.Empty }).First();
foreach (var obj in objects)
{
dataTableHandler.SetPreCachedObject(primary.GetValue(obj), obj);
}
}
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("RegisterDataObject: Error While Registering Table \"{0}\"\n{1}", tableName, e);
}
}
}
/// <summary>
/// Helper to Retrieve Table or View Handler from Object Type
/// Return View or Table for Select Queries
/// </summary>
/// <param name="objectType">Object Type</param>
/// <returns>DataTableHandler for this Object Type or null.</returns>
protected DataTableHandler GetTableOrViewHandler(Type objectType)
{
var tableName = AttributesUtils.GetTableOrViewName(objectType);
DataTableHandler handler;
return(TableDatasets.TryGetValue(tableName, out handler) ? handler : null);
}
/// <summary>
/// Gets the number of objects in a given table in the database based on a given set of criteria. (where clause)
/// </summary>
/// <typeparam name="TObject">the type of objects to retrieve</typeparam>
/// <param name="whereExpression">the where clause to filter object count on</param>
/// <returns>a positive integer representing the number of objects that matched the given criteria; zero if no such objects existed</returns>
protected override int GetObjectCountImpl <TObject>(string whereExpression)
{
string tableName = AttributesUtils.GetTableOrViewName(typeof(TObject));
DataTableHandler tableHandler;
if (!TableDatasets.TryGetValue(tableName, out tableHandler))
{
throw new DatabaseException(string.Format("Table {0} is not registered for Database Connection...", tableName));
}
string command = null;
if (string.IsNullOrEmpty(whereExpression))
{
command = string.Format("SELECT COUNT(*) FROM `{0}`", tableName);
}
else
{
command = string.Format("SELECT COUNT(*) FROM `{0}` WHERE {1}", tableName, whereExpression);
}
var count = ExecuteScalarImpl(command);
return(count is long?(int)((long)count) : (int)count);
}
public void TestTableMigrationToNonNullValue()
{
// Destroy previous table
Database.ExecuteNonQuery(string.Format("DROP TABLE IF EXISTS `{0}`", AttributesUtils.GetTableName(typeof(TestTableMigrationNullToNonNull))));
// Get a new Database Object to Trigger Migration
var DatabaseV2 = GetDatabaseV2;
Database.RegisterDataObject(typeof(TestTableMigrationNullToNonNull));
Database.DeleteObject(Database.SelectAllObjects <TestTableMigrationNullToNonNull>());
Assert.IsEmpty(Database.SelectAllObjects <TestTableMigrationNullToNonNull>(), "Test Table TestTableMigrationNullToNonNull should be empty to begin this tests.");
var objs = new [] { "TestObj1", null, "TestObj3" }.Select((ent, i) => new TestTableMigrationNullToNonNull {
StringValue = ent
}).ToArray();
Database.AddObject(objs);
CollectionAssert.AreEquivalent(objs.Select(obj => obj.StringValue), Database.SelectAllObjects <TestTableMigrationNullToNonNull>().Select(obj => obj.StringValue), "Test Table TestTableMigrationNullToNonNull Entries should be available for this test to run.");
// Trigger False Migration
DatabaseV2.RegisterDataObject(typeof(TestTableMigrationNullFromNull));
var newObjs = DatabaseV2.SelectAllObjects <TestTableMigrationNullFromNull>().ToArray();
CollectionAssert.AreEquivalent(objs.Select(obj => obj.StringValue ?? string.Empty), newObjs.Select(obj => obj.StringValue), "Test Table Migration to TestTableMigrationNullFromNull should retrieve similar values that created ones...");
CollectionAssert.AreEqual(Enumerable.Repeat(0, 3), newObjs.Select(obj => obj.IntValue), "Test Table Migration to TestTableMigrationNullFromNull should retrieve all default int value to 0...");
}
/// <summary>
/// Register Data Object Type if not already Registered
/// </summary>
/// <param name="dataObjectType">DataObject Type</param>
public virtual void RegisterDataObject(Type dataObjectType)
{
var tableName = AttributesUtils.GetTableOrViewName(dataObjectType);
if (TableDatasets.ContainsKey(tableName))
{
return;
}
var dataTableHandler = new DataTableHandler(dataObjectType);
TableDatasets.Add(tableName, dataTableHandler);
}
public void ToListShouldSortByKey()
{
var attributes = new Dictionary <string, string>
{
{ "someInt", "123" },
{ "bizDate", "2010-08-06" }
};
var expected = new List <string> {
"2010-08-06", "123"
};
Assert.AreEqual(expected, AttributesUtils.ToList(attributes));
}
private void InitData()
{
List <AttributesUtils.EnumItem> listFieldType = AttributesUtils.GetEnumList <Common.BaseEnum.Enumeration.FieldTypes>();
ExcelFieldType.DataSource = listFieldType;
ExcelFieldType.DataTextField = "Value";
ExcelFieldType.DataValueField = "Key";
ExcelFieldType.DataBind();
SQLFieldType.DataSource = listFieldType;
SQLFieldType.DataTextField = "Value";
SQLFieldType.DataValueField = "Key";
SQLFieldType.DataBind();
}
public void TestTableMigrationWithDifferentTypes()
{
// Destroy previous table
Database.ExecuteNonQuery(string.Format("DROP TABLE IF EXISTS `{0}`", AttributesUtils.GetTableName(typeof(TestTableDifferentTypesV1))));
// Get a new Database Object to Trigger Migration
var DatabaseV2 = GetDatabaseV2;
Database.RegisterDataObject(typeof(TestTableDifferentTypesV1));
Database.DeleteObject(Database.SelectAllObjects <TestTableDifferentTypesV1>());
Assert.IsEmpty(Database.SelectAllObjects <TestTableDifferentTypesV1>(), "Test Table TestTableDifferentTypesV1 should be empty to begin this tests.");
var datenow = DateTime.UtcNow;
var now = new DateTime(datenow.Year, datenow.Month, datenow.Day, datenow.Hour, datenow.Minute, datenow.Second);
var objs = new [] { "TestObj1", "TestObj2", "TestObj3" }.Select((ent, i) => new TestTableDifferentTypesV1 {
StringValue = ent, IntValue = i, DateValue = now
}).ToArray();
Database.AddObject(objs);
CollectionAssert.AreEquivalent(objs.Select(obj => obj.StringValue), Database.SelectAllObjects <TestTableDifferentTypesV1>().Select(obj => obj.StringValue), "Test Table TestTableDifferentTypesV1 Entries should be available for this test to run.");
// Trigger False Migration
DatabaseV2.RegisterDataObject(typeof(TestTableDifferentTypesV2));
var newObjs = DatabaseV2.SelectAllObjects <TestTableDifferentTypesV2>().ToArray();
CollectionAssert.AreEquivalent(objs.Select(obj => obj.StringValue), newObjs.Select(obj => obj.StringValue), "Test Table Migration to TestTableDifferentTypesV2 should retrieve similar values that created ones...");
CollectionAssert.AreEquivalent(objs.Select(obj => obj.IntValue), newObjs.Select(obj => obj.IntValue), "Test Table Migration to TestTableDifferentTypesV2 should retrieve similar values that created ones...");
CollectionAssert.AreEquivalent(objs.Select(obj => obj.DateValue), newObjs.Select(obj => Convert.ToDateTime(obj.DateValue)), "Test Table Migration to TestTableDifferentTypesV2 should retrieve similar values that created ones...");
// Trigger another Migraiton
DatabaseV2 = GetDatabaseV2;
DatabaseV2.RegisterDataObject(typeof(TestTableDifferentTypesV1));
var newerObjs = DatabaseV2.SelectAllObjects <TestTableDifferentTypesV1>().ToArray();
CollectionAssert.AreEquivalent(objs.Select(obj => obj.StringValue), newerObjs.Select(obj => obj.StringValue), "Test Table Migration to TestTableDifferentTypesV1 should retrieve similar values that created ones...");
CollectionAssert.AreEquivalent(objs.Select(obj => obj.IntValue), newerObjs.Select(obj => obj.IntValue), "Test Table Migration to TestTableDifferentTypesV1 should retrieve similar values that created ones...");
CollectionAssert.AreEquivalent(objs.Select(obj => obj.DateValue), newerObjs.Select(obj => obj.DateValue), "Test Table Migration to TestTableDifferentTypesV1 should retrieve similar values that created ones...");
}
public void TestTableMigrationFromNoPrimaryKeyToAutoInc()
{
// Destroy previous table
Database.ExecuteNonQuery(string.Format("DROP TABLE IF EXISTS `{0}`", AttributesUtils.GetTableName(typeof(TestTableWithNoPrimaryV1))));
// Get a new Database Object to Trigger Migration
var DatabaseV2 = GetDatabaseV2;
Database.RegisterDataObject(typeof(TestTableWithNoPrimaryV1));
Database.DeleteObject(Database.SelectAllObjects <TestTableWithNoPrimaryV1>());
Assert.IsEmpty(Database.SelectAllObjects <TestTableWithNoPrimaryV1>(), "Test Table TestTableWithNoPrimaryV1 should be empty to begin this tests.");
var objs = new [] { "TestObj1", "TestObj2", "TestObj3" }.Select(ent => new TestTableWithNoPrimaryV1 {
Value = ent
}).ToArray();
Database.AddObject(objs);
CollectionAssert.AreEquivalent(objs.Select(obj => obj.Value), Database.SelectAllObjects <TestTableWithNoPrimaryV1>().Select(obj => obj.Value), "Test Table TestTableWithNoPrimaryV1 Entries should be available for this test to run.");
// Trigger False Migration
DatabaseV2.RegisterDataObject(typeof(TestTableWithNoPrimaryV2));
var newObjs = DatabaseV2.SelectAllObjects <TestTableWithNoPrimaryV2>().ToArray();
CollectionAssert.AreEquivalent(objs.Select(obj => obj.Value), newObjs.Select(obj => obj.Value), "Test Table Migration to TestTableWithNoPrimaryV2 should retrieve similar values that created ones...");
Assert.IsTrue(newObjs.All(obj => obj.PrimaryKey != 0), "Test Table Migration to TestTableWithNoPrimaryV2 should have created and populated Primary Key Auto Increment.");
// Trigger Another Migration
DatabaseV2 = GetDatabaseV2;
DatabaseV2.RegisterDataObject(typeof(TestTableWithNoPrimaryV3));
var newerObjs = DatabaseV2.SelectAllObjects <TestTableWithNoPrimaryV3>().ToArray();
CollectionAssert.AreEquivalent(objs.Select(obj => obj.Value), newerObjs.Select(obj => obj.Value), "Test Table Migration to TestTableWithNoPrimaryV3 should retrieve similar values that created ones...");
Assert.IsTrue(newerObjs.All(obj => obj.PrimaryKey2 != 0), "Test Table Migration to TestTableWithNoPrimaryV3 should have created and populated Primary Key Auto Increment.");
}
private static StringBuilder GetEntryQueryBuilder()
{
var queryBuilder = new StringBuilder();
// generate insert query
queryBuilder.Append("INSERT INTO ");
// get proper table name
string tableName = AttributesUtils.GetTableOrViewName(typeof(AuditEntry));
if (string.IsNullOrEmpty(tableName))
{
// this should never, ever happen.
throw new DatabaseException("Audit table does not exist!");
}
queryBuilder.Append(tableName);
queryBuilder.Append(
" (`AuditEntry_ID`,`AuditTime`,`AccountID`,`RemoteHost`,`AuditType`,`AuditSubtype`,`OldValue`,`NewValue`) VALUES");
return(queryBuilder);
}
/// <summary>
/// Create new instance of <see cref="DataTableHandler"/>
/// </summary>
/// <param name="ObjectType">DataObject Type</param>
public DataTableHandler(Type ObjectType)
{
if (!typeof(DataObject).IsAssignableFrom(ObjectType))
{
throw new ArgumentException("DataTableHandler can only register DataObject Types", "ObjectType");
}
this.ObjectType = ObjectType;
// Init Cache and Table Params
TableName = AttributesUtils.GetTableOrViewName(ObjectType);
var isView = AttributesUtils.GetViewName(ObjectType) != null;
HasRelations = false;
UsesPreCaching = AttributesUtils.GetPreCachedFlag(ObjectType);
if (UsesPreCaching)
{
_precache = new ConcurrentDictionary <object, DataObject>();
}
// Parse Table Type
ElementBindings = ObjectType.GetMembers().Select(member => new ElementBinding(member)).Where(bind => bind.IsDataElementBinding).ToArray();
// Views Can't Handle Auto GUID Key
if (!isView)
{
// If no Primary Key AutoIncrement add GUID
if (FieldElementBindings.Any(bind => bind.PrimaryKey != null && !bind.PrimaryKey.AutoIncrement))
{
ElementBindings = ElementBindings.Concat(new [] {
new ElementBinding(ObjectType.GetProperty("ObjectId"),
new DataElement()
{
Unique = true
},
string.Format("{0}_ID", TableName))
}).ToArray();
}
else if (FieldElementBindings.All(bind => bind.PrimaryKey == null))
{
ElementBindings = ElementBindings.Concat(new [] {
new ElementBinding(ObjectType.GetProperty("ObjectId"),
new PrimaryKey(),
string.Format("{0}_ID", TableName))
}).ToArray();
}
}
// Prepare Table
Table = new DataTable(TableName);
var multipleUnique = new List <ElementBinding>();
var indexes = new Dictionary <string, ElementBinding[]>();
//Build Table for DataSet
foreach (var bind in ElementBindings)
{
if (bind.Relation != null)
{
HasRelations = true;
continue;
}
var column = Table.Columns.Add(bind.ColumnName, bind.ValueType);
if (bind.PrimaryKey != null)
{
column.AutoIncrement = bind.PrimaryKey.AutoIncrement;
Table.PrimaryKey = new [] { column };
}
if (bind.DataElement != null)
{
column.AllowDBNull = bind.DataElement.AllowDbNull;
// Store Multi Unique for definition after table
// Single Unique can be defined directly.
if (!string.IsNullOrEmpty(bind.DataElement.UniqueColumns))
{
multipleUnique.Add(bind);
}
else if (bind.DataElement.Unique)
{
Table.Constraints.Add(new UniqueConstraint(string.Format("U_{0}_{1}", TableName, bind.ColumnName), column));
}
// Store Indexes for definition after table
if (!string.IsNullOrEmpty(bind.DataElement.IndexColumns))
{
indexes.Add(string.Format("I_{0}_{1}", TableName, bind.ColumnName), bind.DataElement.IndexColumns.Split(',')
.Select(col => FieldElementBindings.FirstOrDefault(ind => ind.ColumnName.Equals(col.Trim(), StringComparison.OrdinalIgnoreCase)))
.Concat(new [] { bind }).ToArray());
}
else if (bind.DataElement.Index)
{
indexes.Add(string.Format("I_{0}_{1}", TableName, bind.ColumnName), new [] { bind });
}
if (bind.DataElement.Varchar > 0)
{
column.ExtendedProperties.Add("VARCHAR", bind.DataElement.Varchar);
}
}
}
// Set Indexes when all columns are set
Table.ExtendedProperties.Add("INDEXES", indexes.Select(kv => new KeyValuePair <string, DataColumn[]>(
kv.Key,
kv.Value.Select(bind => Table.Columns[bind.ColumnName]).ToArray()))
.ToDictionary(kv => kv.Key, kv => kv.Value));
// Set Unique Constraints when all columns are set.
foreach (var bind in multipleUnique)
{
var columns = bind.DataElement.UniqueColumns.Split(',').Select(column => column.Trim()).Concat(new [] { bind.ColumnName });
Table.Constraints.Add(new UniqueConstraint(string.Format("U_{0}_{1}", TableName, bind.ColumnName),
columns.Select(column => Table.Columns[column]).ToArray()));
}
}
/// <summary>
/// Populate or Refresh Objects Relations
/// </summary>
/// <param name="dataObjects">Objects to Populate</param>
/// <param name="force">Force Refresh even if Autoload is False</param>
protected virtual void FillObjectRelations(IEnumerable <DataObject> dataObjects, bool force)
{
var groups = dataObjects.GroupBy(obj => obj.GetType());
foreach (var grp in groups)
{
var dataType = grp.Key;
var tableName = AttributesUtils.GetTableOrViewName(dataType);
try
{
DataTableHandler tableHandler;
if (!TableDatasets.TryGetValue(tableName, out tableHandler))
{
throw new DatabaseException(string.Format("Table {0} is not registered for Database Connection...", tableName));
}
if (!tableHandler.HasRelations)
{
return;
}
var relations = tableHandler.ElementBindings.Where(bind => bind.Relation != null);
foreach (var relation in relations)
{
// Check if Loading is needed
if (!(relation.Relation.AutoLoad || force))
{
continue;
}
var remoteName = AttributesUtils.GetTableOrViewName(relation.ValueType);
try
{
DataTableHandler remoteHandler;
if (!TableDatasets.TryGetValue(remoteName, out remoteHandler))
{
throw new DatabaseException(string.Format("Table {0} is not registered for Database Connection...", remoteName));
}
// Select Object On Relation Constraint
var localBind = tableHandler.FieldElementBindings.Single(bind => bind.ColumnName.Equals(relation.Relation.LocalField, StringComparison.OrdinalIgnoreCase));
var remoteBind = remoteHandler.FieldElementBindings.Single(bind => bind.ColumnName.Equals(relation.Relation.RemoteField, StringComparison.OrdinalIgnoreCase));
FillObjectRelationsImpl(relation, localBind, remoteBind, remoteHandler, grp);
}
catch (Exception re)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("Could not Retrieve Objects from Relation (Table {0}, Local {1}, Remote Table {2}, Remote {3})\n{4}", tableName,
relation.Relation.LocalField, AttributesUtils.GetTableOrViewName(relation.ValueType), relation.Relation.RemoteField, re);
}
}
}
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("Could not Resolve Relations for Table {0}\n{1}", tableName, e);
}
}
}
}
/// <summary>
/// Unload a DataObject Type to XML File
/// </summary>
/// <param name="t"></param>
public static void UnloadXMLTable(Type t, string directory)
{
if (t == null || !typeof(DataObject).IsAssignableFrom(t))
{
if (log.IsInfoEnabled)
{
log.InfoFormat("Null Type or Incompatible Type in UnloadXMLTable Call: {0}", Environment.StackTrace);
}
}
try
{
// Get all object "Method" Through Reflection
var classMethod = GameServer.Database.GetType().GetMethod("SelectAllObjects", Type.EmptyTypes);
var genericMethod = classMethod.MakeGenericMethod(t);
// Get Table Name
var attrib = t.GetCustomAttributes <DataTable>(false);
if (attrib.Any())
{
var tableName = AttributesUtils.GetTableName(t);
var path = string.Format("{0}{1}{2}.xml", directory, Path.DirectorySeparatorChar, tableName);
if (log.IsInfoEnabled)
{
log.InfoFormat("Unloading Table {0} - To file {1}", tableName, path);
}
var objects = (IEnumerable)genericMethod.Invoke(GameServer.Database, new object[] { });
try
{
// Try Sorting them !
var remarkables = DatabaseUtils.GetRemarkableMembers(t, true);
if (remarkables.Length > 0)
{
var firstOrder = objects.Cast <DataObject>().OrderBy(o => remarkables.First().GetValue(o));
foreach (var remarkable in remarkables.Skip(1))
{
var followingOrder = firstOrder.ThenBy(o => remarkable.GetValue(o));
firstOrder = followingOrder;
}
// Dynamic cast
var castMethods = typeof(Enumerable).GetMethod("Cast");
var castGeneric = castMethods.MakeGenericMethod(t);
var toArrayMethod = typeof(Enumerable).GetMethod("ToArray");
var toArrayGeneric = toArrayMethod.MakeGenericMethod(t);
objects = (IEnumerable)toArrayGeneric.Invoke(null, new object[] { castGeneric.Invoke(null, new object[] { firstOrder }) });
}
}
catch (Exception oe)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Error while sorting Table {0} for XML Unload, Probably Unsorted... - {1}", tableName, oe);
}
}
// Delete Older Files
if (File.Exists(path))
{
File.Delete(path);
}
// Write XML DataTable
var serializer = GetXMLSerializer(t.MakeArrayType(), t);
using (var writer = new StreamWriter(path))
{
serializer.Serialize(writer, objects);
}
}
}
catch (Exception ex)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Could Not Unload Table {0}: {1}", t, ex);
}
}
}
/// <summary>
/// Check For UnloadXML Args
/// </summary>
/// <param name="client"></param>
/// <param name="args"></param>
public void OnCommand(GameClient client, string[] args)
{
if (args.Length < 2)
{
DisplaySyntax(client);
return;
}
var types = LoaderUnloaderXML.GetAllDataTableTypes();
var argTable = args[1];
// Prepare Write Path
var directory = Path.IsPathRooted(XML_UNLOAD_DB_DIRECTORY) ? XML_UNLOAD_DB_DIRECTORY : string.Format("{0}{1}scripts{1}{2}", GameServer.Instance.Configuration.RootDirectory, Path.DirectorySeparatorChar, XML_UNLOAD_DB_DIRECTORY);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
switch (argTable)
{
case "full":
foreach (Type table in types)
{
var dir = directory;
var workingType = table;
System.Threading.Tasks.Task.Factory.StartNew(() => LoaderUnloaderXML.UnloadXMLTable(workingType, dir));
}
break;
default:
var finddir = directory;
var findType = types.FirstOrDefault(t => t.Name.Equals(argTable, StringComparison.OrdinalIgnoreCase) || AttributesUtils.GetTableName(t).Equals(argTable, StringComparison.OrdinalIgnoreCase));
if (findType == null)
{
DisplaySyntax(client);
if (log.IsInfoEnabled)
{
log.InfoFormat("Could not find table to unload with search string : {0}", argTable);
}
return;
}
System.Threading.Tasks.Task.Factory.StartNew(() => LoaderUnloaderXML.UnloadXMLTable(findType, finddir));
break;
}
}
