PageRenderTime 53ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 0ms

/src/EventStore.Core/Services/Transport/Http/AutoEventConverter.cs

https://github.com/elainte/EventStore
C# | 178 lines | 146 code | 23 blank | 9 comment | 11 complexity | 3402011988747ccd6846b3dc375ad28b MD5 | raw file
  1. using System;
  2. using System.Text;
  3. using System.Xml.Linq;
  4. using EventStore.Common.Log;
  5. using EventStore.Core.Data;
  6. using EventStore.Core.Messages;
  7. using EventStore.Core.TransactionLog.LogRecords;
  8. using EventStore.Transport.Http;
  9. using EventStore.Transport.Http.Codecs;
  10. using Newtonsoft.Json;
  11. using Newtonsoft.Json.Linq;
  12. using Formatting = Newtonsoft.Json.Formatting;
  13. using System.Linq;
  14. using EventStore.Common.Utils;
  15. namespace EventStore.Core.Services.Transport.Http
  16. {
  17. public static class AutoEventConverter
  18. {
  19. private static readonly ILogger Log = LogManager.GetLogger("AutoEventConverter");
  20. public static string SmartFormat(ResolvedEvent evnt, ICodec targetCodec)
  21. {
  22. var dto = CreateDataDto(evnt);
  23. switch (targetCodec.ContentType)
  24. {
  25. case ContentType.Xml:
  26. case ContentType.ApplicationXml:
  27. {
  28. var serializeObject = JsonConvert.SerializeObject(dto.data);
  29. var deserializeXmlNode = JsonConvert.DeserializeXmlNode(serializeObject, "data");
  30. return deserializeXmlNode.InnerXml;
  31. }
  32. case ContentType.Json:
  33. return targetCodec.To(dto.data);
  34. case ContentType.Atom:
  35. case ContentType.EventXml:
  36. {
  37. var serializeObject = JsonConvert.SerializeObject(dto);
  38. var deserializeXmlNode = JsonConvert.DeserializeXmlNode(serializeObject, "event");
  39. return deserializeXmlNode.InnerXml;
  40. }
  41. case ContentType.EventJson:
  42. return targetCodec.To(dto);
  43. default:
  44. throw new NotSupportedException();
  45. }
  46. }
  47. public static HttpClientMessageDto.ReadEventCompletedText CreateDataDto(ResolvedEvent evnt)
  48. {
  49. var dto = new HttpClientMessageDto.ReadEventCompletedText(evnt);
  50. if (evnt.Event.Flags.HasFlag(PrepareFlags.IsJson))
  51. {
  52. var deserializedData = Codec.Json.From<object>((string) dto.data);
  53. var deserializedMetadata = Codec.Json.From<object>((string) dto.metadata);
  54. if (deserializedData != null)
  55. dto.data = deserializedData;
  56. if (deserializedMetadata != null)
  57. dto.metadata = deserializedMetadata;
  58. }
  59. return dto;
  60. }
  61. //TODO GFY THERE IS WAY TOO MUCH COPYING/SERIALIZING/DESERIALIZING HERE!
  62. public static Event[] SmartParse(string request, ICodec sourceCodec, Guid includedId, string includedType=null)
  63. {
  64. switch(sourceCodec.ContentType)
  65. {
  66. case ContentType.Json:
  67. return LoadRaw(request, true, includedId, includedType);
  68. case ContentType.EventJson:
  69. case ContentType.EventsJson:
  70. case ContentType.AtomJson:
  71. var writeEvents = LoadFromJson(request);
  72. if (writeEvents.IsEmpty())
  73. return null;
  74. return Parse(writeEvents);
  75. case ContentType.Xml:
  76. return LoadRaw(request, false, includedId, includedType);
  77. case ContentType.EventXml:
  78. case ContentType.EventsXml:
  79. case ContentType.ApplicationXml:
  80. case ContentType.Atom:
  81. var writeEvents2 = LoadFromXml(request);
  82. if (writeEvents2.IsEmpty())
  83. return null;
  84. return Parse(writeEvents2);
  85. default:
  86. return null;
  87. }
  88. }
  89. private static Event[] LoadRaw(string data, bool isJson, Guid includedId, string includedType) {
  90. var ret = new Event[1];
  91. ret[0] = new Event(includedId, includedType, isJson, data, null);
  92. return ret;
  93. }
  94. private static HttpClientMessageDto.ClientEventDynamic[] LoadFromJson(string json)
  95. {
  96. return Codec.Json.From<HttpClientMessageDto.ClientEventDynamic[]>(json);
  97. }
  98. private static HttpClientMessageDto.ClientEventDynamic[] LoadFromXml(string xml)
  99. {
  100. try
  101. {
  102. XDocument doc = XDocument.Parse(xml);
  103. XNamespace jsonNsValue = "http://james.newtonking.com/projects/json";
  104. XName jsonNsName = XNamespace.Xmlns + "json";
  105. doc.Root.SetAttributeValue(jsonNsName, jsonNsValue);
  106. var events = doc.Root.Elements()/*.ToArray()*/;
  107. foreach (var @event in events)
  108. {
  109. @event.Name = "events";
  110. @event.SetAttributeValue(jsonNsValue + "Array", "true");
  111. }
  112. //doc.Root.ReplaceNodes(events);
  113. // foreach (var element in doc.Root.Descendants("data").Concat(doc.Root.Descendants("metadata")))
  114. // {
  115. // element.RemoveAttributes();
  116. // }
  117. var json = JsonConvert.SerializeXNode(doc.Root, Formatting.None, true);
  118. var root = JsonConvert.DeserializeObject<HttpClientMessageDto.WriteEventsDynamic>(json);
  119. return root.events;
  120. // var root = JsonConvert.DeserializeObject<JObject>(json);
  121. // var dynamicEvents = root.ToObject<HttpClientMessageDto.WriteEventsDynamic>();
  122. // return dynamicEvents.events;
  123. }
  124. catch (Exception e)
  125. {
  126. Log.InfoException(e, "Failed to load xml. Invalid format");
  127. return null;
  128. }
  129. }
  130. private static Event[] Parse(HttpClientMessageDto.ClientEventDynamic[] dynamicEvents)
  131. {
  132. var events = new Event[dynamicEvents.Length];
  133. for (int i = 0, n = dynamicEvents.Length; i < n; ++i)
  134. {
  135. var textEvent = dynamicEvents[i];
  136. bool dataIsJson;
  137. bool metadataIsJson;
  138. var data = AsBytes(textEvent.data, out dataIsJson);
  139. var metadata = AsBytes(textEvent.metadata, out metadataIsJson);
  140. events[i] = new Event(textEvent.eventId, textEvent.eventType, dataIsJson || metadataIsJson, data, metadata);
  141. }
  142. return events.ToArray();
  143. }
  144. private static byte[] AsBytes(object obj, out bool isJson)
  145. {
  146. if (obj is JObject)
  147. {
  148. isJson = true;
  149. return Helper.UTF8NoBom.GetBytes(Codec.Json.To(obj));
  150. }
  151. isJson = false;
  152. return Helper.UTF8NoBom.GetBytes((obj as string) ?? string.Empty);
  153. }
  154. }
  155. }