RestClient.cs 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613
  1. using System.IO.Compression;
  2. using System.Net;
  3. using InABox.Core;
  4. using RestSharp;
  5. using System;
  6. using System.Collections.Generic;
  7. using System.IO;
  8. using System.Linq;
  9. using System.Threading.Tasks;
  10. namespace InABox.Clients
  11. {
  12. public static class StaticRestClients
  13. {
  14. public static Dictionary<string, RestClient> Clients = new Dictionary<string, RestClient>();
  15. public static RestClient GetClient(string url)
  16. {
  17. var uri = new Uri(url);
  18. if (!Clients.TryGetValue(url, out var cli))
  19. {
  20. cli = new RestClient(uri);
  21. Clients.Add(url, cli);
  22. }
  23. return cli;
  24. }
  25. }
  26. public class RestClient<TEntity> : BaseClient<TEntity> where TEntity : Entity, new()
  27. {
  28. private bool _simpleencryption;
  29. private string _server;
  30. private bool _compression;
  31. private BinarySerializationSettings _binarysettings;
  32. public RestClient(string server, bool useSimpleEncryption, bool compression, BinarySerializationSettings binarySerializationSettings)
  33. {
  34. _server = server;
  35. _simpleencryption = useSimpleEncryption;
  36. _compression = compression;
  37. _binarysettings = binarySerializationSettings;
  38. RestClientCache.Check(server);
  39. }
  40. public RestClient(string server, bool simpleencryption, bool compression) : this(server, simpleencryption, compression, BinarySerializationSettings.Latest)
  41. {
  42. }
  43. public RestClient(string server, bool simpleencryption) : this(server, simpleencryption, false)
  44. {
  45. }
  46. public RestClient(string server) : this(server, false)
  47. {
  48. }
  49. public override bool IsConnected() => true;
  50. public static string Ping(string[] urls, out DatabaseInfo info)
  51. {
  52. var result = "";
  53. info = new DatabaseInfo();
  54. List<Task<Tuple<string,DatabaseInfo>>> pings = urls.Select(x => Task.Run(
  55. () => new Tuple<string, DatabaseInfo>(x, new RestClient<User>(x).Info())
  56. )).ToList();
  57. while (pings.Count > 0)
  58. {
  59. var ping = Task.WhenAny(pings).Result;
  60. if (ping.Status == TaskStatus.RanToCompletion && !string.IsNullOrWhiteSpace(ping.Result.Item2.Version))
  61. {
  62. result = ping.Result.Item1;
  63. info = ping.Result.Item2;
  64. break;
  65. }
  66. else
  67. pings.Remove(ping);
  68. }
  69. return result;
  70. }
  71. private void PrepareRequest(Request request)
  72. {
  73. request.Credentials.Platform = ClientFactory.Platform;
  74. request.Credentials.Version = ClientFactory.Version;
  75. request.Credentials.Session = ClientFactory.SessionID;
  76. Request.BeforeRequest?.Invoke(request);
  77. }
  78. protected override IValidationData DoValidate(Guid session = default)
  79. {
  80. return Validate(
  81. null, null, false, session);
  82. }
  83. protected override IValidationData DoValidate(string pin, Guid session = default)
  84. {
  85. return Validate(
  86. null, pin, true, session);
  87. }
  88. protected override IValidationData DoValidate(string userid, string password, Guid session = default)
  89. {
  90. return Validate(
  91. userid, password, false, session);
  92. }
  93. private IValidationData Validate(string? userid, string? password, bool usePin, Guid session = default)
  94. {
  95. var ticks = DateTime.Now.ToUniversalTime().Ticks.ToString();
  96. var request = new ValidateRequest();
  97. request.UsePIN = usePin;
  98. if (usePin)
  99. {
  100. request.UserID = Encryption.Encrypt(ticks, "wCq9rryEJEuHIifYrxRjxg", _simpleencryption);
  101. request.Password = Encryption.Encrypt(ticks, "7mhvLnqMwkCAzN+zNGlyyg", _simpleencryption);
  102. request.PIN = password;
  103. }
  104. else
  105. {
  106. request.UserID = userid;
  107. request.Password = password;
  108. }
  109. PrepareRequest(request);
  110. if (session != Guid.Empty)
  111. {
  112. request.Credentials.Session = session;
  113. }
  114. var response = SendRequest<ValidateRequest, ValidateResponse>(request, "validate", SerializationFormat.Binary, SerializationFormat.Binary, false);
  115. if (response != null)
  116. if (response.Status.Equals(StatusCode.OK))
  117. {
  118. PasswordCache.Password = password;
  119. return new ValidationData(
  120. response.ValidationStatus,
  121. response.UserID,
  122. response.UserGuid,
  123. response.SecurityID,
  124. response.Session,
  125. response.Recipient2FA,
  126. response.PasswordExpiration
  127. );
  128. }
  129. else if(response.Status == StatusCode.BadServer)
  130. {
  131. throw new RemoteException(response.Messages, request);
  132. }
  133. return new ValidationData(
  134. ValidationStatus.INVALID,
  135. "",
  136. Guid.Empty,
  137. Guid.Empty,
  138. Guid.Empty,
  139. null,
  140. DateTime.MinValue
  141. );
  142. }
  143. protected TResponse SendRequest<TRequest, TResponse>(TRequest request, string Action, SerializationFormat requestFormat, SerializationFormat responseFormat, bool includeEntity = true)
  144. where TRequest : Request where TResponse : Response, new()
  145. {
  146. var result = default(TResponse);
  147. var url = RestClientCache.URL(_server);
  148. if (string.IsNullOrEmpty(url))
  149. {
  150. result = (TResponse)Activator.CreateInstance(typeof(TResponse));
  151. result.Status = StatusCode.BadServer;
  152. result.Messages.Add("Server URL not set!");
  153. return result;
  154. }
  155. var cli = StaticRestClients.GetClient(url);
  156. var cmd = string.Format(
  157. "{0}{1}?format={2}&responseFormat={3}&serializationVersion={4}",
  158. Action,
  159. includeEntity ? typeof(TEntity).Name : "",
  160. requestFormat,
  161. responseFormat,
  162. _binarysettings.Version
  163. );
  164. var req = new RestRequest(cmd, Method.Post)
  165. {
  166. Timeout = Timeout.Milliseconds,
  167. };
  168. //Log(" * {0}{1}() Creating Uri, Client and RestRequest took {2}ms", Action, typeof(TEntity).Name, sw.ElapsedMilliseconds);
  169. //sw.Restart();
  170. //req.AdvancedResponseWriter = (stream, response) =>
  171. //{
  172. // //Log(" * {0}{1}() Response from Server took {2}ms ({3} bytes)", Action, typeof(TEntity).Name, sw.ElapsedMilliseconds, response.ContentLength);
  173. // //length = response.ContentLength;
  174. // //sw.Restart();
  175. // try
  176. // {
  177. // if (responseFormat == SerializationFormat.Binary && typeof(TResponse).HasInterface<ISerializeBinary>())
  178. // {
  179. // result = (TResponse)Serialization.ReadBinary(typeof(TResponse), stream, _binarysettings);
  180. // }
  181. // else
  182. // {
  183. // result = Serialization.Deserialize<TResponse>(stream, true);
  184. // }
  185. // }
  186. // catch (Exception e)
  187. // {
  188. // Logger.Send(LogType.Information, "", $"Error deserializing response: {e.Message}");
  189. // }
  190. // //Log(" * {0}{1}() Deserializing Stream took {2}ms ({3} bytes)", Action, typeof(TEntity).Name, sw.ElapsedMilliseconds, response.ContentLength);
  191. //};
  192. if(requestFormat == SerializationFormat.Binary && request is ISerializeBinary binary)
  193. {
  194. var data = binary.WriteBinary(_binarysettings);
  195. req.AddOrUpdateParameter("application/octet-stream", data, ParameterType.RequestBody);
  196. req.RequestFormat = DataFormat.None;
  197. }
  198. else
  199. {
  200. var json = Serialization.Serialize(request);
  201. req.AddOrUpdateParameter("application/json", json, ParameterType.RequestBody);
  202. req.RequestFormat = DataFormat.Json;
  203. }
  204. try
  205. {
  206. //sw.Restart();
  207. var res = cli.Execute(req);
  208. //Log(" * {0}{1}() returns {2} bytes in {3}ms", Action, typeof(TEntity).Name, res.ContentLength, sw.ElapsedMilliseconds);
  209. if (result == null)
  210. {
  211. if (res.ErrorException == null)
  212. {
  213. if (res.StatusCode != HttpStatusCode.OK)
  214. throw new Exception(String.Format("HTTP Request returns {0} {1}" + (int)res.StatusCode, CoreUtils.SplitCamelCase(res.StatusCode.ToString())));
  215. try
  216. {
  217. Stream stream;
  218. if (_compression)
  219. {
  220. //sw.Restart();
  221. var comp = Serialization.Deserialize<CompressedResponse>(res.Content, true);
  222. var bytes = Convert.FromBase64String(comp.Response);
  223. var ms = new MemoryStream(bytes);
  224. stream = new MemoryStream();
  225. using (var decompressionStream = new DeflateStream(ms, CompressionMode.Decompress))
  226. {
  227. decompressionStream.CopyTo(stream);
  228. }
  229. }
  230. else
  231. {
  232. stream = new MemoryStream(res.RawBytes);
  233. }
  234. if (responseFormat == SerializationFormat.Binary && typeof(TResponse).HasInterface<ISerializeBinary>())
  235. {
  236. result = (TResponse)Serialization.ReadBinary(typeof(TResponse), stream, _binarysettings);
  237. }
  238. else
  239. {
  240. result = Serialization.Deserialize<TResponse>(stream, true);
  241. }
  242. stream.Dispose();
  243. }
  244. catch (Exception eDeserialize)
  245. {
  246. throw new Exception(string.Format("Unable to deserialize response!\n\n{0}\n\n{1}", eDeserialize.Message, res.Content));
  247. }
  248. }
  249. else
  250. {
  251. // Connectivity
  252. result = new TResponse();
  253. result.Status = StatusCode.BadServer;
  254. result.Messages.Add(res.ErrorMessage);
  255. }
  256. }
  257. }
  258. catch (Exception err)
  259. {
  260. result = new TResponse();
  261. result.Status = StatusCode.BadServer;
  262. result.Messages.Add(err.Message);
  263. if (err.InnerException != null)
  264. result.Messages.Add("- " + err.InnerException.Message);
  265. }
  266. return result;
  267. }
  268. #region Query Data
  269. protected override CoreTable DoQuery(Filter<TEntity>? filter, Columns<TEntity>? columns, SortOrder<TEntity>? sort = null)
  270. {
  271. var request = new QueryRequest<TEntity>(filter, columns, sort);
  272. PrepareRequest(request);
  273. var response = SendRequest<QueryRequest<TEntity>, QueryResponse<TEntity>>(request, "List", SerializationFormat.Binary, SerializationFormat.Binary);
  274. if (response != null)
  275. {
  276. return response.Status switch
  277. {
  278. StatusCode.OK => response.Items,
  279. StatusCode.Unauthenticated => throw new RemoteException("Client not authenticated", StatusCode.Unauthenticated, request),
  280. _ => throw new RemoteException(response.Messages, request),
  281. };
  282. }
  283. return null;
  284. //throw new Exception("Response is null");
  285. }
  286. #endregion
  287. #region Load
  288. protected override TEntity[] DoLoad(Filter<TEntity>? filter = null, SortOrder<TEntity>? sort = null)
  289. {
  290. var result = new List<TEntity>();
  291. var request = new QueryRequest<TEntity>(filter, null, sort);
  292. PrepareRequest(request);
  293. var response = SendRequest<QueryRequest<TEntity>, QueryResponse<TEntity>>(request, "List", SerializationFormat.Binary, SerializationFormat.Binary);
  294. if (response.Items != null)
  295. foreach (var row in response.Items.Rows)
  296. result.Add(row.ToObject<TEntity>());
  297. return result.ToArray();
  298. }
  299. #endregion
  300. #region MultipleTables
  301. protected override Dictionary<string, CoreTable> DoQueryMultiple(Dictionary<string, IQueryDef> queries)
  302. {
  303. var request = new MultiQueryRequest();
  304. foreach (var item in queries)
  305. {
  306. request.AddQuery(item.Key, item.Value);
  307. }
  308. PrepareRequest(request);
  309. var response = SendRequest<MultiQueryRequest, MultiQueryResponse>(request, "QueryMultiple", SerializationFormat.Binary, SerializationFormat.Binary, false);
  310. if (response != null)
  311. {
  312. return response.Status switch
  313. {
  314. StatusCode.OK => response.Tables,
  315. StatusCode.Unauthenticated => throw new RemoteException("Client not authenticated", request),
  316. _ => throw new RemoteException(response.Messages, request),
  317. };
  318. }
  319. return null;
  320. //throw new Exception("Response is null");
  321. }
  322. #endregion
  323. #region Save
  324. protected override void DoSave(TEntity entity, string auditnote)
  325. {
  326. var request = new SaveRequest<TEntity>(entity, auditnote);
  327. request.ReturnOnlyChanged = true;
  328. PrepareRequest(request);
  329. var response = SendRequest<SaveRequest<TEntity>, SaveResponse<TEntity>>(request, "Save", SerializationFormat.Binary, SerializationFormat.Binary);
  330. switch (response.Status)
  331. {
  332. case StatusCode.OK:
  333. /*var props = CoreUtils.PropertyList(typeof(TEntity), x => true, true);
  334. entity.SetObserving(false);
  335. foreach (var prop in props.Keys)
  336. {
  337. var value = CoreUtils.GetPropertyValue(response.Item, prop);
  338. CoreUtils.SetPropertyValue(entity, prop, value);
  339. }
  340. entity.CommitChanges();
  341. entity.SetObserving(true);*/
  342. entity.SetObserving(false);
  343. foreach (var (key, value) in response.ChangedValues)
  344. {
  345. if(CoreUtils.TryGetProperty<TEntity>(key, out var property))
  346. {
  347. CoreUtils.SetPropertyValue(entity, key, CoreUtils.ChangeType(value, property.PropertyType));
  348. }
  349. }
  350. entity.CommitChanges();
  351. entity.SetObserving(true);
  352. break;
  353. case StatusCode.Unauthenticated:
  354. throw new RemoteException("Client not authenticated", request);
  355. default:
  356. throw new RemoteException(response.Messages, request);
  357. }
  358. }
  359. protected override void DoSave(IEnumerable<TEntity> entities, string auditnote)
  360. {
  361. var items = entities.ToArray();
  362. var request = new MultiSaveRequest<TEntity>(items, auditnote);
  363. request.ReturnOnlyChanged = true;
  364. PrepareRequest(request);
  365. var response = SendRequest<MultiSaveRequest<TEntity>, MultiSaveResponse<TEntity>>(request, "MultiSave", SerializationFormat.Binary, SerializationFormat.Binary);
  366. switch (response.Status)
  367. {
  368. case StatusCode.OK:
  369. for(int i = 0; i < items.Length; ++i)
  370. {
  371. var entity = items[i];
  372. var changedValues = response.ChangedValues[i];
  373. entity.SetObserving(false);
  374. foreach (var (key, value) in changedValues)
  375. {
  376. if (CoreUtils.TryGetProperty<TEntity>(key, out var property))
  377. {
  378. CoreUtils.SetPropertyValue(entity, key, CoreUtils.ChangeType(value, property.PropertyType));
  379. }
  380. }
  381. entity.CommitChanges();
  382. entity.SetObserving(true);
  383. }
  384. /*var props = CoreUtils.PropertyList(typeof(TEntity), x => true, true);
  385. for (var i = 0; i < items.Length; i++)
  386. {
  387. items[i].SetObserving(false);
  388. foreach (var prop in props.Keys)
  389. {
  390. var value = CoreUtils.GetPropertyValue(response.Items[i], prop);
  391. CoreUtils.SetPropertyValue(items[i], prop, value);
  392. }
  393. //CoreUtils.DeepClone<TEntity>(response.Items[i], items[i]);
  394. items[i].CommitChanges();
  395. items[i].SetObserving(true);
  396. }*/
  397. break;
  398. case StatusCode.Unauthenticated:
  399. throw new RemoteException("Client not authenticated", request);
  400. default:
  401. throw new RemoteException(response.Messages, request);
  402. }
  403. }
  404. #endregion
  405. #region Delete
  406. protected override void DoDelete(TEntity entity, string auditnote)
  407. {
  408. var request = new DeleteRequest<TEntity>(entity, auditnote);
  409. PrepareRequest(request);
  410. var response = SendRequest<DeleteRequest<TEntity>, DeleteResponse<TEntity>>(request, "Delete", SerializationFormat.Binary, SerializationFormat.Binary);
  411. switch (response.Status)
  412. {
  413. case StatusCode.OK:
  414. break;
  415. case StatusCode.Unauthenticated:
  416. throw new RemoteException("Client not authenticated", request);
  417. default:
  418. throw new RemoteException(response.Messages, request);
  419. }
  420. }
  421. protected override void DoDelete(IEnumerable<TEntity> entities, string auditnote)
  422. {
  423. var items = entities.AsArray();
  424. var request = new MultiDeleteRequest<TEntity>(items, auditnote);
  425. PrepareRequest(request);
  426. var response = SendRequest<MultiDeleteRequest<TEntity>, MultiDeleteResponse<TEntity>>(request, "MultiDelete", SerializationFormat.Binary, SerializationFormat.Binary);
  427. switch (response.Status)
  428. {
  429. case StatusCode.OK:
  430. break;
  431. case StatusCode.Unauthenticated:
  432. throw new RemoteException("Client not authenticated", request);
  433. default:
  434. throw new RemoteException(response.Messages, request);
  435. }
  436. }
  437. #endregion
  438. #region 2FA
  439. protected override bool DoCheck2FA(string code, Guid? session)
  440. {
  441. var request = new Check2FARequest(code);
  442. PrepareRequest(request);
  443. var response = SendRequest<Check2FARequest, Check2FAResponse>(request, "check_2fa", SerializationFormat.Binary, SerializationFormat.Binary, false);
  444. if (response != null)
  445. {
  446. return response.Status switch
  447. {
  448. StatusCode.OK => response.Valid,
  449. StatusCode.Unauthenticated => false,
  450. _ => throw new RemoteException(response.Messages, request),
  451. };
  452. }
  453. return false;
  454. }
  455. #endregion
  456. #region Ping
  457. protected override bool DoPing()
  458. {
  459. var cli = StaticRestClients.GetClient(RestClientCache.URL(_server));
  460. var req = new RestRequest("/ping", Method.Get) { Timeout = 20000 };
  461. try
  462. {
  463. var res = cli.Execute(req);
  464. if (res.StatusCode != HttpStatusCode.OK || res.ErrorException != null)
  465. return false;
  466. return true;
  467. }
  468. catch
  469. {
  470. return false;
  471. }
  472. }
  473. #endregion
  474. public override DatabaseInfo Info()
  475. {
  476. return RestClientCache.Info(_server);
  477. }
  478. public override string Version()
  479. {
  480. var url = RestClientCache.URL(_server);
  481. if (string.IsNullOrEmpty(url))
  482. {
  483. return "";
  484. }
  485. var cli = StaticRestClients.GetClient(url);
  486. var versionrequest = new RestRequest("/version", Method.Get);
  487. return cli.Execute(versionrequest).Content ?? "";
  488. }
  489. public override string ReleaseNotes()
  490. {
  491. var url = RestClientCache.URL(_server);
  492. if (string.IsNullOrEmpty(url))
  493. {
  494. return "";
  495. }
  496. var cli = StaticRestClients.GetClient(url);
  497. var versionrequest = new RestRequest("/releasenotes", Method.Get);
  498. return cli.Execute(versionrequest).Content ?? "";
  499. }
  500. public override byte[]? Installer()
  501. {
  502. var url = RestClientCache.URL(_server);
  503. if (string.IsNullOrEmpty(url))
  504. {
  505. return null;
  506. }
  507. var cli = StaticRestClients.GetClient(url);
  508. var versionrequest = new RestRequest("/install", Method.Get);
  509. return cli.Execute(versionrequest).RawBytes;
  510. }
  511. }
  512. }