CoreTable.cs 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Data;
  5. using System.Linq;
  6. using System.Linq.Expressions;
  7. using System.Net.Http.Headers;
  8. using System.Reflection;
  9. namespace InABox.Core
  10. {
  11. [Serializable]
  12. public class CoreTable : ICoreTable, ISerializeBinary //: IEnumerable, INotifyCollectionChanged
  13. {
  14. #region Fields
  15. private List<CoreRow>? rows;
  16. private List<CoreColumn> columns = new List<CoreColumn>();
  17. private string tableName;
  18. #endregion
  19. #region Properties
  20. public string TableName { get => tableName; }
  21. public int TotalRecords { get; set; }
  22. public int Offset { get; set; } = 0;
  23. public IList<CoreColumn> Columns { get => columns; }
  24. public IList<CoreRow> Rows
  25. {
  26. get
  27. {
  28. rows ??= new List<CoreRow>();
  29. //this.rows.CollectionChanged += OnRowsCollectionChanged;
  30. return rows;
  31. }
  32. }
  33. [field: NonSerialized]
  34. public IList<Func<object, object?>?> Getters { get; } = new List<Func<object, object?>?>();
  35. [field: NonSerialized]
  36. public Dictionary<string, IList<Action<object, object>?>> Setters { get; } = new Dictionary<string, IList<Action<object, object>?>>();
  37. #endregion
  38. public CoreTable() : this("")
  39. {
  40. }
  41. public CoreTable(string tableName): base()
  42. {
  43. this.tableName = tableName;
  44. }
  45. public CoreTable(Type type) : this()
  46. {
  47. LoadColumns(type);
  48. }
  49. public void AddColumn<T>(Expression<Func<T, object>> column)
  50. {
  51. Columns.Add(
  52. new CoreColumn()
  53. {
  54. ColumnName = CoreUtils.GetFullPropertyName(column, "."),
  55. DataType = column.ReturnType
  56. }
  57. );
  58. }
  59. public CoreRow NewRow(bool populate = false)
  60. {
  61. var result = new CoreRow(this);
  62. if (populate)
  63. foreach (var column in Columns)
  64. result[column.ColumnName] = column.DataType.GetDefault();
  65. return result;
  66. }
  67. public void LoadColumns(Type T)
  68. {
  69. var iprops = DatabaseSchema.Properties(T);
  70. foreach (var iprop in iprops)
  71. Columns.Add(new CoreColumn { ColumnName = iprop.Name, DataType = iprop.PropertyType });
  72. }
  73. public void LoadColumns(IColumns columns)
  74. {
  75. foreach (var col in columns)
  76. Columns.Add(new CoreColumn { ColumnName = col.Property, DataType = col.Type });
  77. }
  78. public void LoadColumns(IEnumerable<CoreColumn> columns)
  79. {
  80. Columns.Clear();
  81. foreach (var col in columns)
  82. Columns.Add(new CoreColumn() { ColumnName = col.ColumnName, DataType = col.DataType });
  83. }
  84. /// <summary>
  85. /// Add the rows from the given <paramref name="table"/> to this table.
  86. /// </summary>
  87. /// <remarks>
  88. /// This method assumes that the columns of this table and <paramref name="table"/> are the same; it is intended for paging functionality.
  89. /// </remarks>
  90. /// <param name="table"></param>
  91. public void AddPage(CoreTable table)
  92. {
  93. foreach(var row in table.Rows)
  94. {
  95. var newRow = NewRow(populate: false);
  96. newRow.LoadValues(row.Values);
  97. Rows.Add(newRow);
  98. }
  99. }
  100. public void LoadRows(IEnumerable<object> objects)
  101. {
  102. foreach (var obj in objects)
  103. {
  104. LoadRow(obj);
  105. }
  106. }
  107. public void LoadRows(IEnumerable<CoreRow> rows)
  108. {
  109. foreach (var row in rows)
  110. {
  111. var newrow = NewRow();
  112. FillRow(newrow, row);
  113. Rows.Add(newrow);
  114. }
  115. }
  116. public void LoadFrom<T1, T2>(CoreTable table, CoreFieldMap<T1, T2> mappings, Action<CoreRow>? customization = null)
  117. {
  118. foreach (var row in table.Rows)
  119. {
  120. var newrow = NewRow();
  121. foreach (var map in mappings.Fields)
  122. newrow.Set(map.To, row.Get(map.From));
  123. customization?.Invoke(newrow);
  124. Rows.Add(newrow);
  125. }
  126. }
  127. public void FillRow(CoreRow row, object obj)
  128. {
  129. var bFirst = Getters.Count == 0;
  130. for(var i = 0; i < Columns.Count; ++i)
  131. {
  132. try
  133. {
  134. if (bFirst)
  135. {
  136. var prop = DatabaseSchema.Property(obj.GetType(), Columns[i].ColumnName);
  137. Getters.Add(prop?.Getter());
  138. }
  139. var getter = Getters[i];
  140. if (getter != null)
  141. row.Set(i, getter(obj));
  142. else
  143. row.Set(i, CoreUtils.GetPropertyValue(obj, Columns[i].ColumnName));
  144. }
  145. catch (Exception e)
  146. {
  147. Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
  148. }
  149. }
  150. }
  151. public void FillRow(CoreRow row, CoreRow from)
  152. {
  153. foreach (var col in Columns)
  154. try
  155. {
  156. if (from.Table.Columns.Any(x => x.ColumnName.Equals(col.ColumnName)))
  157. row[col.ColumnName] = from[col.ColumnName];
  158. }
  159. catch (Exception e)
  160. {
  161. Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
  162. }
  163. }
  164. public void Filter(Func<CoreRow, bool> predicate)
  165. {
  166. for (var i = Rows.Count - 1; i > -1; i--)
  167. {
  168. var row = Rows[i];
  169. var predresult = predicate.Invoke(row);
  170. if (!predresult)
  171. Rows.Remove(row);
  172. }
  173. }
  174. #region ToDictionary
  175. public IDictionary ToDictionary(string keycol, string displaycol, string sortcol = "")
  176. {
  177. var kc = Columns.FirstOrDefault(x => x.ColumnName.Equals(keycol));
  178. var dc = Columns.FirstOrDefault(x => x.ColumnName.Equals(displaycol));
  179. var dt = typeof(Dictionary<,>).MakeGenericType(kc.DataType, dc.DataType);
  180. var id = (Activator.CreateInstance(dt) as IDictionary)!;
  181. var sorted = string.IsNullOrWhiteSpace(sortcol) ? Rows : Rows.OrderBy(x => x.Get<object>(sortcol)).ToList();
  182. foreach (var row in sorted)
  183. id[row[keycol]] = row[displaycol];
  184. return id;
  185. }
  186. public Dictionary<TKey, TValue> ToDictionary<T, TKey, TValue>(Expression<Func<T, TKey>> key, Expression<Func<T, TValue>> value,
  187. Expression<Func<T, object>>? sort = null)
  188. {
  189. var result = new Dictionary<TKey, TValue>();
  190. var sorted = sort == null ? Rows : Rows.OrderBy(x => x.Get(sort)).ToList();
  191. foreach (var row in Rows)
  192. result[row.Get(key)] = row.Get(value);
  193. return result;
  194. }
  195. public Dictionary<TKey, string> ToDictionary<T, TKey>(Expression<Func<T, TKey>> key, Expression<Func<T, object>>[] values,
  196. Expression<Func<T, object>>? sort = null)
  197. {
  198. var result = new Dictionary<TKey, string>();
  199. var sorted = sort == null ? Rows : Rows.OrderBy(x => x.Get(sort)).ToList();
  200. foreach (var row in Rows)
  201. {
  202. var display = new List<object>();
  203. foreach (var value in values)
  204. display.Add(row.Get(value));
  205. result[row.Get(key)] = string.Join(" : ", display);
  206. }
  207. return result;
  208. }
  209. public Dictionary<TKey, TValue> ToDictionary<T, TKey, TValue>(Expression<Func<T, TKey>> key, Func<CoreRow, TValue> value,
  210. Expression<Func<T, object>>? sort = null)
  211. {
  212. var result = new Dictionary<TKey, TValue>();
  213. var sorted = sort == null ? Rows : Rows.OrderBy(x => x.Get(sort)).ToList();
  214. foreach (var row in Rows)
  215. result[row.Get(key)] = value(row);
  216. return result;
  217. }
  218. public void LoadDictionary<T, TKey, TValue>(Dictionary<TKey, TValue> dictionary, Expression<Func<T, TKey>> key,
  219. Expression<Func<T, TValue>> value)
  220. {
  221. foreach (var row in Rows)
  222. dictionary[row.Get(key)] = row.Get(value);
  223. }
  224. public Dictionary<TKey, string> IntoDictionary<T, TKey>(Dictionary<TKey, string> result, Expression<Func<T, TKey>> key,
  225. params Expression<Func<T, object>>[] values)
  226. {
  227. foreach (var row in Rows)
  228. {
  229. var display = new List<object>();
  230. foreach (var value in values)
  231. display.Add(row.Get(value));
  232. result[row.Get(key)] = string.Join(" : ", display);
  233. }
  234. return result;
  235. }
  236. public Dictionary<TKey, TValue> IntoDictionary<T, TKey, TValue>(Dictionary<TKey, TValue> result, Expression<Func<T, TKey>> key,
  237. Func<CoreRow, TValue> value)
  238. {
  239. foreach (var row in Rows)
  240. result[row.Get(key)] = value(row);
  241. return result;
  242. }
  243. #endregion
  244. public DataTable ToDataTable(string name = "", IColumns? additionalColumns = null)
  245. {
  246. var result = new DataTable(name);
  247. foreach (var column in Columns)
  248. result.Columns.Add(column.ColumnName.Replace('.', '_'), column.DataType);
  249. if(additionalColumns != null)
  250. {
  251. foreach (var column in additionalColumns)
  252. result.Columns.Add(column.Property.Replace('.', '_'), column.Type);
  253. }
  254. //result.Columns["ID"].Unique = true;
  255. //result.PrimaryKey = new DataColumn[] { result.Columns["ID"] };
  256. foreach (var row in Rows)
  257. {
  258. //result.Rows.Add(row.Values.ToArray());
  259. var newrow = result.NewRow();
  260. newrow.ItemArray = row.Values.ToArray();
  261. result.Rows.Add(newrow);
  262. }
  263. return result;
  264. }
  265. #region ToObjects
  266. public IEnumerable<BaseObject> ToObjects(Type T)
  267. => Rows.Select(x => x.ToObject(T));
  268. public IEnumerable<T> ToObjects<T>() where T : BaseObject, new()
  269. => Rows.Select(x => x.ToObject<T>());
  270. public List<T> ToList<T>() where T : BaseObject, new()
  271. {
  272. var list = new List<T>(Rows.Count);
  273. for(int i = 0; i < Rows.Count; ++i)
  274. {
  275. list.Add(Rows[i].ToObject<T>());
  276. }
  277. return list;
  278. }
  279. public T[] ToArray<T>() where T : BaseObject, new()
  280. {
  281. var arr = new T[Rows.Count];
  282. for(int i = 0; i < Rows.Count; ++i)
  283. {
  284. arr[i] = Rows[i].ToObject<T>();
  285. }
  286. return arr;
  287. }
  288. #endregion
  289. #region ToTuples
  290. public IEnumerable<Tuple<T1, T2>> ToTuples<TType, T1, T2>(
  291. Expression<Func<TType, T1>> item1,
  292. Expression<Func<TType, T2>> item2
  293. )
  294. {
  295. return Rows.Select(row =>
  296. new Tuple<T1, T2>
  297. (
  298. row.Get<TType,T1>(item1),
  299. row.Get<TType,T2>(item2)
  300. )
  301. );
  302. }
  303. public IEnumerable<Tuple<T1, T2, T3>> ToTuples<TType, T1, T2, T3>(
  304. Expression<Func<TType, T1>> item1,
  305. Expression<Func<TType, T2>> item2,
  306. Expression<Func<TType, T3>> item3)
  307. {
  308. return Rows.Select(row =>
  309. new Tuple<T1, T2, T3>
  310. (
  311. row.Get<TType,T1>(item1),
  312. row.Get<TType,T2>(item2),
  313. row.Get<TType,T3>(item3)
  314. )
  315. );
  316. }
  317. public IEnumerable<Tuple<T1, T2, T3, T4>> ToTuples<TType, T1, T2, T3, T4>(
  318. Expression<Func<TType, T1>> item1,
  319. Expression<Func<TType, T2>> item2,
  320. Expression<Func<TType, T3>> item3,
  321. Expression<Func<TType, T4>> item4
  322. )
  323. {
  324. return Rows.Select(row =>
  325. new Tuple<T1, T2, T3, T4>
  326. (
  327. row.Get<TType,T1>(item1),
  328. row.Get<TType,T2>(item2),
  329. row.Get<TType,T3>(item3),
  330. row.Get<TType,T4>(item4)
  331. )
  332. );
  333. }
  334. public IEnumerable<Tuple<T1, T2, T3, T4, T5>> ToTuples<TType, T1, T2, T3, T4, T5>(
  335. Expression<Func<TType, T1>> item1,
  336. Expression<Func<TType, T2>> item2,
  337. Expression<Func<TType, T3>> item3,
  338. Expression<Func<TType, T4>> item4,
  339. Expression<Func<TType, T5>> item5
  340. )
  341. {
  342. return Rows.Select(row =>
  343. new Tuple<T1, T2, T3, T4,T5>
  344. (
  345. row.Get<TType,T1>(item1),
  346. row.Get<TType,T2>(item2),
  347. row.Get<TType,T3>(item3),
  348. row.Get<TType,T4>(item4),
  349. row.Get<TType,T5>(item5)
  350. )
  351. );
  352. }
  353. #endregion
  354. public void CopyTo(DataTable table)
  355. {
  356. var columns = new List<string>();
  357. foreach (var column in Columns)
  358. columns.Add(column.ColumnName.Replace('.', '_'));
  359. foreach (var row in Rows)
  360. {
  361. var newrow = table.NewRow();
  362. for (var i = 0; i < columns.Count; i++)
  363. newrow[columns[i]] = row.Values[i];
  364. table.Rows.Add(newrow);
  365. }
  366. }
  367. public void CopyTo(CoreTable table)
  368. {
  369. var columns = new List<string>();
  370. //foreach (var column in Columns)
  371. // columns.Add(column.ColumnName.Replace('.', '_'));
  372. foreach (var row in Rows)
  373. {
  374. var newrow = table.NewRow();
  375. foreach (var column in Columns)
  376. if (table.Columns.Any(x => x.ColumnName.Equals(column.ColumnName)))
  377. newrow[column.ColumnName] = row[column.ColumnName];
  378. //for (int i = 0; i < columns.Count; i++)
  379. // newrow.Set(columns[i], row.Values[i]);
  380. table.Rows.Add(newrow);
  381. }
  382. }
  383. #region Extract Values
  384. public IEnumerable<TValue> ExtractValues<TSource, TValue>(Expression<Func<TSource, TValue>> column, bool distinct = true)
  385. {
  386. var result = Rows.Select(r => r.Get(column));
  387. if (distinct)
  388. result = result.Distinct();
  389. return result;
  390. }
  391. public IEnumerable<TValue> ExtractValues<TValue>(string column, bool distinct = true)
  392. {
  393. var result = Rows.Select(r => r.Get<TValue>(column));
  394. if (distinct)
  395. result = result.Distinct();
  396. return result;
  397. }
  398. #endregion
  399. /// <summary>
  400. /// Create a new row with data from <paramref name="obj"/>, and adds it to the table.
  401. /// </summary>
  402. /// <param name="obj"></param>
  403. /// <returns></returns>
  404. public CoreTable LoadRow(object obj)
  405. {
  406. var row = NewRow();
  407. FillRow(row, obj);
  408. Rows.Add(row);
  409. return this;
  410. }
  411. public int GetColumnIndex<T>(Expression<Func<T, object>> column)
  412. => GetColumnIndex(CoreUtils.GetFullPropertyName(column, "."));
  413. public int GetColumnIndex(string columnname)
  414. {
  415. for (var i = 0; i < Columns.Count; i++)
  416. if (Columns[i].ColumnName.Equals(columnname))
  417. {
  418. return i;
  419. }
  420. return -1;
  421. }
  422. #region ToLookup
  423. public IEnumerable<IGrouping<TKey, TValue>> ToGroups<T, TKey, TValue>(Expression<Func<T, TKey>> key,
  424. Expression<Func<T, TValue>> value)
  425. {
  426. return Rows.GroupBy(r => r.Get(key), r => r.Get(value));
  427. }
  428. public IMutableLookup<TKey, TValue> ToLookup<T, TKey, TValue>(Expression<Func<T, TKey>> key, Expression<Func<T, TValue>> value,
  429. Expression<Func<T, object>>? sort = null)
  430. {
  431. IMutableLookup<TKey, TValue> result = new MutableLookup<TKey, TValue>(
  432. Rows.ToLookup(
  433. r => r.Get(key),
  434. r => r.Get(value)
  435. )
  436. );
  437. return result;
  438. }
  439. public IMutableLookup<TKey, TValue> ToLookup<T, TKey, TValue>(Expression<Func<T, TKey>> key, Func<CoreRow, TValue> value,
  440. Expression<Func<T, object>>? sort = null)
  441. {
  442. IMutableLookup<TKey, TValue> result = new MutableLookup<TKey, TValue>(
  443. Rows.ToLookup(
  444. r => r.Get(key),
  445. r => value(r)
  446. )
  447. );
  448. return result;
  449. }
  450. #endregion
  451. #region Serialize Binary
  452. public void WriteBinary(CoreBinaryWriter writer, bool includeColumns)
  453. {
  454. writer.Write(TableName);
  455. if (includeColumns)
  456. {
  457. foreach (var column in Columns)
  458. {
  459. writer.Write(true);
  460. writer.Write(column.ColumnName);
  461. writer.Write(column.DataType.EntityName());
  462. }
  463. writer.Write(false);
  464. }
  465. writer.Write(Rows.Count);
  466. foreach (var row in Rows)
  467. {
  468. foreach (var col in Columns)
  469. {
  470. var val = row[col.ColumnName];
  471. writer.WriteBinaryValue(col.DataType, val);
  472. }
  473. }
  474. }
  475. public void SerializeBinary(CoreBinaryWriter writer) => WriteBinary(writer, true);
  476. public void ReadBinary(CoreBinaryReader reader, IList<CoreColumn>? columns)
  477. {
  478. tableName = reader.ReadString();
  479. Columns.Clear();
  480. if (columns is null)
  481. {
  482. while (reader.ReadBoolean())
  483. {
  484. var columnName = reader.ReadString();
  485. var dataType = CoreUtils.GetEntity(reader.ReadString());
  486. Columns.Add(new CoreColumn(dataType, columnName));
  487. }
  488. }
  489. else
  490. {
  491. foreach (var column in columns)
  492. {
  493. Columns.Add(column);
  494. }
  495. }
  496. Rows.Clear();
  497. var nRows = reader.ReadInt32();
  498. for (int i = 0; i < nRows; ++i)
  499. {
  500. var row = NewRow();
  501. foreach (var column in Columns)
  502. {
  503. var value = reader.ReadBinaryValue(column.DataType);
  504. row.Values.Add(value);
  505. }
  506. Rows.Add(row);
  507. }
  508. }
  509. public void DeserializeBinary(CoreBinaryReader reader) => ReadBinary(reader, null);
  510. #endregion
  511. }
  512. }