public static FeedElement ToStreamEventForwardFeed(ClientMessage.ReadStreamEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(msg.IsEndOfStream);
var prevEventNumber = Math.Min(msg.FromEventNumber + msg.MaxCount - 1, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - 1;
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (nextEventNumber >= 0)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber, msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber, msg.MaxCount));
if (!escapedStreamId.StartsWith("$$"))
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return feed;
}
public static FeedElement ToAllEventsForwardFeed(ClientMessage.ReadAllEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle("All events");
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 ? msg.Events[msg.Events.Length - 1].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (msg.CurrentPos.CommitPosition != 0)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.PrevPos.AsString(), msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.NextPos.AsString(), msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(
ToEntry(
new ResolvedEvent(msg.Events[i].Event, msg.Events[i].Link, msg.Events[i].ResolveResult),
requestedUrl, embedContent));
}
return feed;
}
private static EmbedLevel GetEmbedLevel(HttpEntityManager manager, UriTemplateMatch match,
EmbedLevel htmlLevel = EmbedLevel.PrettyBody)
{
if (manager.ResponseCodec is IRichAtomCodec)
{
return(htmlLevel);
}
var rawValue = match.BoundVariables["embed"] ?? string.Empty;
switch (rawValue.ToLowerInvariant())
{
case "content":
return(EmbedLevel.Content);
case "rich":
return(EmbedLevel.Rich);
case "body":
return(EmbedLevel.Body);
case "pretty":
return(EmbedLevel.PrettyBody);
case "tryharder":
return(EmbedLevel.TryHarder);
default:
return(EmbedLevel.None);
}
}
public static FeedElement ToStreamEventBackwardFeed(ClientMessage.ReadStreamEventsBackwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent, bool headOfStream)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
var prevEventNumber = Math.Min(msg.FromEventNumber, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - msg.MaxCount;
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (!msg.IsEndOfStream)
{
if (nextEventNumber < 0) throw new Exception(string.Format("nextEventNumber is negative: {0} while IsEndOfStream", nextEventNumber));
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber, msg.MaxCount));
}
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber, msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
for (int i = 0; i < msg.Events.Length; ++i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return feed;
}
public static string ReadAllEventsForwardCompleted(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
{
var msg = message as ClientMessage.ReadAllEventsForwardCompleted;
if (msg == null || msg.Result != ReadAllResult.Success)
return String.Empty;
return entity.ResponseCodec.To(Convert.ToAllEventsForwardFeed(msg, entity.RequestedUrl, embed));
}
public static string GetStreamEventsBackward(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed, bool headOfStream)
{
var msg = message as ClientMessage.ReadStreamEventsBackwardCompleted;
if (msg == null || msg.Result != ReadStreamResult.Success)
return String.Empty;
return entity.ResponseCodec.To(Convert.ToStreamEventBackwardFeed(msg, entity.RequestedUrl, embed, headOfStream));
}
public static FeedElement ToStreamEventBackwardFeed(ClientMessage.ReadStreamEventsBackwardCompleted msg,
Uri requestedUrl, EmbedLevel embedContent, bool headOfStream)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null
? msg.Events[0].Event.TimeStamp
: DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(headOfStream); //TODO AN: remove this ?
feed.SetSelfUrl(self);
//TODO AN: remove this ?
if (headOfStream) //NOTE: etag workaround - to be fixed with better http handling model
{
feed.SetETag(Configure.GetPositionETag(msg.LastEventNumber, ContentType.AtomJson));
}
var prevEventNumber = Math.Min(msg.FromEventNumber, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - msg.MaxCount;
feed.AddLink("self", self);
feed.AddLink("first",
HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (!msg.IsEndOfStream)
{
if (nextEventNumber < 0)
{
throw new Exception(string.Format("nextEventNumber is negative: {0} while IsEndOfStream",
nextEventNumber));
}
feed.AddLink("last",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber,
msg.MaxCount));
}
feed.AddLink("previous",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber,
msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
for (int i = 0; i < msg.Events.Length; ++i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return(feed);
}
private void GetStreamEvent(HttpEntityManager manager, string stream, int eventNumber,
bool resolveLinkTos, bool requireMaster, EmbedLevel embed)
{
var envelope = new SendToHttpEnvelope(_networkSendQueue,
manager,
(args, message) => Format.EventEntry(args, message, embed),
(args, message) => Configure.EventEntry(args, message, headEvent: eventNumber == -1));
var corrId = Guid.NewGuid();
Publish(new ClientMessage.ReadEvent(corrId, corrId, envelope, stream, eventNumber, resolveLinkTos, requireMaster, manager.User));
}
private void GetStreamEventsForward(HttpEntityManager manager, string stream, int eventNumber, int count,
bool resolveLinkTos, bool requireMaster, EmbedLevel embed)
{
var envelope = new SendToHttpEnvelope(_networkSendQueue,
manager,
(ent, msg) => Format.GetStreamEventsForward(ent, msg, embed),
Configure.GetStreamEventsForward);
var corrId = Guid.NewGuid();
Publish(new ClientMessage.ReadStreamEventsForward(corrId, corrId, envelope, stream, eventNumber, count,
resolveLinkTos, requireMaster, GetETagStreamVersion(manager), manager.User));
}
public static string ReadAllEventsForwardCompleted(HttpResponseFormatterArgs entity, Message message,
EmbedLevel embed)
{
var msg = message as ClientMessage.ReadAllEventsForwardCompleted;
if (msg == null || msg.Result != ReadAllResult.Success)
{
return(String.Empty);
}
return(entity.ResponseCodec.To(Convert.ToAllEventsForwardFeed(msg, entity.ResponseUrl, embed)));
}
public static string GetStreamEventsBackward(HttpResponseFormatterArgs entity, Message message,
EmbedLevel embed, bool headOfStream)
{
var msg = message as ClientMessage.ReadStreamEventsBackwardCompleted;
if (msg == null || msg.Result != ReadStreamResult.Success)
{
return(String.Empty);
}
return(entity.ResponseCodec.To(
Convert.ToStreamEventBackwardFeed(msg, entity.ResponseUrl, embed, headOfStream)));
}
public static FeedElement ToStreamEventForwardFeed(ClientMessage.ReadStreamEventsForwardCompleted msg,
Uri requestedUrl, EmbedLevel embedContent)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null
? msg.Events[0].Event.TimeStamp
: DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(msg.IsEndOfStream);
var prevEventNumber = Math.Min(msg.FromEventNumber + msg.MaxCount - 1, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - 1;
feed.AddLink("self", self);
feed.AddLink("first",
HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (nextEventNumber >= 0)
{
feed.AddLink("last",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber,
msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
{
feed.AddLink("previous",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber,
msg.MaxCount));
}
if (!escapedStreamId.StartsWith("$$"))
{
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
}
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return(feed);
}
public static string EventEntry(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
{
var msg = message as ClientMessage.ReadEventCompleted;
if (msg == null || msg.Result != ReadEventResult.Success || msg.Record.Event == null)
return entity.ResponseCodec.To(new {});
switch (entity.ResponseCodec.ContentType)
{
case ContentType.Atom:
case ContentType.AtomJson:
case ContentType.Html:
return entity.ResponseCodec.To(Convert.ToEntry(msg.Record, entity.RequestedUrl, embed, singleEntry: true));
default:
return AutoEventConverter.SmartFormat(msg.Record, entity.ResponseCodec);
}
}
public static string ReadEventCompletedEntry(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
{
Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventCompleted));
var completed = message as ClientMessage.ReadEventCompleted;
if (completed != null)
{
switch (completed.Result)
{
case ReadEventResult.Success:
return entity.ResponseCodec.To(Convert.ToEntry(completed.Record, entity.UserHostName, embed));
case ReadEventResult.NotFound:
case ReadEventResult.NoStream:
case ReadEventResult.StreamDeleted:
return string.Empty;
default:
throw new ArgumentOutOfRangeException();
}
}
return string.Empty;
}
public static FeedElement ToAllEventsForwardFeed(ClientMessage.ReadAllEventsForwardCompleted msg,
Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle("All events");
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null
? msg.Events[msg.Events.Length - 1].Event.TimeStamp
: DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first",
HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (msg.CurrentPos.CommitPosition != 0)
{
feed.AddLink("last",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped,
new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.PrevPos.AsString(),
msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
{
feed.AddLink("previous",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.NextPos.AsString(),
msg.MaxCount));
}
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i].WithoutPosition(), requestedUrl, embedContent));
}
return(feed);
}
public static string ReadStreamEventsBackwardCompletedFeed(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed, bool headOfStream)
{
Debug.Assert(message.GetType() == typeof(ClientMessage.ReadStreamEventsBackwardCompleted));
var completed = message as ClientMessage.ReadStreamEventsBackwardCompleted;
if (completed != null)
{
switch (completed.Result)
{
case ReadStreamResult.Success:
return entity.ResponseCodec.To(Convert.ToReadStreamFeed(completed, entity.UserHostName, embed, headOfStream));
case ReadStreamResult.NoStream:
case ReadStreamResult.StreamDeleted:
case ReadStreamResult.NotModified:
case ReadStreamResult.Error:
return string.Empty;
default:
throw new ArgumentOutOfRangeException();
}
}
return string.Empty;
}
public static FeedElement ToAllEventsBackwardFeed(ClientMessage.ReadAllEventsBackwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle(string.Format("All events"));
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (!msg.IsEndOfStream)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.NextPos.AsString(), msg.MaxCount));
}
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.PrevPos.AsString(), msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = 0; i < msg.Events.Length; ++i)
{
feed.AddEntry(ToEntry(new ResolvedEvent(msg.Events[i].Event, msg.Events[i].Link), requestedUrl, embedContent));
}
return(feed);
}
public static string ReadAllEventsForwardCompleted(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
{
Debug.Assert(message.GetType() == typeof(ClientMessage.ReadAllEventsForwardCompleted));
var msg = message as ClientMessage.ReadAllEventsForwardCompleted;
if (msg == null || msg.NotModified)
return string.Empty;
return entity.ResponseCodec.To(Convert.ToAllEventsForwardFeed(msg.Result, entity.UserHostName, embed));
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (eventLinkPair.Event == null || requestedUrl == null)
return null;
var evnt = eventLinkPair.Event;
EntryElement entry;
if (embedContent > EmbedLevel.Content)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
var escapedStreamId = Uri.EscapeDataString(evnt.EventStreamId);
entry.SetTitle(evnt.EventNumber + "@" + evnt.EventStreamId);
entry.SetId(HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.SetUpdated(evnt.TimeStamp);
entry.SetAuthor(AtomSpecs.Author);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
entry.AddLink("edit", HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.AddLink("alternate", HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
return entry;
}
public static string ReadNextNPersistentMessagesCompleted(HttpResponseFormatterArgs entity, Message message, string streamId, string groupName, int count, EmbedLevel embed)
{
var msg = message as ClientMessage.ReadNextNPersistentMessagesCompleted;
if (msg == null || msg.Result != ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult.Success)
return String.Empty;
return entity.ResponseCodec.To(Convert.ToNextNPersistentMessagesFeed(msg, entity.RequestedUrl, streamId, groupName, count, embed));
}
public static FeedElement ToAllEventsBackwardFeed(ClientMessage.ReadAllEventsBackwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle(string.Format("All events"));
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (!msg.IsEndOfStream)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.NextPos.AsString(), msg.MaxCount));
}
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.PrevPos.AsString(), msg.MaxCount));
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = 0; i < msg.Events.Length; ++i)
{
feed.AddEntry(ToEntry(msg.Events[i].WithoutPosition(), requestedUrl, embedContent));
}
return feed;
}
public static FeedElement ToReadStreamFeed(
ClientMessage.ReadStreamEventsBackwardCompleted msg, string userHostName, EmbedLevel embedContent,
bool headOfStream)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(userHostName, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(headOfStream);
if (headOfStream)
//NOTE: etag workaround - to be fixed with better http handling model
feed.SetETag(msg.LastEventNumber.ToString(CultureInfo.InvariantCulture) + ";" + "application/json".GetHashCode());
feed.SetSelfUrl(self);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(userHostName, "/streams/{0}", escapedStreamId)); // TODO AN: should account for msg.MaxCount
feed.AddLink("last", HostName.Combine(userHostName, "/streams/{0}/range/{1}/{2}", escapedStreamId, msg.MaxCount - 1, msg.MaxCount));
feed.AddLink("previous", HostName.Combine(userHostName,
"/streams/{0}/range/{1}/{2}",
escapedStreamId,
Math.Min(msg.FromEventNumber, msg.LastEventNumber) + msg.MaxCount,
msg.MaxCount));
if (msg.FromEventNumber - msg.MaxCount >= 0)
{
feed.AddLink("next", HostName.Combine(userHostName,
"/streams/{0}/range/{1}/{2}",
escapedStreamId,
msg.FromEventNumber - msg.MaxCount,
msg.MaxCount));
}
for (int i = 0; i < msg.Events.Length; ++i)
{
feed.AddEntry(ToEntry(msg.Events[i], userHostName, embedContent));
}
return feed;
}
private static EmbedLevel GetEmbedLevel(HttpEntityManager manager, UriTemplateMatch match, EmbedLevel htmlLevel = EmbedLevel.PrettyBody)
{
if (manager.ResponseCodec is IRichAtomCodec)
return htmlLevel;
var rawValue = match.BoundVariables["embed"] ?? string.Empty;
switch (rawValue.ToLowerInvariant())
{
case "content": return EmbedLevel.Content;
case "rich": return EmbedLevel.Rich;
case "body": return EmbedLevel.Body;
case "pretty": return EmbedLevel.PrettyBody;
case "tryharder": return EmbedLevel.TryHarder;
default: return EmbedLevel.None;
}
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (requestedUrl == null)
return null;
var evnt = eventLinkPair.Event;
var link = eventLinkPair.Link;
EntryElement entry;
if (embedContent > EmbedLevel.Content && evnt != null)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventId = evnt.EventId;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body && eventLinkPair.Event != null)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.Body)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
if (embedContent >= EmbedLevel.PrettyBody)
{
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
if (string.IsNullOrEmpty(richEntry.MetaData))
{
richEntry.MetaData = null;
}
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
if (embedContent >= EmbedLevel.PrettyBody)
{
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
if (evnt != null && link == null)
{
SetEntryProperties(evnt.EventStreamId, evnt.EventNumber, evnt.TimeStamp, requestedUrl, entry);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
}
else if (link != null)
{
var eventLoc = GetLinkData(Encoding.UTF8.GetString(link.Data));
SetEntryProperties(eventLoc.Item1, eventLoc.Item2, link.TimeStamp, requestedUrl, entry);
entry.SetSummary("$>");
}
return entry;
}
public static FeedElement ToNextNPersistentMessagesFeed(ClientMessage.ReadNextNPersistentMessagesCompleted msg, Uri requestedUrl, string streamId, string groupName, int count, EmbedLevel embedContent)
{
string escapedStreamId = Uri.EscapeDataString(streamId);
string escapedGroupName = Uri.EscapeDataString(groupName);
var self = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}", escapedStreamId, escapedGroupName);
var feed = new FeedElement();
feed.SetTitle(string.Format("Messages for '{0}/{1}'", streamId, groupName));
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[msg.Events.Length - 1].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
if (msg.Events != null && msg.Events.Length > 0)
{
var ackAllQueryString = String.Format("?ids={0}", String.Join(",", msg.Events.Select(x => x.OriginalEvent.EventId)));
var ackAll = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/ack", escapedStreamId, escapedGroupName) + ackAllQueryString;
feed.AddLink("ackAll", ackAll);
var nackAllQueryString = String.Format("?ids={0}", String.Join(",", msg.Events.Select(x => x.OriginalEvent.EventId)));
var nackAll = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/nack", escapedStreamId, escapedGroupName) + nackAllQueryString;
feed.AddLink("nackAll", nackAll);
}
var prev = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/{2}", escapedStreamId, escapedGroupName, count);
feed.AddLink("previous", prev);
feed.AddLink("self", self);
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
var entry = ToEntry(msg.Events[i].WithoutPosition(), requestedUrl, embedContent);
var ack = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/ack/{2}", escapedStreamId, escapedGroupName, msg.Events[i].OriginalEvent.EventId);
var nack = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/nack/{2}", escapedStreamId, escapedGroupName, msg.Events[i].OriginalEvent.EventId);
entry.AddLink("ack", ack);
entry.AddLink("nack", nack);
feed.AddEntry(entry);
}
return feed;
}
public static FeedElement ToNextNPersistentMessagesFeed(ClientMessage.ReadNextNPersistentMessagesCompleted msg, Uri requestedUrl, string streamId, string groupName, int count, EmbedLevel embedContent)
{
string escapedStreamId = Uri.EscapeDataString(streamId);
string escapedGroupName = Uri.EscapeDataString(groupName);
var self = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}", escapedStreamId, escapedGroupName);
var feed = new FeedElement();
feed.SetTitle(string.Format("Messages for '{0}/{1}'", streamId, groupName));
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[msg.Events.Length - 1].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
if (msg.Events != null && msg.Events.Length > 0)
{
var ackAllQueryString = String.Format("?ids={0}", String.Join(",", msg.Events.Select(x => x.OriginalEvent.EventId)));
var ackAll = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/ack", escapedStreamId, escapedGroupName) + ackAllQueryString;
feed.AddLink("ackAll", ackAll);
var nackAllQueryString = String.Format("?ids={0}", String.Join(",", msg.Events.Select(x => x.OriginalEvent.EventId)));
var nackAll = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/nack", escapedStreamId, escapedGroupName) + nackAllQueryString;
feed.AddLink("nackAll", nackAll);
}
var prev = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/{2}", escapedStreamId, escapedGroupName, count);
feed.AddLink("previous", prev);
feed.AddLink("self", self);
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
var entry = ToEntry(msg.Events[i].WithoutPosition(), requestedUrl, embedContent);
var ack = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/ack/{2}", escapedStreamId, escapedGroupName, msg.Events[i].OriginalEvent.EventId);
var nack = HostName.Combine(requestedUrl, "/subscriptions/{0}/{1}/nack/{2}", escapedStreamId, escapedGroupName, msg.Events[i].OriginalEvent.EventId);
entry.AddLink("ack", ack);
entry.AddLink("nack", nack);
feed.AddEntry(entry);
}
return(feed);
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (eventLinkPair.Event == null || requestedUrl == null)
{
return(null);
}
var evnt = eventLinkPair.Event;
EntryElement entry;
if (embedContent > EmbedLevel.Content)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
var escapedStreamId = Uri.EscapeDataString(evnt.EventStreamId);
entry.SetTitle(evnt.EventNumber + "@" + evnt.EventStreamId);
entry.SetId(HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.SetUpdated(evnt.TimeStamp);
entry.SetAuthor(AtomSpecs.Author);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
{
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
}
entry.AddLink("edit", HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.AddLink("alternate", HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
return(entry);
}
public static string ReadNextNPersistentMessagesCompleted(HttpResponseFormatterArgs entity, Message message, string streamId, string groupName, int count, EmbedLevel embed)
{
var msg = message as ClientMessage.ReadNextNPersistentMessagesCompleted;
if (msg == null || msg.Result != ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult.Success)
{
return(String.Empty);
}
return(entity.ResponseCodec.To(Convert.ToNextNPersistentMessagesFeed(msg, entity.RequestedUrl, streamId, groupName, count, embed)));
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (requestedUrl == null)
{
return(null);
}
var evnt = eventLinkPair.Event;
var link = eventLinkPair.Link;
EntryElement entry;
if (embedContent > EmbedLevel.Content && evnt != null)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventId = evnt.EventId;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body && eventLinkPair.Event != null)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
if (evnt != null && link == null)
{
SetEntryProperties(evnt.EventStreamId, evnt.EventNumber, evnt.TimeStamp, requestedUrl, entry);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
{
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
}
}
else if (link != null)
{
var pieces = Encoding.UTF8.GetString(link.Data).Split('@');
if (pieces.Length != 2)
{
throw new Exception("link not in proper format.");
}
var eventNumber = int.Parse(pieces[0]);
var streamId = pieces[1];
SetEntryProperties(streamId, eventNumber, link.TimeStamp, requestedUrl, entry);
entry.SetSummary("$>");
}
return(entry);
}
public static FeedElement ToAllEventsBackwardFeed(ReadAllResult result, string userHostName, EmbedLevel embedContent)
{
var self = HostName.Combine(userHostName, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle(string.Format("All events"));
feed.SetId(self);
feed.SetUpdated(result.Events.Length > 0 ? result.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(userHostName, "/streams/{0}/{1}", AllEscaped, result.MaxCount));
feed.AddLink("last", HostName.Combine(userHostName, "/streams/{0}/after/{1}/{2}", AllEscaped, new TFPos(0, 0).AsString(), result.MaxCount));
feed.AddLink("previous", HostName.Combine(userHostName, "/streams/{0}/after/{1}/{2}", AllEscaped, result.PrevPos.AsString(), result.MaxCount));
feed.AddLink("next", HostName.Combine(userHostName, "/streams/{0}/before/{1}/{2}", AllEscaped, result.NextPos.AsString(), result.MaxCount));
for (int i = 0; i < result.Events.Length; ++i)
{
feed.AddEntry(ToEntry(new ResolvedEvent(result.Events[i].Event, result.Events[i].Link), userHostName, embedContent));
}
return feed;
}
public static string EventEntry(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
{
var msg = message as ClientMessage.ReadEventCompleted;
if (msg == null || msg.Result != ReadEventResult.Success || msg.Record.Event == null)
{
return(entity.ResponseCodec.To(new {}));
}
switch (entity.ResponseCodec.ContentType)
{
case ContentType.Atom:
case ContentType.AtomJson:
case ContentType.Html:
return(entity.ResponseCodec.To(Convert.ToEntry(msg.Record, entity.RequestedUrl, embed, singleEntry: true)));
default:
return(AutoEventConverter.SmartFormat(msg.Record, entity.ResponseCodec));
}
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, string userHostName, EmbedLevel embedContent)
{
if (eventLinkPair.Event == null || userHostName == null)
return null;
var evnt = eventLinkPair.Event;
EntryElement entry;
if (embedContent > EmbedLevel.None)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = (eventLinkPair.Link ?? eventLinkPair.Event).EventNumber;
richEntry.PositionStreamId = (eventLinkPair.Link ?? eventLinkPair.Event).EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
try
{
richEntry.Data = Encoding.UTF8.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Encoding.UTF8.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
else
richEntry.Data = Encoding.UTF8.GetString(evnt.Data);
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Encoding.UTF8.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Encoding.UTF8.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Encoding.UTF8.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
var escapedStreamId = Uri.EscapeDataString(evnt.EventStreamId);
entry.SetTitle(evnt.EventNumber + "@" + evnt.EventStreamId);
entry.SetId(HostName.Combine(userHostName, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.SetUpdated(evnt.TimeStamp);
entry.SetAuthor(AtomSpecs.Author);
entry.SetSummary(evnt.EventType);
entry.AddLink("edit", HostName.Combine(userHostName, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.AddLink(null, HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=text", escapedStreamId, evnt.EventNumber), ContentType.PlainText);
entry.AddLink("alternate", HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=json", escapedStreamId, evnt.EventNumber), ContentType.Json);
entry.AddLink("alternate", HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=xml", escapedStreamId, evnt.EventNumber), ContentType.Xml);
return entry;
}
