public override void Execute(Database database, IIssueCollector issueCollector, IProviderCollection providers)
{
foreach (var table in database.Tables.Where(t => t.ForeignKeys.Count > 0 && t.PrimaryKey != null))
{
foreach (var fk in table.ForeignKeys.Where(fk => TableID.TableEquals(fk.PKTable, fk.FKTable)))
{
bool isContained = true;
foreach (var pair in fk.ColumnPairs)
{
if (!table.PrimaryKey.Columns.Contains(pair.FKColumn))
{
isContained = false;
}
}
if (isContained)
{
issueCollector.ReportIssue(new Issue(this, DefaultSeverity.Value)
{
Name = this.Name,
Context = new TableContext(table),
Description = new Description("The primary key '{0}' in table '{1}' references itself", table.PrimaryKey.PrimaryKeyName, table),
ExtendedDescription = new Description("Having a self-referencing primary key is likely not what is intended."),
});
}
}
}
}
public GDPbyIndustry()
{
_freq = new Frequency
{
Options =
(BeaParameterOptions.IsRequired | BeaParameterOptions.HasAllValue |
BeaParameterOptions.AllowMultiples),
AllValue = Globals.ALL_STRING
};
_industry = new Industry
{
Options =
(BeaParameterOptions.IsRequired | BeaParameterOptions.HasAllValue |
BeaParameterOptions.AllowMultiples),
AllValue = Globals.ALL_STRING
};
_tableId = new TableID
{
Options =
(BeaParameterOptions.IsRequired | BeaParameterOptions.HasAllValue |
BeaParameterOptions.AllowMultiples),
AllValue = Globals.ALL_STRING
};
_beaYear = new BeaYear
{
Options =
(BeaParameterOptions.IsRequired | BeaParameterOptions.HasAllValue |
BeaParameterOptions.AllowMultiples),
AllValue = Globals.ALL_STRING
};
MyParameters = new List <BeaParameter> {
_freq, _industry, _tableId, _beaYear
};
}
public double this[TableID tid]
{
get
{
return(this._importanceVector[tid]);
}
}
// 读取一个表，仅仅读取表头
private void readTable(TableID tableID, ByteBuffer bytes)
{
TableBase table = m_dicTable[tableID];
table.m_byteBuffer = bytes;
bytes.setEndian(Endian.LITTLE_ENDIAN);
uint len = 0;
bytes.readUnsignedInt32(ref len);
uint i = 0;
TableItemBase item = null;
for (i = 0; i < len; i++)
{
//if (TableID.TABLE_OBJECT == tableID)
//{
// item = new TableItemObject();
//}
item = new TableItemBase();
item.parseHeaderByteBuffer(bytes);
// 加载完整数据
//loadOneTableOneItemAll(tableID, table, item);
//if (TableID.TABLE_OBJECT == tableID)
//{
//item.parseAllByteBuffer<TableObjectItemBody>(bytes);
//}
table.m_List.Add(item);
}
}
protected override string GetQuery(CodeActivityContext context)
{
string tableId = TableID.Get(context);
DateTime dueDate = DueDate.Get(context);
string title = Title.Get(context);
if (dueDate == null || dueDate == DateTime.MinValue)
{
dueDate = DateTime.Now.AddMonths(1);
}
var dict = DictionaryFields.Get(context);
if (dict == null || dict.Count == 0)
{
var dataRow = DataRowFields.Get(context);
var tempDict = dataRow.ToDictionary();
if (tempDict != null)
{
dict = tempDict;
}
}
if (string.IsNullOrWhiteSpace(title) && dict?.Count > 0)
{
title = dict.First().Value.ToString();
}
return(BuildQuery(tableId, title, dict, dueDate));
}
public DataEnumerator(DataTable table)
{
this.Disposed = false;
lock (_masterLock)
{
if (!_tableQueuedEnumerators.Any(kv => TableID.TableEquals(kv.Key, table)))
{
_tableQueuedEnumerators.Enqueue(new KeyValuePair <DataTable, List <DataEnumerator> >(table, new List <DataEnumerator>()
{
this
}));
if (masterThread == null)
{
masterThread = new Thread(DoWork);
masterThread.Start();
}
NextTable.Release();
}
else
{
_tableQueuedEnumerators.First(kv => TableID.TableEquals(table, kv.Key)).Value.Add(this);
}
}
}
// 加载一个表中一项的所有内容
public void loadOneTableOneItemAll(TableID tableID, TableBase table, TableItemBase itemBase)
{
if (TableID.TABLE_OBJECT == tableID)
{
itemBase.parseBodyByteBuffer <TableObjectItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_CARD == tableID)
{
itemBase.parseBodyByteBuffer <TableCardItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_SKILL == tableID) // 添加一个表的步骤四
{
itemBase.parseBodyByteBuffer <TableSkillItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_JOB == tableID)
{
itemBase.parseBodyByteBuffer <TableJobItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_SPRITEANI == tableID)
{
itemBase.parseBodyByteBuffer <TableSpriteAniItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_RACE == tableID)
{
itemBase.parseBodyByteBuffer <TableRaceItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_STATE == tableID)
{
itemBase.parseBodyByteBuffer <TableStateItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
}
public override bool SkipTable(Table table)
{
//There must be exactly two FKs
if (table.ForeignKeys.Count != 2)
{
return(true);
}
//The foreign keys must point to two different tables
if (TableID.TableEquals(table.ForeignKeys[0].PKTable, table.ForeignKeys[1].PKTable))
{
return(true);
}
if (table.PrimaryKey == null)
{
return(true);
}
//Both foreignkeys must be part of PK
var fkColums = (from fk in table.ForeignKeys
from colPair in fk.ColumnPairs
select colPair.FKColumn);
if (!fkColums.All(c => table.PrimaryKey.Columns.Contains(c)))
{
return(true);
}
return(false);
}
public string GetSummarySimple()
{
var tableID = TableID.ToString("X16");
var tableData = TableUtil.GetTable(Entries);
return(tableID + Environment.NewLine + tableData + Environment.NewLine);
}
private static void AddPrimaryKeys(Extractor extractor, Database database)
{
foreach (var schema in database.Schemas)
{
var tableID = new TableID(database.DatabaseName, schema.SchemaName, null);
foreach (var pk in extractor.Database.GetPrimaryKeys(schema.SchemaName))
{
tableID.TableName = pk.TableName;
if (!database.tableDictionary.ContainsKey(tableID))
{
continue;
}
var table = database.tableDictionary[tableID];
using (var primaryKey = new PrimaryKey(table, pk.KeyName))
{
var columns = from c in pk.IndexOrderdColumnNames
orderby c.Key
select table.Columns.First(col => col.ColumnName == c.Value);
foreach (var column in columns)
{
primaryKey._columns.Add(column);
}
primaryKey.Table = table;
primaryKey.Schema = schema;
primaryKey.Database = database;
table.PrimaryKey = primaryKey;
if (!primaryKey.IsMulticolumn)
{
primaryKey.Columns.First().Unique = true;
}
}
}
}
}
public static bool TableEquals(TableID tid, TableID tid2)
{
if (tid == null || tid2 == null || GetTableHashCode(tid) != GetTableHashCode(tid2))
{
return(false);
}
return(tid.TableName.Equals(tid2.TableName) && SchemaEquals(tid, tid2));
}
public TableContext(TableID table, IEnumerable <ColumnID> columns) : this(table)
{
this.Columns = columns;
foreach (var g in columns.GroupBy(c => c.TableName))
{
this.tables.Add(g.First());
}
}
private static void AddForeignKeys(Extractor extractor, Database db)
{
foreach (var schema in db.Schemas)
{
var foreignKeys = extractor.Database.GetForeignKeys(schema.SchemaName);
var pktableID = new TableID(extractor.DatabaseName, null, null);
var fktableID = new TableID(extractor.DatabaseName, null, null);
foreach (var foreignKey in foreignKeys)
{
pktableID.SchemaName = foreignKey.PrimaryKeySchemaName;
pktableID.TableName = foreignKey.PrimaryKeyTableName;
fktableID.SchemaName = foreignKey.SchemaName;
fktableID.TableName = foreignKey.TableName;
if (!(db.tableDictionary.ContainsKey(pktableID) && db.tableDictionary.ContainsKey(fktableID)))
{
continue;
}
var pktable = db.tableDictionary[pktableID];
var fktable = db.tableDictionary[fktableID];
pktable._referencedBy.Add(fktable);
fktable._references.Add(pktable);
using (var fk = new ForeignKey(db.DatabaseName, schema.SchemaName, foreignKey.ForeignKeyName))
{
fk.Schema = schema;
fk.Database = db;
fk.PKTable = pktable;
fk.FKTable = fktable;
fk.UpdateRule = foreignKey.UpdateRule;
fk.DeleteRule = foreignKey.DeleteRule;
fk.Deferrability = foreignKey.Deferrability;
fk.InitialMode = foreignKey.InitialMode;
var addFk = true;
foreach (var colpair in foreignKey.IndexOrderdColumnNames)
{
var pkcolumn = pktable.Columns.FirstOrDefault(c => c.ColumnName == colpair.Value.PrimaryKeyColumn);
var fkcolumn = fktable.Columns.FirstOrDefault(c => c.ColumnName == colpair.Value.ForeignKeyColumn);
if (fkcolumn == null || pkcolumn == null)
{
addFk = false;
break;
}
var fkpair = new ForeignKeyPair(fkcolumn, pkcolumn, colpair.Key);
fk._columnPairs.Add(fkpair);
}
if (addFk)
{
fktable._foreignKeys.Add(fk);
}
}
}
}
}
public string getTableName(TableID tableID)
{
TableBase table = m_dicTable[tableID];
if (table != null)
{
return table.m_tableName;
}
return "";
}
public static int GetTableHashCode(TableID tid)
{
if (!tid._hashCode.HasValue)
{
tid._hashCode = tid._tableName.GetHashCode();
}
return(GetSchemaHashCode(tid) * 19 + tid._hashCode.Value);
}
public void loadOneTable(TableID tableID)
{
TableBase table = m_dicTable[tableID];
byte[] bytes = Ctx.m_instance.m_localFileSys.LoadFileByte(Ctx.m_instance.m_cfg.m_path, table.m_resName + ".txt");
ByteArray byteArray = new ByteArray();
byteArray.writeBytes(bytes, 0, (uint)bytes.Length);
byteArray.position = 0;
readTable(TableID.TABLE_OBJECT, byteArray);
}
public List<ItemBase> getTable(TableID tableID)
{
TableBase table = m_dicTable[tableID];
if (table == null)
{
loadOneTable(tableID);
table = m_dicTable[tableID];
}
return table.m_List;
}
public override bool Equals(object obj)
{
if (obj is TableID)
{
TableID tableID = obj as TableID;
return(index == tableID.index &&
section == tableID.section);
}
return(false);
}
public CodedIndex2(Type enumType, TableID[] tables)
{
EnumType = enumType;
var y = (double)Enum.GetValues(enumType).Cast<object>().Select(o => Convert.ToUInt64(o)).Max();
var c = y / 2.0;
var x = Math.Log(c + y) / Math.Log(2);
TagWidth = (int)Math.Ceiling(x);
ByteWidth = 2;
Tables = tables;
}
public string getTableName(TableID tableID)
{
TableBase table = m_dicTable[tableID];
if (table != null)
{
return(table.m_tableName);
}
return("");
}
public ItemBase getItem(TableID tableID, uint itemID)
{
TableBase table = m_dicTable[tableID];
if (table == null)
{
loadOneTable(tableID);
table = m_dicTable[tableID];
}
ItemBase ret = TableSys.findDataItem(table, itemID);
return ret;
}
public double this[TableID tableID]
{
get
{
if (_tableInformationContent.ContainsKey(tableID))
{
return(this._tableInformationContent[tableID]);
}
return(0);
}
}
public void loadOneTable(TableID tableID)
{
TableBase table = m_dicTable[tableID];
byte[] bytes = Ctx.m_instance.m_localFileSys.LoadFileByte(Ctx.m_instance.m_cfg.m_path, table.m_resName + ".txt");
ByteArray byteArray = new ByteArray();
byteArray.writeBytes(bytes, 0, (uint)bytes.Length);
byteArray.position = 0;
readTable(TableID.TABLE_OBJECT, byteArray);
}
public List <ItemBase> getTable(TableID tableID)
{
TableBase table = m_dicTable[tableID];
if (table == null)
{
loadOneTable(tableID);
table = m_dicTable[tableID];
}
return(table.m_List);
}
public bool CheckTable(TableID table)
{
if (this.XMLConfig.TablesToCheck != null)
{
return(this.XMLConfig.TablesToCheck.Any(t => t.TableName == table.TableName && t.SchemaName == table.SchemaName));
}
else
{
return(false);
}
}
/*Some fields and methods*/
public bool Equals(Vector other)
{
if (ReferenceEquals(other, null))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Column.Equals(other.Column) && Row.Equals(other.Row) && TableID.Equals(other.TableID));
}
// 加载一个表
public void loadOneTable(TableID tableID)
{
TableBase table = m_dicTable[tableID];
LoadParam param = Ctx.m_instance.m_poolSys.newObject<LoadParam>();
LocalFileSys.modifyLoadParam(Path.Combine(Ctx.m_instance.m_cfg.m_pathLst[(int)ResPathType.ePathTablePath], table.m_resName), param);
param.m_loadEventHandle = onLoadEventHandle;
param.m_loadNeedCoroutine = false;
param.m_resNeedCoroutine = false;
Ctx.m_instance.m_resLoadMgr.loadResources(param);
Ctx.m_instance.m_poolSys.deleteObj(param);
}
public IEnumerable <Issue> GetIssues(TableID table)
{
this.listLock.EnterReadLock();
List <Issue> ret = new List <Issue>();
if (this.tableIssues.ContainsKey(table))
{
ret = this.tableIssues[table];
}
this.listLock.ExitReadLock();
return(ret);
}
public ItemBase getItem(TableID tableID, uint itemID)
{
TableBase table = m_dicTable[tableID];
if (table == null)
{
loadOneTable(tableID);
table = m_dicTable[tableID];
}
ItemBase ret = TableSys.findDataItem(table, itemID);
return(ret);
}
public void TestCRUD_Create()
{
ITableRepository <TTableType> repository = DataSource.DataRepository.GetTableRepositoryFor <TTableType>(TableName);
Assert.AreEqual(TableName, repository.Name);
TTableType data = repository.Add(NewDomainTableData());
data.Should().NotBeNull();
TableID = data.Id;
TableID.Should().BeGreaterThan(0);
}
public String FormatTableID(TableID tableID)
{
Table table = this.dblint.DatabaseModel.GetTable(tableID);
if (table != null)
{
return(this.formatter.Format(table));
}
else
{
return(tableID.TableName);
}
}
// 加载一个表
public void loadOneTable(TableID tableID)
{
TableBase table = m_dicTable[tableID];
LoadParam param = Ctx.m_instance.m_poolSys.newObject <LoadParam>();
LocalFileSys.modifyLoadParam(Path.Combine(Ctx.m_instance.m_cfg.m_pathLst[(int)ResPathType.ePathTablePath], table.m_resName), param);
param.m_loadEventHandle = onLoadEventHandle;
param.m_loadNeedCoroutine = false;
param.m_resNeedCoroutine = false;
Ctx.m_instance.m_resLoadMgr.loadResources(param);
Ctx.m_instance.m_poolSys.deleteObj(param);
}
void Start()
{
Debug.Log("Game engine start.");
if (!Check())
{
return;
}
TableID.Init();
GameBaseInfo.Instance.Init();
UIHandler.Instance.Init();
Tables.Instance.InitAll(null);
UIManager.Instance.Init();
LocationManager.Instance.Init();
}
private static void AddUniqueConstraints(Extractor extractor, Database database)
{
foreach (var schema in database.Schemas)
{
var tableID = new TableID(schema.DatabaseName, schema.SchemaName, null);
var uniqueConstraints = extractor.Database.GetUniqueConstraints(schema.SchemaName);
foreach (var uniqueConstraint in uniqueConstraints)
{
tableID.TableName = uniqueConstraint.TableName;
if (!database.tableDictionary.ContainsKey(tableID))
{
continue;
}
var table = database.tableDictionary[tableID];
using (var uc = new UniqueConstraint(table))
{
var kname = uniqueConstraint.KeyName;
uc.ConstraintName = kname;
var columns = from colname in uniqueConstraint.IndexOrderdColumnNames
orderby colname.Key
select colname.Value;
var addConstraint = true;
foreach (var colname in columns)
{
var column = table.Columns.FirstOrDefault(col => col.ColumnName == colname);
if (column == null)
{
addConstraint = false;
break;
}
uc._columns.Add(column);
if (!uniqueConstraint.IsMultiColumn)
{
column.Unique = true;
}
}
if (addConstraint)
{
table._uniqueConstraints.Add(uc);
}
}
}
}
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var tableid = TableID.Get(context);
var rownumber = RowNumber.Get(context);
///////////////////////////
// Add execution logic HERE
SAPAuto objSAPAuto = new SAPAuto();
objSAPAuto.TableRow_Select(tableid, rownumber);
///////////////////////////
// Outputs
return((ctx) => {
});
}
static public Boolean SendNotificationToCloudServer(TableID tableId, DatabaseOperationType type,
string imsi)
{
if (udpClient == null)
{
udpClient = new UdpClient(11000);
udpClient.Connect(cloudServerIP, 37000);
}
int len = 4 + 2 + imsi.Length; // 4 is PMD ID
byte[] data = new byte[5 + len];
data[0] = 0xB2;
data[1] = (byte)(len & 0xff);
data[2] = (byte)((len >> 8) & 0xff);
data[3] = 0x00;
data[4] = 0x00;
data[5] = (byte)(webServerId & 0xff);
data[6] = (byte)((webServerId >> 8) & 0xff);
data[7] = (byte)((webServerId >> 16) & 0xff);
data[8] = (byte)((webServerId >> 24) & 0xff);
data[9] = (byte)tableId;
data[10] = (byte)type;
byte[] keyArray = Encoding.ASCII.GetBytes(imsi);
Buffer.BlockCopy(keyArray, 0, data, 11, keyArray.Length);
int byteSent = udpClient.Send(data, data.Length);
if (byteSent == data.Length)
{
return(true);
}
else
{
return(false);
}
}
private void readTable(TableID tableID, ByteArray bytes)
{
TableBase table = m_dicTable[tableID];
bytes.endian = Endian.LITTLE_ENDIAN;
uint len = bytes.readUnsignedInt();
uint i = 0;
ItemBase item = new ItemBase();
for (i = 0; i < len; i++)
{
if (TableID.TABLE_OBJECT == tableID)
{
item = new ObjectItem();
}
item.parseHeaderByteArray(bytes);
//item.parseByteArrayTestServer(bytes);
table.m_List.Add(item);
}
}
// 返回一个表中一项，返回的时候表中数据全部加载到 Item 中
public TableItemBase getItem(TableID tableID, uint itemID)
{
TableBase table = m_dicTable[tableID];
if (null == table.m_byteBuffer)
{
loadOneTable(tableID);
table = m_dicTable[tableID];
}
TableItemBase ret = TableSys.findDataItem(table, itemID);
if (null != ret && null == ret.m_itemBody)
{
loadOneTableOneItemAll(tableID, table, ret);
}
if (null == ret)
{
Ctx.m_instance.m_logSys.log(string.Format("table name: {0}, table Item {1} 加载失败", (int)tableID, itemID));
}
return ret;
}
public void ParseTable(Stream s, uint rowCount, TableID id)
{
s.AssumeNotNull();
switch (id)
{
case TableID.Module:
ParseModuleTable(s, rowCount);
break;
case TableID.TypeRef:
ParseTypeRefTable(s, rowCount);
break;
case TableID.TypeDef:
ParseTypeDefTable(s, rowCount);
break;
case TableID.Field:
ParseFieldTable(s, rowCount);
break;
case TableID.MethodDef:
ParseMethodDefTable(s, rowCount);
break;
case TableID.Param:
ParseParamTable(s, rowCount);
break;
case TableID.InterfaceImpl:
ParseInterfaceImplTable(s, rowCount);
break;
case TableID.MemberRef:
ParseMemberRefTable(s, rowCount);
break;
case TableID.CustomAttribute:
ParseCustomAttributeTable(s, rowCount);
break;
case TableID.FieldMarshal:
ParseFieldMarshalTable(s, rowCount);
break;
case TableID.DeclSecurty:
ParseDeclSecurityTable(s, rowCount);
break;
case TableID.ClassLayout:
ParseClassLayoutTable(s, rowCount);
break;
case TableID.FieldLayout:
ParseFieldLayoutTable(s, rowCount);
break;
case TableID.StandAloneSig:
ParseStandAloneSigTable(s, rowCount);
break;
case TableID.EventMap:
ParseEventMapTable(s, rowCount);
break;
case TableID.Event:
ParseEventTable(s, rowCount);
break;
case TableID.PropertyMap:
ParsePropertyMapTable(s, rowCount);
break;
case TableID.Property:
ParsePRopertyTable(s, rowCount);
break;
case TableID.MethodSemantics:
ParseMethodSemanticsTable(s, rowCount);
break;
case TableID.MethodImp:
ParseMethodImplTable(s, rowCount);
break;
case TableID.ModuleRef:
ParseModuleRefTable(s, rowCount);
break;
case TableID.TypeSpec:
ParseTypeSpecTable(s, rowCount);
break;
case TableID.ImplMap:
ParseImplMapTabble(s, rowCount);
break;
case TableID.FieldRVA:
ParseFieldRVATable(s, rowCount);
break;
case TableID.Assembly:
ParseAssemblyTable(s, rowCount);
break;
case TableID.AssemblyProcessor:
ParseAssemblyProcessorTable(s, rowCount);
break;
case TableID.AssemblyOS:
ParseAssemblyOSTable(s, rowCount);
break;
case TableID.AssemblyRef:
ParseAssemblyRefTable(s, rowCount);
break;
case TableID.AssemblyRefProcessor:
ParseAssemblyRefProcessorTable(s, rowCount);
break;
case TableID.AssemblyRefOS:
ParseAssemblyRefOsTable(s, rowCount);
break;
case TableID.File:
ParseAssemblyFileTable(s, rowCount);
break;
case TableID.ExportedType:
ParseExportedTypeTable(s, rowCount);
break;
case TableID.ManifestResource:
ParseMainfestResourceTable(s, rowCount);
break;
case TableID.NestedClass:
ParseNestedClassTable(s, rowCount);
break;
case TableID.GenericParam:
ParseGenericParamTable(s, rowCount);
break;
case TableID.MethodSpec:
ParseMethodSpecTable(s, rowCount);
break;
case TableID.GenericParamConstraint:
ParseGenericParamConstraintTable(s, rowCount);
break;
default:
throw new InternalErrorException("Unknown table id");
}
}
// 读取一个表，仅仅读取表头
private void readTable(TableID tableID, ByteBuffer bytes)
{
TableBase table = m_dicTable[tableID];
table.m_byteBuffer = bytes;
bytes.setEndian(Endian.LITTLE_ENDIAN);
uint len = 0;
bytes.readUnsignedInt32(ref len);
uint i = 0;
TableItemBase item = null;
for (i = 0; i < len; i++)
{
//if (TableID.TABLE_OBJECT == tableID)
//{
// item = new TableItemObject();
//}
item = new TableItemBase();
item.parseHeaderByteBuffer(bytes);
// 加载完整数据
//loadOneTableOneItemAll(tableID, table, item);
//if (TableID.TABLE_OBJECT == tableID)
//{
//item.parseAllByteBuffer<TableObjectItemBody>(bytes);
//}
table.m_List.Add(item);
}
}
public TableSchema(TableID tableID, params object[] columns)
{
TableID = tableID;
Columns = columns;
}
// 加载一个表中一项的所有内容
public void loadOneTableOneItemAll(TableID tableID, TableBase table, TableItemBase itemBase)
{
if (TableID.TABLE_OBJECT == tableID)
{
itemBase.parseBodyByteBuffer<TableObjectItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_CARD == tableID)
{
itemBase.parseBodyByteBuffer<TableCardItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_SKILL == tableID) // 添加一个表的步骤四
{
itemBase.parseBodyByteBuffer<TableSkillItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_JOB == tableID)
{
itemBase.parseBodyByteBuffer<TableJobItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_SPRITEANI == tableID)
{
itemBase.parseBodyByteBuffer<TableSpriteAniItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_RACE == tableID)
{
itemBase.parseBodyByteBuffer<TableRaceItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
else if (TableID.TABLE_STATE == tableID)
{
itemBase.parseBodyByteBuffer<TableStateItemBody>(table.m_byteBuffer, itemBase.m_itemHeader.m_offset);
}
}
private ArrayList CalculateData(TableID id)
{
EnumerableRowCollection<WeeklyData.tableTradesRow> result1 = null;
EnumerableRowCollection<WeeklyData.tableDaysRow> result2 = null;
EnumerableRowCollection<WeeklyData.tableTradesRow> result3 = null;
double sumpospnl = 0;
double sumclosepnl = 0;
double sumtradeprofit = 0;
double sumcommission = 0;
double sumPremiumSumma = 0;
double sumpnl = 0;
int summaryReversal;
int index = 0;
string time;
ArrayList valuelist = null;
int newDayIndexer = 0;
if (id == TableID.DayTable)
{
result1 = from item in _weeklyData.tableTrades.AsEnumerable() where (item.id_Day == _dayindexer) select item;
summaryReversal = 0;
foreach (WeeklyData.tableTradesRow dataRow in result1.ToArray())
{
double commission;
double closepnl;
double pospnl;
double tradeprofit;
double premiumSumma;
double pnl;
string openprice = null;
string closeprice = null;
if (dataRow.Operation.ToString() == "Premium")
{
double.TryParse(dataRow.Trades.ToString(), out premiumSumma);
sumPremiumSumma += premiumSumma;
}
if (dataRow.Operation.ToString() == "PNL")
{
double.TryParse(dataRow.PosPNL.ToString(), out pospnl);
sumpospnl += Math.Round(pospnl, 2);
double.TryParse(dataRow.ClosePNL.ToString(), out closepnl);
sumclosepnl += Math.Round(closepnl, 2);
double.TryParse(dataRow.Commission.ToString(), out commission);
sumcommission += Math.Round(commission, 2);
}
if (dataRow.Operation != "PNL" && dataRow.Operation != "Premium")
{
double.TryParse(dataRow.Trades.ToString(), out tradeprofit);
sumtradeprofit += Math.Round(tradeprofit, 2);
}
if (dataRow.Operation != "PNL" && dataRow.Operation != "Premium" && dataRow.Comment != "Closed for Exit")
{
summaryReversal += 1;
}
sumpnl = sumcommission + sumpospnl + sumclosepnl + sumtradeprofit + sumPremiumSumma;
string sumPremium = FormatNumber(sumPremiumSumma);
string sumTrProf = FormatNumber(sumtradeprofit);
string sumComiss = FormatNumber(sumcommission);
string sumPosPNL = FormatNumber(sumpospnl);
string sumClPNL = FormatNumber(sumclosepnl);
string sumPNL = FormatNumber(sumpnl);
//decimal summm = Decimal.Parse(sumTrProf, Nfi);
if (_dayDate.DayOfWeek == DayOfWeek.Friday && _isFullWeek)
_dayDate = _dayDate.AddDays(3);
valuelist = new ArrayList
{
_dayindexer,
_weekindexer,
_dayDate.ToString(DateFormatsManager.CurrentShortDateFormat + " HH:mm:ss"),//result1.ToArray().ElementAt(result1.ToArray().Length - 1).TimeClose,
sumPremiumSumma,
sumtradeprofit,
sumcommission,
sumpospnl,
sumclosepnl,
sumpnl,
summaryReversal,
_dayOpenPrice,
_dayClosePrice
};
}
result3 = from item in _weeklyData.tableTrades.AsEnumerable() where (item.id_Day == _dayindexer - 1) select item;
foreach (WeeklyData.tableTradesRow dataRow in result3.ToArray())
{
if (dataRow.Operation == "PNL")
{
_weeklyData.tableTrades.Rows.Remove(dataRow);
_weeklyData.AcceptChanges();
}
}
}
else
if (id == TableID.WeekTable)
{
result2 = from item in _weeklyData.tableDays.AsEnumerable() where (item.id_Week == _weekindexer) select item;
summaryReversal = 0;
foreach (WeeklyData.tableDaysRow dataRow in result2.ToArray())
{
double commission;
double closepnl;
double pospnl;
double tradeprofit;
double premiumSumma;
double pnl;
int reversal = 0;
int firstday = 0;
DateTime wstarttime;
if (firstday == 0)
{
_startWeek = DateTime.ParseExact(dataRow.Date, DateFormatsManager.CurrentShortDateFormat + " HH:mm:ss", CultureInfo.InvariantCulture);
firstday++;
}
double.TryParse(dataRow.Time_Value.ToString(), out premiumSumma);
sumPremiumSumma += premiumSumma;
double.TryParse(dataRow.PosPNL.ToString(), out pospnl);
sumpospnl += pospnl;
double.TryParse(dataRow.ClosePNL.ToString(), out closepnl);
sumclosepnl += closepnl;
double.TryParse(dataRow.Commission.ToString(), out commission);
sumcommission += commission;
double.TryParse(dataRow.PNL.ToString(), out pnl);
sumpnl += pnl;
int.TryParse(dataRow.Reversal.ToString(), out reversal);
summaryReversal += reversal;
double.TryParse(dataRow.Trades.ToString(), out tradeprofit);
sumtradeprofit += tradeprofit;
string sumPremium = FormatNumber(sumPremiumSumma);
string sumTrProf = FormatNumber(sumtradeprofit);
string sumComiss = FormatNumber(sumcommission);
string sumPosPNL = FormatNumber(sumpospnl);
string sumClPNL = FormatNumber(sumclosepnl);
string sumPNL = FormatNumber(sumpnl);
valuelist = new ArrayList
{
_weekindexer,
result2.ToArray().ElementAt(0).Date,
_startWeek.ToString(DateFormatsManager.CurrentShortDateFormat + " HH:mm:ss"),
sumPremiumSumma,
sumtradeprofit,
sumcommission,
sumpospnl,
sumclosepnl,
sumpnl,
summaryReversal
};
}
}
return valuelist;
}
public SimpleIndex(TableID tableID)
{
TableID = tableID;
ByteWidth = 2;
}
