protected static Record get_Record(IEnumerable <string> cols, SqlDataReader reader, bool pSetFieldNameToLower)
{
try
{
var result = new Record();
foreach (var col in cols)
{
if (pSetFieldNameToLower)
{
result.Add(col.ToLower(), reader[col]);
}
else
{
result.Add(col, reader[col]);
}
}
return(result);
}
catch (Exception ex)
{
throw new Exception("get_Record:" + Core.GetCommonErrorMessage(ex));
}
}
protected static Record get_Record(SqlDataReader reader, bool pSetFieldNameToLower)
{
try
{
var result = new Record();
string field = "";
for (var i = 0; i < reader.FieldCount; i++)
{
field = reader.GetName(i);
if (pSetFieldNameToLower)
{
result.Add(field.ToLower(), reader[field]);
}
else
{
result.Add(field, reader[field]);
}
}
return(result);
}
catch (Exception ex)
{
throw new Exception("get_Record:" + Core.GetCommonErrorMessage(ex));
}
}
public static void Main(string[] commandArgs)
{
try
{
var record = new Record();
record.Add(new Property("title", "My Title"));
record.Add(new Property("header", "My Header"));
var link = new Link();
link.Add(new Property("title", "My Title"));
link.Add(new Property("href", "My #ref"));
link.Add(new Property("header", "My Header"));
link.Add(new Class("header"));
link.Add(new Rel("header"));
record.Add(link);
var file = new ResourceRef();
file.Add(new Property("title", "My Title"));
file.Add(new Property("href", "My #ref"));
file.Add(new Property("header", "My Header"));
file.Add(new Class("header"));
file.Add(new Rel("header"));
record.Add(file);
record.Add(new Property("__meta", Value.CreateObject(new
{
Tables = new
{
Headers = new VName[] {
"Id",
"Name"
}
}
})));
var p1 = record.GetProperty <VArray>("__meta.tables.headers");
record.SetProperty("__meta.tables.headers.id", new[] { 10 });
var p2 = record.GetProperty <VArray>("__meta.tables.headers.id");
var serializer = new MediaSerializer(MimeType.JsonSiren);
var step1 = serializer.Serialize(record);
var target = serializer.Deserialize(step1);
var step2 = serializer.Serialize(record);
Debug.WriteLine(Json.Beautify(step1));
Debug.WriteLine(Json.Beautify(step2));
}
catch (Exception ex)
{
ex.Trace();
}
}
protected virtual void CopyEntityColumnToRecord(string columnName, T entity, ref Record record)
{
//autopopulates a record
//for this to work you must make sure that the parameter name required by the stored procedure is identical to the column name
//defined in the enum member in each entity class
object val = entity[columnName];
//if (val != null)
//{
// if (val is SimpleEntity) //if the column type is SimpleEntity, take the code
// val = ((SimpleEntity)val).Code;
// else if (val is Identifier)
// val = val.ToString();
// else if (val is PIdEntity)
// {
// PIdEntity pidEntity = (PIdEntity)val;
// if (pidEntity.PId.HasValue) val = pidEntity.PId.Value;
// else val = null;
// }
// else if (val is Entity) //if the column type is other Entity (it's not one of the basic types), throw an exception -> we don't know how to map it
// throw new CopyToRecordException(entity.GetType().Name, val.GetType().Name);
// else if (val is DateTime)
// val = DateTimeConverter.DateTimeToDbString((DateTime)val);
//}
record.Add(new DataElement(columnName, val));
}
public void Dig()
{
try
{
//初始化DnsClient，第一个参数为DNS服务器的IP，第二个参数为超时时间
DnsClient dnsClient = new DnsClient(IPAddress.Parse(DnsServer), TimeOut);
//解析域名。将域名请求发送至DNS服务器解析，参数为需要解析的域名
DnsMessage dnsMessage = dnsClient.Resolve(DomainName.Parse(Domain));
//TimeSpan = s.Elapsed;
//若返回结果为空，或者存在错误，则该请求失败。
if (dnsMessage == null || (dnsMessage.ReturnCode != ReturnCode.NoError && dnsMessage.ReturnCode != ReturnCode.NxDomain))
{
IsSuccess = false;
return;
}
//循环遍历返回结果，将返回的IPV4记录添加到结果集List中。
if (dnsMessage != null)
{
foreach (DnsRecordBase dnsRecord in dnsMessage.AnswerRecords)
{
ARecord AR = dnsRecord as ARecord;
if (AR != null)
{
IsSuccess = true;
Record.Add(AR.Address.ToString());
}
}
}
}
catch (Exception)
{
}
}
/// <summary>
/// An extension method to extract outputs from a record dictionary.
/// </summary>
/// <param name="dbDataParameters"> The target enumerable of data paramters. </param>
/// <returns> A dictionary with record key/value pairs of OUTPUT data. </returns>
public static IRecord GetOutputAsRecord(this IEnumerable <IDbDataParameter> dbDataParameters)
{
IRecord output;
if ((object)dbDataParameters == null)
{
throw new ArgumentNullException("dbDataParameters");
}
output = new Record();
foreach (IDbDataParameter dbDataParameter in dbDataParameters)
{
if (dbDataParameter.Direction != ParameterDirection.InputOutput &&
dbDataParameter.Direction != ParameterDirection.Output &&
dbDataParameter.Direction != ParameterDirection.ReturnValue)
{
continue;
}
output.Add(dbDataParameter.ParameterName, dbDataParameter.Value);
}
return(output);
}
public void HandleDeath(Mobile m, bool killedBy)
{
Record.Add(new DuelRecord(m, killedBy));
if (Record.Count > 12)
{
Record.RemoveAt(12);
}
}
public void TestAdd()
{
// setup
var record = new Record();
var expected = "test_value";
record.Add(expected);
// assert
record[0].Is(expected);
}
public void TestAutoEnsureCapacity()
{
// setup
var capacity = 10;
var record = new Record(capacity);
var testCases = createMockRecord(10);
foreach (var tc in testCases)
{
record.Add(tc);
}
}
public void Setting_Values_With_Add_Works()
{
Schema schema = new Schema();
schema.Fields.Add(Field.New <int>("Id"));
schema.Fields.Add(Field.New <string>("Name"));
schema.Fields.Add(Field.New <bool>("IsMale"));
schema.Fields.Add(Field.New <DateTime>("DateOfBirth"));
Record record = new Record(schema);
record.Add(15);
record.Add("Max");
record.Add(true);
record.Add(new DateTime(1982, 11, 5));
Assert.AreEqual(15, record[0]);
Assert.AreEqual("Max", record[1]);
Assert.AreEqual(true, record[2]);
Assert.AreEqual(new DateTime(1982, 11, 5), record[3]);
}
protected override void CopyEntityColumnToRecord(string columnName, Boletim entity, ref Record record)
{
switch (columnName)
{
case Boletim.colIdAluno:
record.Add(new DataElement(columnName, entity.Aluno.IdAluno));
break;
default:
base.CopyEntityColumnToRecord(columnName, entity, ref record);
break;
}
}
protected override void CopyEntityColumnToRecord(string columnName, Validado entity, ref Record record)
{
switch (columnName)
{
case Validado.colIdAluno:
record.Add(new DataElement(columnName, entity.Aluno.IdAluno));
break;
case Validado.colIdMov:
record.Add(new DataElement(columnName, entity.Movimento.IdMov));
break;
case Movimento.colDtValor:
case Aluno.colUsername:
case Aluno.colNome:
break;
default:
base.CopyEntityColumnToRecord(columnName, entity, ref record);
break;
}
}
public override RecordBuilder Add(string field)
{
if (Record.Count == Position)
{
Record.Add(field);
}
else
{
Record[Position] = field;
}
Position++;
return(this);
}
public void CheckCycle(Type convertType)
{
if (!BuilderManager.ContainsBuilder(convertType))
{
if (Record.Contains(convertType))
{
throw new Exception("不允许循环引用");
}
else
{
Record.Add(convertType);
BuilderManager.AddBuilder(convertType, this);
}
}
}
/// <summary>
/// Create a Mock instance for testing.
/// </summary>
/// <param name="recordCnt">The number of pre-set elements</param>
/// <returns>Record instance.</returns>
private Record createMockRecord(int recordCnt = 0)
{
if (recordCnt == 0)
{
return(new Record());
}
var record = new Record();
for (var i = 0; i < recordCnt; i++)
{
record.Add($"test{i}");
}
return(record);
}
public ShipParameterElement this[int i] {
get {
return(Record.ContainsKey(i) ? Record[i] : null);
}
set {
if (!Record.ContainsKey(i))
{
Record.Add(i, value);
}
else
{
Record[i] = value;
}
}
}
/// <summary>
/// 通过sql查询
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public List <Record> Query(string sql)
{
List <Record> list = new List <Record>();
var con = Connection();
try
{
if (con.code != 200)
{
return(list);
}
MySqlCommand cmd = new MySqlCommand(sql, conn);
//执行ExecuteReader()返回一个MySqlDataReader对象
MySqlDataReader reader = cmd.ExecuteReader();
List <string> st = new List <string>();
var u = 0;
while (reader.Read())//初始索引是-1，执行读取下一行数据，返回值是bool
{
if (reader.HasRows)
{
if (u++ == 0)
{
for (var i = 0; i < reader.FieldCount; i++)
{
st.Add(reader.GetName(i).ToLower());
}
}
var r = new Record();
foreach (var x in st)
{
r.Add(x, reader[x]?.ToString() ?? "");
}
list.Add(r);
}
}
reader.Close();
return(list);
}
catch
{
return(list);
}
finally
{
Close();
}
}
public RecordCollection ExecuteRecord(string SQLText)
{
RecordCollection rcc = new RecordCollection();
using (IDataReader rd = ExecuteReader(SQLText))
{
while (rd.Read())
{
Record rc = new Record();
for (int i = 0; i < rd.FieldCount; i++)
{
rc.Add(rd.GetName(i), rd.GetValue(i));
}
rcc.Add(rc);
}
}
return rcc;
}
public void AddRow(IEnumerable values)
{
var list = new ArrayList();
list.Add(++Rowcount);
foreach (var value in values)
{
list.Add(value);
}
var record = new Record();
for (var ii = 0; ii < _columns.Count; ii++)
{
record.Add(new Property(_columns[ii].Name, list[ii]));
}
_records.Add(record);
}
private void PrecreateBaseRecords(IRecord record)
{
foreach (var i in this.Inheritances)
{
var baseModel = (IModel)this.DbDomain.GetResource(i.BaseModel);
var baseRecord = new Record();
foreach (var f in baseModel.Fields)
{
object fieldValue = null;
if (record.TryGetValue(f.Key, out fieldValue))
{
baseRecord.Add(f.Key, fieldValue);
record.Remove(f.Key);
}
}
var baseId = baseModel.CreateInternal(baseRecord);
record[i.RelatedField] = baseId;
}
}
/// <summary>
/// 获得翻牌结果
/// </summary>
/// <param name="data"></param>
public void GetCardsResult(ISFSObject data)
{
if (data == null)
{
return;
}
CardInfos = new List <CardsData>();
TrendData newData = new TrendData();
int zhuangScore = 0;
int xianScore = 0;
if (data.ContainsKey(ConstantData.KeyZhuang))
{
CardsData zhuangInfo = new CardsData(CardResultType.Zhuang, data.GetSFSObject(ConstantData.KeyZhuang));
newData.ZhuangDui = zhuangInfo.DoubleCard;
newData.ZhuangTian = zhuangInfo.King;
CardInfos.Add(zhuangInfo);
zhuangScore = zhuangInfo.Result;
}
if (data.ContainsKey(ConstantData.KeyXian))
{
var xianInfo = new CardsData(CardResultType.Xian, data.GetSFSObject(ConstantData.KeyXian));
newData.XianDui = xianInfo.DoubleCard;
newData.XianTian = xianInfo.King;
CardInfos.Add(xianInfo);
xianScore = xianInfo.Result;
}
if (zhuangScore == xianScore)
{
newData.Win = ConstantData.KeyBetEqual;
}
else
{
newData.Win = zhuangScore > xianScore ? ConstantData.KeyBetBanker : ConstantData.KeyBetLeisure;
}
if (Record == null)
{
Record = new List <TrendData>();
}
Record.Add(newData);
}
/// <summary>
/// An extension method to extract outputs from a record dictionary.
/// </summary>
/// <param name="dbParameters"> The target enumerable of data paramters. </param>
/// <returns> A dictionary with record key/value pairs of OUTPUT data. </returns>
public static IRecord GetOutputAsRecord(this IEnumerable<DbParameter> dbParameters)
{
IRecord output;
if ((object)dbParameters == null)
throw new ArgumentNullException(nameof(dbParameters));
output = new Record();
foreach (DbParameter dbParameter in dbParameters)
{
if (dbParameter.Direction != ParameterDirection.InputOutput &&
dbParameter.Direction != ParameterDirection.Output &&
dbParameter.Direction != ParameterDirection.ReturnValue)
continue;
output.Add(dbParameter.ParameterName, dbParameter.Value);
}
return output;
}
public bool Merge(string line)
{
try
{
var elem = new ShipParameterElement(line);
if (!Record.ContainsKey(elem.ShipID))
{
Record.Add(elem.ShipID, elem);
return(true);
}
else
{
return(Record[elem.ShipID].Merge(elem));
}
}
catch (Exception)
{
return(false);
}
}
protected override void LoadLine(string line)
{
Record.Add(new ResourceElement(line));
}
public static void Core(string packageName)
{
Console.WriteLine(I18N.Core("Install_CollectingPackageInfo"));
//=================================================================pre-process
//name is legal
var packageDbConn = new Database();
packageDbConn.Open();
var reader = (from _i in packageDbConn.CoreDbContext.package
where _i.name == (packageName.Contains("@") ? packageName.Split('@', StringSplitOptions.None)[0] : packageName)
select _i).ToList();
if (!reader.Any())
{
ConsoleAssistance.WriteLine(I18N.Core("General_NoMatchedPackage"), ConsoleColor.Red);
return;
}
packageName = GetVersionNatrually(packageName, packageDbConn);
//is installed ?
var installFolder = new DirectoryInfo(Information.WorkPath.Enter("cache").Enter("installed").Path);
if (installFolder.GetDirectories($"{packageName}").Any())
{
ConsoleAssistance.WriteLine(I18N.Core("Install_InstalledPackage"), ConsoleColor.Red);
return;
}
//====================================================================get-info
//get denpendency tree
Console.WriteLine(I18N.Core("Install_BuildingDependencyTree"));
var cache1 = GetPackageInfo(packageName, packageDbConn);
if (!cache1.res)
{
ConsoleAssistance.WriteLine(I18N.Core("General_NetworkError"), ConsoleColor.Red);
return;
}
//conflict detect
Console.WriteLine(I18N.Core("Install_DetectConflict"));
var cache2 = DetectConflict(cache1.topologyMap, packageDbConn);
if (!cache2.status)
{
ConsoleAssistance.WriteLine(I18N.Core("Install_SelfConflict"), ConsoleColor.Red);
return;
}
//sort dependency
Console.WriteLine(I18N.Core("Install_SortingDependencyTree"));
var cache1_1 = new Dictionary <string, List <string> >();
foreach (var item in cache1.topologyMap.Keys)
{
var cache = new List <string>();
foreach (var depItem in cache1.topologyMap[item].dependency.ToList())
{
cache.Add(GetTopVersion(depItem, packageDbConn));
}
cache1_1.Add(item, cache);
}
var cache3 = KahnTopologySort(cache1_1);
if (!cache3.status)
{
ConsoleAssistance.WriteLine(I18N.Core("Install_CloseLoop"), ConsoleColor.Red);
return;
}
//remove installed package
var realPackage = new List <string>(cache3.res);
foreach (var item in installFolder.GetDirectories())
{
if (realPackage.Contains(item.Name))
{
realPackage.Remove(item.Name);
}
}
packageDbConn.Close();
//sort removed package
var sort_recorder = new Record();
sort_recorder.Init();
var realRemovedPackage = sort_recorder.SortPackage(cache2.res);
sort_recorder.Save();
//=======================================================================output
ConsoleAssistance.WriteLine(I18N.Core("Install_InstallList"), ConsoleColor.Yellow);
foreach (var item in realPackage)
{
Console.WriteLine(item);
}
Console.WriteLine("");
ConsoleAssistance.WriteLine(I18N.Core("Install_RemoveList"), ConsoleColor.Yellow);
if (realRemovedPackage.Count == 0)
{
ConsoleAssistance.WriteLine(I18N.Core("General_None"), ConsoleColor.Yellow);
}
foreach (var item in realRemovedPackage)
{
Console.WriteLine(item);
}
Console.WriteLine("");
ConsoleAssistance.Write(I18N.Core("General_Continue"), ConsoleColor.Yellow);
if (Console.ReadLine().ToUpper() != "Y")
{
ConsoleAssistance.WriteLine(I18N.Core("General_CancelOperation"), ConsoleColor.Red);
return;
}
//============================================================================install
//remove
Console.WriteLine(I18N.Core("Install_RemovingSelectedPackage"));
Remove.RealRemove(realRemovedPackage);
//install
Console.WriteLine(I18N.Core("Install_InstallingSelectedPackage"));
//ready recorder
var recorder = new Record();
recorder.Init();
var zipExtractor = new FastZip();
foreach (var item in realPackage)
{
Console.WriteLine(I18N.Core("Install_InstallItem", item));
//download
var downloadRes = Download.DownloadPackage(item);
Console.WriteLine(Download.JudgeDownloadResult(downloadRes));
if (downloadRes != Download.DownloadResult.OK && downloadRes != Download.DownloadResult.ExistedLocalFile)
{
ConsoleAssistance.WriteLine(I18N.Core("General_NetworkError"), ConsoleColor.Red);
return;
}
//remove decompress folder
Directory.Delete(Information.WorkPath.Enter("cache").Enter("decompress").Path, true);
Directory.CreateDirectory(Information.WorkPath.Enter("cache").Enter("decompress").Path);
//decompress
Console.WriteLine(I18N.Core("Install_ExtractItem", item));
zipExtractor.ExtractZip(Information.WorkPath.Enter("cache").Enter("download").Enter(item + ".zip").Path, Information.WorkPath.Enter("cache").Enter("decompress").Path, "");
Console.WriteLine(I18N.Core("Install_RunScriptItem", item));
var cacheRes = ScriptInvoker.Core(Information.WorkPath.Enter("cache").Enter("decompress").Path, ScriptInvoker.InvokeMethod.Install, "");
if (!cacheRes.status)
{
ConsoleAssistance.WriteLine(I18N.Core("General_ScriptError"), ConsoleColor.Red);
ConsoleAssistance.WriteLine(cacheRes.desc, ConsoleColor.Red);
//save installed package info
recorder.Save();
return;
}
//record first and copy folders
Console.WriteLine(I18N.Core("Install_RecordItem", item));
recorder.Add(item);
PackageAssistance.DirectoryCopy(Information.WorkPath.Enter("cache").Enter("decompress").Path, Information.WorkPath.Enter("cache").Enter("installed").Enter(item).Path, true);
Console.WriteLine(I18N.Core("Install_Success", item));
}
//close recorder
recorder.Save();
ConsoleAssistance.WriteLine(I18N.Core("General_AllOperationDown"), ConsoleColor.Yellow);
}
public IEnumerable<IDictionary<string, object>> ExecuteRecords(bool schemaOnly, Type connectionType, string connectionString, bool transactional, IsolationLevel isolationLevel, CommandType commandType, string commandText, IEnumerable<DbParameter> commandParameters, Action<int> resultsetCallback = null)
{
DbTransaction dbTransaction;
const bool OPEN = true;
IList<IRecord> records;
// force no preparation
const bool COMMAND_PREPARE = false;
// force provider default timeout
object COMMAND_TIMEOUT = null; /*int?*/
CommandBehavior commandBehavior;
int resultsetIndex = 0;
ReadOnlyCollection<DbColumn> dbColumns;
DbColumn dbColumn;
PropertyInfo[] propertyInfos;
PropertyInfo propertyInfo;
if ((object)connectionType == null)
throw new ArgumentNullException(nameof(connectionType));
if ((object)connectionString == null)
throw new ArgumentNullException(nameof(connectionString));
using (DbConnection dbConnection = (DbConnection)Activator.CreateInstance(connectionType))
{
if (OPEN)
{
dbConnection.ConnectionString = connectionString;
dbConnection.Open();
if (transactional)
dbTransaction = dbConnection.BeginTransaction(isolationLevel);
else
dbTransaction = null;
}
using (DbCommand dbCommand = dbConnection.CreateCommand())
{
dbCommand.Transaction = dbTransaction;
dbCommand.CommandType = commandType;
dbCommand.CommandText = commandText;
if ((object)COMMAND_TIMEOUT != null)
dbCommand.CommandTimeout = (int)COMMAND_TIMEOUT;
// add parameters
if ((object)commandParameters != null)
{
foreach (DbParameter commandParameter in commandParameters)
{
if ((object)commandParameter.Value == null)
commandParameter.Value = DBNull.Value;
dbCommand.Parameters.Add(commandParameter);
}
}
if (COMMAND_PREPARE)
dbCommand.Prepare();
records = new List<IRecord>();
commandBehavior = schemaOnly ? CommandBehavior.SchemaOnly : CommandBehavior.Default;
// wrap reader with proxy
using (DbDataReader dbDataReader = new WrappedDbDataReader.__(dbCommand.ExecuteReader(commandBehavior)))
{
Record record;
string key;
object value;
if (!schemaOnly)
{
do
{
if ((object)resultsetCallback != null)
resultsetCallback(resultsetIndex++);
while (dbDataReader.Read())
{
record = new Record();
for (int columnIndex = 0; columnIndex < dbDataReader.FieldCount; columnIndex++)
{
key = dbDataReader.GetName(columnIndex);
value = dbDataReader.GetValue(columnIndex);
value = this.DataTypeFascade.ChangeType<object>(value);
if (record.ContainsKey(key) || (key ?? string.Empty).Length == 0)
key = string.Format("Column_{0:0000}", columnIndex);
record.Add(key, value);
}
records.Add(record);
}
}
while (dbDataReader.NextResult());
}
else
{
if (!dbDataReader.CanGetColumnSchema())
throw new NotSupportedException(string.Format("The connection command type '{0}' does not support schema access.", dbDataReader.GetType().FullName));
dbColumns = dbDataReader.GetColumnSchema();
{
if ((object)dbColumns != null)
{
for (int index = 0; index < dbColumns.Count; index++)
{
dbColumn = dbColumns[index];
propertyInfos = dbColumn.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
record = new Record();
record.Context = dbColumn;
if ((object)propertyInfos != null)
{
for (int i = 0; i < propertyInfos.Length; i++)
{
propertyInfo = propertyInfos[i];
if (propertyInfo.GetIndexParameters().Any())
continue;
key = propertyInfo.Name;
value = propertyInfo.GetValue(dbColumn);
value = value.ChangeType<object>();
record.Add(key, value);
}
}
}
}
}
}
}
return records;
}
}
}
public ConverterBuilderAssistant(Type convertType, ConverterBuilderManager builderManager)
{
Record.Add(convertType);
BuilderManager = builderManager;
}
public void Reset()
{
Record.Clear();
Record.Add(NewRecord());
}
/// <summary>
/// Execute a command against a data source, mapping the data reader GetSchemaTable() result to an enumerable of record dictionaries.
/// This method perfoms LAZY LOADING/DEFERRED EXECUTION.
/// Note that THE DATA READER WILL NOT BE DISPOSED UPON ENUMERATION OR FOREACH BRANCH OUT.
/// </summary>
/// <param name="dbDataReader"> The target data reader. </param>
/// <param name="recordsAffectedCallback"> Executed when the output count of records affected is available to return (post enumeration). </param>
/// <returns> An enumerable of record dictionary instances, containing key/value pairs of schema metadata. </returns>
public IEnumerable<IRecord> GetSchemaRecordsFromReader(DbDataReader dbDataReader, Action<int> recordsAffectedCallback)
{
ReadOnlyCollection<DbColumn> dbColumns;
DbColumn dbColumn;
PropertyInfo[] propertyInfos;
PropertyInfo propertyInfo;
Record record;
int recordsAffected;
string key;
object value;
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): enter", typeof(AdoNetStreamingFascade).Name));
if ((object)dbDataReader == null)
throw new ArgumentNullException(nameof(dbDataReader));
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): before yield", typeof(AdoNetStreamingFascade).Name));
if (!dbDataReader.CanGetColumnSchema())
throw new NotSupportedException(string.Format("The connection command type '{0}' does not support schema access.", dbDataReader.GetType().FullName));
dbColumns = dbDataReader.GetColumnSchema();
{
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): use table", typeof(AdoNetStreamingFascade).Name));
if ((object)dbColumns != null)
{
for (int index = 0; index < dbColumns.Count; index++)
{
dbColumn = dbColumns[index];
propertyInfos = dbColumn.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty);
record = new Record();
record.Context = dbColumn;
if ((object)propertyInfos != null)
{
for (int i = 0; i < propertyInfos.Length; i++)
{
propertyInfo = propertyInfos[i];
if (propertyInfo.GetIndexParameters().Any())
continue;
key = propertyInfo.Name;
value = propertyInfo.GetValue(dbColumn);
value = value.ChangeType<object>();
record.Add(key, value);
}
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): on yield", typeof(AdoNetStreamingFascade).Name));
yield return record; // LAZY PROCESSING INTENT HERE / DO NOT FORCE EAGER LOAD
}
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): dispose table", typeof(AdoNetStreamingFascade).Name));
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): after yield", typeof(AdoNetStreamingFascade).Name));
recordsAffected = dbDataReader.RecordsAffected;
if ((object)recordsAffectedCallback != null)
recordsAffectedCallback(recordsAffected);
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): leave", typeof(AdoNetStreamingFascade).Name));
}
/// <summary>
/// Execute a command against a data source, mapping the data reader to an enumerable of record dictionaries.
/// This method perfoms LAZY LOADING/DEFERRED EXECUTION.
/// Note that THE DATA READER WILL NOT BE DISPOSED UPON ENUMERATION OR FOREACH BRANCH OUT.
/// </summary>
/// <param name="dbDataReader"> The target data reader. </param>
/// <param name="recordsAffectedCallback"> Executed when the output count of records affected is available to return (post enumeration). </param>
/// <returns> An enumerable of record dictionary instances, containing key/value pairs of data. </returns>
public IEnumerable<IRecord> GetRecordsFromReader(DbDataReader dbDataReader, Action<int> recordsAffectedCallback)
{
IRecord record;
int recordsAffected;
int recordIndex = 0;
string key;
object value;
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetRecordsFromReader(...): enter", typeof(AdoNetStreamingFascade).Name));
if ((object)dbDataReader == null)
throw new ArgumentNullException(nameof(dbDataReader));
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetRecordsFromReader(...): before yield", typeof(AdoNetStreamingFascade).Name));
while (dbDataReader.Read())
{
record = new Record();
for (int columnIndex = 0; columnIndex < dbDataReader.FieldCount; columnIndex++)
{
key = dbDataReader.GetName(columnIndex);
value = dbDataReader.GetValue(columnIndex).ChangeType<object>();
if (record.ContainsKey(key) || (key ?? string.Empty).Length == 0)
key = string.Format("Column_{0:0000}", columnIndex);
record.Add(key, value);
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetRecordsFromReader(...): on yield", typeof(AdoNetStreamingFascade).Name));
yield return record; // LAZY PROCESSING INTENT HERE / DO NOT FORCE EAGER LOAD
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetRecordsFromReader(...): after yield", typeof(AdoNetStreamingFascade).Name));
recordsAffected = dbDataReader.RecordsAffected;
if ((object)recordsAffectedCallback != null)
recordsAffectedCallback(recordsAffected);
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetRecordsFromReader(...): leave", typeof(AdoNetStreamingFascade).Name));
}
public static void AddField <ResultType, InputType>(this Records.Records Records, System.String ResultFieldName, System.String InputFieldName, System.Func <InputType, ResultType> Action)
{
Records.Map(Record => Record.Add(ResultFieldName, Action(Record.Get <InputType>(InputFieldName))));
}
public static unsafe AsyncReply RecordParser(byte[] data, uint offset, uint length, DistributedConnection connection, uint[] requestSequence)
{
var reply = new AsyncReply <IRecord>();
var classId = data.GetGuid(offset);
offset += 16;
length -= 16;
var template = Warehouse.GetTemplateByClassId((Guid)classId, TemplateType.Record);
var initRecord = (TypeTemplate template) =>
{
ListParser(data, offset, length, connection, requestSequence).Then(r =>
{
var ar = (object[])r;
if (template.DefinedType != null)
{
var record = Activator.CreateInstance(template.DefinedType) as IRecord;
for (var i = 0; i < template.Properties.Length; i++)
{
try
{
var v = Convert.ChangeType(ar[i], template.Properties[i].PropertyInfo.PropertyType);
template.Properties[i].PropertyInfo.SetValue(record, v);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
reply.Trigger(record);
}
else
{
var record = new Record();
for (var i = 0; i < template.Properties.Length; i++)
{
record.Add(template.Properties[i].Name, ar[i]);
}
reply.Trigger(record);
}
});
};
if (template != null)
{
initRecord(template);
}
else
{
connection.GetTemplate((Guid)classId).Then(tmp =>
{
ListParser(data, offset, length, connection, requestSequence).Then(r =>
{
if (tmp == null)
{
reply.TriggerError(new AsyncException(ErrorType.Management, (ushort)ExceptionCode.TemplateNotFound,
"Template not found for record."));
}
else
{
initRecord(tmp);
}
});
}).Error(x => reply.TriggerError(x));
}
return(reply);
}
private void CreateNewRecord(enmActionType actionType, long timeStamp, List <SchemaInstrument> schemaInstruments, string value)
{
var currentRecord = Record.Last();
var milliseconds = (timeStamp <= 0 ? DateTimeOffset.Now.ToUnixTimeMilliseconds() : timeStamp);
var seconds = (milliseconds / 1000);
var previousRecord = Record.ElementAt(Record.Count == 1 ? 0 : Record.Count - 2);
currentRecord.TimeDiff = (previousRecord.Time == 0 ? 0 : milliseconds - previousRecord.Time);
currentRecord.Time = milliseconds;
if (!string.IsNullOrEmpty(value))
{
foreach (var instrument in schemaInstruments)
{
currentRecord.Values[instrument.Key] = value;
}
}
foreach (var formula in schemaFormulas)
{
formulaLib.ExecuteMethod(formula, Record);
}
var isNewRecord = false;
var isCorrect = false;
if (this.unit == enmUnit.ticks)
{
isNewRecord = schemaInstruments.Exists(x => x.Key == isNewRecordEventColumnName);
TempTimeValue += 1;
if (TempTimeValue >= this.unitValue)
{
isCorrect = true;
TempTimeValue = 0;
}
}
else if (this.unit == enmUnit.seconds)
{
isNewRecord = actionType == enmActionType.TimedEvent;
isCorrect = true;
var temp = seconds; // DateTimeOffset.Now.ToUnixTimeSeconds();
if ((temp - TempTimeValue) > this.unitValue || timeStamp != 0)
{
isCorrect = true;
TempTimeValue = seconds; // DateTimeOffset.Now.ToUnixTimeSeconds();
}
}
if (isNewRecord && isCorrect)
{
foreach (var instrument in transformInstruments)
{
formulaLib.TransformData(instrument, instruments, Record);
}
var regex = new Regex(Regex.Escape("X"));
foreach (var column in columns)
{
var temp = currentRecord.Values[column.Key];
if (string.IsNullOrEmpty(temp))
{
if (column.DataType == SchemaInstrument.enmDataType.@string)
{
currentRecord.Values[column.Key] = "-";
}
else
{
currentRecord.Values[column.Key] = "0";
}
}
else
{
currentRecord.Values["completed"] = regex.Replace(currentRecord.Values["completed"], "O", 1);
}
}
if (IGClient.StreamDisplay != enmContinuousDisplay.None && IGClient.StreamDisplay != enmContinuousDisplay.Subscription && IGClient.SchemaFilterName == schemaName)
{
var message = BaseCodeLibrary.GetDatasetRecord(currentRecord, instruments, (IGClient.StreamDisplay == enmContinuousDisplay.DatasetAllColumns), (IGClient.StreamDisplay == enmContinuousDisplay.Prediction));
if (string.IsNullOrEmpty(Filter) || message.ToLower().Contains(Filter.ToLower()))
{
M(enmMessageType.Info, message);
//Console.Write($"\r{currentRecord.Values["offer"]}");
}
}
if (Record.Count > 0)
{
var tempValues = new Dictionary <string, string>();
foreach (var instrument in schemaCaptures)
{
tempValues.Add(instrument.Key, currentRecord.Values[instrument.Key]);
}
currentRecord = NewRecord();
foreach (var tempValue in tempValues)
{
currentRecord.Values[tempValue.Key] = tempValue.Value;
}
Record.Add(currentRecord);
}
}
}
/*
* void xlog(string s)
* {
* Console.Write(s);
* if (el != null) el.WriteEntry(s);
* }
*/
public bool ImportFixed(StreamReader file, string format, StreamWriter log, string spname)
{
try
{
string[] fields = format.Split(';');
while (!file.EndOfStream)
{
string line = file.ReadLine();
int baseindex = 0;
Record r = new Record();
r.valid = false;
foreach (string fs in fields)
{
string[] f = fs.Split(',');
string fname = f[1];
int fsize = Convert.ToInt32(f[0]);
string value = line.Substring(baseindex, fsize);
baseindex += fsize;
if (fname != "ignore")
{
int outint;
int.TryParse(value.Trim(), out outint);
if (fname == "valid" && outint == 1)
{
r.valid = true;
r.Add(fname, value);
}
else
{
r.Add(fname, value);
}
}
}
r.error = "";
r.nomenclada = nomenclar(r);
if (!r.nomenclada)
{
if (r.error != "")
{
log.WriteLine(string.Format("{0},{1}", DateTime.Now, r.error));
}
if (!Insert(r, spname))
{
if (r.error != "")
{
log.WriteLine(string.Format("{0},{1}", DateTime.Now, r.error));
}
}
else
{
log.WriteLine(string.Format("{0},I-OK,{1}", DateTime.Now, r["custcode"]));
}
}
else
{
if (!Insert(r, spname))
{
if (r.error != "")
{
log.WriteLine(string.Format("{0},{1}", DateTime.Now, r.error));
}
}
else
{
log.WriteLine(string.Format("{0},NI-OK,{1}", DateTime.Now, r["custcode"]));
}
}
}
}
catch (Exception e)
{
log.WriteLine(String.Format("Excepcion procesando archivo:{0}", e.ToString()));
return(false);
}
return(true);
}
/// <summary>
/// Parses a dictinary <content> element and returns a record
/// object containing the parsed values.
/// </summary>
/// <param name="element">An XML element.</param>
/// <returns>The record.</returns>
internal Record ParseDict(XmlElement element)
{
Trace.Assert(element.Name.Equals("s:dict"));
if (element.FirstChild == null)
{
return null;
}
List<XmlElement> children = GetChildElements(element);
int count = children.Count;
if (count == 0)
{
return null;
}
Record result = new Record();
foreach (XmlElement child in children)
{
Trace.Assert(child.Name.Equals("s:key"));
string key = child.GetAttribute("name");
object value = this.ParseValue(child);
if (value != null)
{
result.Add(key, value);
}
}
return result;
}
public static void AddField <Type>(this Records.Records Records, System.String FieldName, Type FieldValue)
{
Records.Map(Record => Record.Add(FieldName, FieldValue));
}
/// <summary>
/// Execute a command against a data source, mapping the data reader GetSchemaTable() result to an enumerable of record dictionaries.
/// This method perfoms LAZY LOADING/DEFERRED EXECUTION.
/// Note that THE DATA READER WILL NOT BE DISPOSED UPON ENUMERATION OR FOREACH BRANCH OUT.
/// </summary>
/// <param name="dataReader"> The target data reader. </param>
/// <param name="recordsAffectedCallback"> Executed when the output count of records affected is available to return (post enumeration). </param>
/// <returns> An enumerable of record dictionary instances, containing key/value pairs of schema metadata. </returns>
public IEnumerable<IRecord> GetSchemaRecordsFromReader(IDataReader dataReader, Action<int> recordsAffectedCallback)
{
IRecord record;
int recordsAffected;
string key;
object value;
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): enter", typeof(AdoNetYieldingFascade).Name));
if ((object)dataReader == null)
throw new ArgumentNullException("dataReader");
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): before yield", typeof(AdoNetYieldingFascade).Name));
using (DataTable dataTable = dataReader.GetSchemaTable())
{
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): use table", typeof(AdoNetYieldingFascade).Name));
if ((object)dataTable != null)
{
foreach (DataRow dataRow in dataTable.Rows)
{
record = new Record();
for (int index = 0; index < dataTable.Columns.Count; index++)
{
key = dataTable.Columns[index].ColumnName;
value = dataRow[index].ChangeType<object>();
record.Add(key, value);
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): on yield", typeof(AdoNetYieldingFascade).Name));
yield return record; // LAZY PROCESSING INTENT HERE / DO NOT FORCE EAGER LOAD
}
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): dispose table", typeof(AdoNetYieldingFascade).Name));
}
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): after yield", typeof(AdoNetYieldingFascade).Name));
recordsAffected = dataReader.RecordsAffected;
if ((object)recordsAffectedCallback != null)
recordsAffectedCallback(recordsAffected);
OnlyWhen._PROFILE_ThenPrint(string.Format("{0}::GetSchemaRecordsFromReader(...): leave", typeof(AdoNetYieldingFascade).Name));
}
