private void SaveConcrete(object obj)
{
if (obj is Document)
{
_session.Save(obj);
}
else if (obj is IIndex)
{
_session.Save(obj);
}
else
{
var doc = new Document();
// convert the custom object to a storable document
_serializer.Serialize(obj, ref doc);
// if the object is not new, reload to get the old map
int id;
if (_documents.TryGetValue(obj, out id))
{
var oldDoc = _session.Get <Document>(id);
var oldObj = _serializer.Deserialize(oldDoc);
// do nothing if the document hasn't been modified
if (oldDoc.Content != doc.Content)
{
oldDoc.Content = doc.Content;
MapDeleted(oldDoc, oldObj);
// update document
MapNew(oldDoc, obj);
}
}
else
{
// new document
_session.Save(doc);
var accessor = _store.GetIdAccessor(obj.GetType(), "Id");
// if the object has an Id property, set it back
var ident = accessor.Get(obj);
if (ident != null)
{
accessor.Set(obj, doc.Id);
}
// track the newly created object
TrackObject(obj, doc);
MapNew(doc, obj);
}
}
}
public static Commit ToCommit(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
{
return(null);
}
BsonDocument id = doc[MongoFields.Id].AsBsonDocument;
string bucketId = id[MongoFields.BucketId].AsString;
string streamId = id[MongoFields.StreamId].AsString;
int commitSequence = id[MongoFields.CommitSequence].AsInt32;
List <EventMessage> events = doc[MongoFields.Events]
.AsBsonArray
.Select(e =>
e.AsBsonDocument[MongoFields.Payload].IsBsonDocument
? BsonSerializer.Deserialize <EventMessage>(e.AsBsonDocument[MongoFields.Payload].AsBsonDocument)
: serializer.Deserialize <EventMessage>(e.AsBsonDocument[MongoFields.Payload].AsByteArray))
.ToList();
int streamRevision = doc[MongoFields.Events].AsBsonArray.Last().AsBsonDocument[MongoFields.StreamRevision].AsInt32;
return(new Commit(
bucketId,
streamId,
streamRevision,
doc[MongoFields.CommitId].AsGuid,
commitSequence,
doc[MongoFields.CommitStamp].ToUniversalTime(),
doc[MongoFields.Headers].AsDictionary <string, object>(),
events));
}
public static ICommit ToCommit_original(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
{
return(null);
}
string bucketId = doc[MongoCommitFields.BucketId].AsString;
string streamId = doc[MongoCommitFields.StreamId].AsString;
int commitSequence = doc[MongoCommitFields.CommitSequence].AsInt32;
var events = doc[MongoCommitFields.Events]
.AsBsonArray
.Select(e =>
{
BsonValue payload = e.AsBsonDocument[MongoCommitFields.Payload];
return(payload.IsBsonDocument
? BsonSerializer.Deserialize <EventMessage>(payload.ToBsonDocument())
: serializer.Deserialize <EventMessage>(payload.AsByteArray));
})
.ToArray();
//int streamRevision = doc[MongoCommitFields.Events].AsBsonArray.Last().AsBsonDocument[MongoCommitFields.StreamRevision].AsInt32;
int streamRevision = doc[MongoCommitFields.StreamRevisionTo].AsInt32;
return(new Commit(bucketId,
streamId,
streamRevision,
doc[MongoCommitFields.CommitId].AsGuid,
commitSequence,
doc[MongoCommitFields.CommitStamp].ToUniversalTime(),
doc[MongoCommitFields.CheckpointNumber].ToInt64(),
doc[MongoCommitFields.Headers].AsDictionary <string, object>(),
events));
}
private FlowDocument CloneDocument(FlowDocument flowDocument)
{
MathDocument mathDocument = _serializer.Serialize(flowDocument);
FlowDocument deserializedFlowDocument = _serializer.Deserialize(mathDocument);
return(deserializedFlowDocument);
}
public static Snapshot ToSnapshot(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
return null;
var id = doc["_id"].AsBsonDocument;
var streamId = id["StreamId"].AsGuid;
var streamRevision = id["StreamRevision"].AsInt32;
var bsonPayload = doc["Payload"];
object payload;
switch (bsonPayload.BsonType)
{
case BsonType.Binary:
payload = serializer.Deserialize<object>(bsonPayload.AsByteArray);
break;
case BsonType.Document:
payload = BsonSerializer.Deserialize<object>(bsonPayload.AsBsonDocument);
break;
default:
payload = bsonPayload.RawValue;
break;
}
return new Snapshot(
streamId,
streamRevision,
payload);
}
public TDocument Get(string documentName)
{
CloudBlobClient blobStorageType = Account.CreateCloudBlobClient();
CloudBlobContainer container = blobStorageType.GetContainerReference(DocumentsContainerName);
var blobAddressUri = documentName;
var serializationStream = new MemoryStream();
//try
//{
// container.GetBlobReference(blobAddressUri).DownloadToStream(serializationStream);
//}
//catch (StorageClientException e)
//{
// if (e.StatusCode == HttpStatusCode.NotFound)
// {
// return null;
// }
// throw;
//}
//TODO: revisar que tipo de exception tira
try
{
container.GetBlockBlobReference(blobAddressUri).DownloadToStream(serializationStream);
}
catch (Exception)
{
return(null);
}
return(_documentSerializer.Deserialize(serializationStream));
}
public static Snapshot ToSnapshot(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
{
return(null);
}
var id = doc["_id"].AsBsonDocument;
var streamId = id["StreamId"].AsGuid;
var streamRevision = id["StreamRevision"].AsInt32;
var bsonPayload = doc["Payload"];
object payload;
switch (bsonPayload.BsonType)
{
case BsonType.Binary:
payload = serializer.Deserialize <object>(bsonPayload.AsByteArray);
break;
case BsonType.Document:
payload = BsonSerializer.Deserialize <object>(bsonPayload.AsBsonDocument);
break;
default:
payload = BsonTypeMapper.MapToDotNetValue(bsonPayload);
break;
}
return(new Snapshot(
streamId,
streamRevision,
payload));
}
public static ICommit ToCommit(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
{
return(null);
}
var mc = BsonSerializer.Deserialize <MongoCommit>(doc);
return(new Commit(mc.BucketId,
mc.StreamId,
mc.StreamRevisionTo,
mc.CommitId,
mc.CommitSequence,
mc.CommitStamp,
mc.CheckpointNumber,
mc.Headers,
mc.Events.Select(e =>
{
BsonValue payload = e[MongoCommitFields.Payload];
return payload.IsBsonDocument
? BsonSerializer.Deserialize <EventMessage>(payload.ToBsonDocument())
: serializer.Deserialize <EventMessage>(payload.AsByteArray); // ByteStreamDocumentSerializer ?!?! doesn't work this way!
}).ToArray()));
}
public override async Task ExecuteAsync(IContext context, SendMessageFromHttpSettings settings, CancellationToken cancellationToken)
{
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, settings.Uri);
if (settings.Headers != null)
{
foreach (var header in settings.Headers)
{
httpRequestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
else
{
httpRequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(settings.Type));
}
using (var cts = new CancellationTokenSource(settings.RequestTimeout ?? DefaultRequestTimeout))
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, cts.Token))
using (var httpResponseMessage = await _httpClient.SendAsync(httpRequestMessage, linkedCts.Token).ConfigureAwait(false))
{
httpResponseMessage.EnsureSuccessStatusCode();
var body = await httpResponseMessage.Content.ReadAsStringAsync();
var message = new Message(EnvelopeId.NewId())
{
Id = EnvelopeId.NewId(),
To = context.Input.Message.From,
Content = _documentSerializer.Deserialize(body, settings.MediaType)
};
await _sender.SendMessageAsync(message, cancellationToken);
}
}
public static Snapshot ToSnapshot(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
{
return(null);
}
BsonDocument id = doc[MongoFields.Id].AsBsonDocument;
string bucketId = id[MongoFields.BucketId].AsString;
string streamId = id[MongoFields.StreamId].AsString;
int streamRevision = id[MongoFields.StreamRevision].AsInt32;
BsonValue bsonPayload = doc[MongoFields.Payload];
object payload;
switch (bsonPayload.BsonType)
{
case BsonType.Binary:
payload = serializer.Deserialize <object>(bsonPayload.AsByteArray);
break;
case BsonType.Document:
payload = BsonSerializer.Deserialize <object>(bsonPayload.AsBsonDocument);
break;
default:
payload = BsonTypeMapper.MapToDotNetValue(bsonPayload);
break;
}
return(new Snapshot(bucketId, streamId, streamRevision, payload));
}
public static Commit ToCommit(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
{
return(null);
}
BsonDocument id = doc["_id"].AsBsonDocument;
Guid streamId = id["StreamId"].AsGuid;
int commitSequence = id["CommitSequence"].AsInt32;
List <EventMessage> events =
doc["Events"].AsBsonArray.Select(
e =>
e.AsBsonDocument["Payload"].IsBsonDocument
? BsonSerializer.Deserialize <EventMessage>(
e.AsBsonDocument["Payload"]
.AsBsonDocument)
: serializer.Deserialize <EventMessage>(e.AsBsonDocument["Payload"].AsByteArray))
.ToList();
int streamRevision = doc["Events"].AsBsonArray.Last().AsBsonDocument["StreamRevision"].AsInt32;
return(new Commit(streamId,
streamRevision,
doc["CommitId"].AsGuid,
commitSequence,
doc["CommitStamp"].ToUniversalTime(),
doc["Headers"].AsDictionary <string, object>(),
events));
}
public static Snapshot ToSnapshot(this RavenSnapshot snapshot, IDocumentSerializer serializer)
{
if (snapshot == null)
return null;
return new Snapshot(snapshot.BucketId, snapshot.StreamId, snapshot.StreamRevision,
serializer.Deserialize<object>(snapshot.Payload));
}
public static Snapshot ToSnapshot(this DocumentSnapshot snapshot, IDocumentSerializer serializer)
{
if (snapshot == null)
{
return(null);
}
return(new Snapshot(snapshot.BucketId, snapshot.StreamRevision,
serializer.Deserialize <object>(snapshot.Payload)));
}
public static Commit ToCommit(this RavenCommit commit, IDocumentSerializer serializer)
{
return new Commit(commit.StreamId,
commit.StreamRevision,
commit.CommitId,
commit.CommitSequence,
commit.CommitStamp,
commit.Headers,
serializer.Deserialize<List<EventMessage>>(commit.Payload));
}
public static Commit ToCommit(this RavenCommit commit, IDocumentSerializer serializer)
{
return(new Commit(commit.StreamId,
commit.StreamRevision,
commit.CommitId,
commit.CommitSequence,
commit.CommitStamp,
commit.Headers,
serializer.Deserialize <List <EventMessage> >(commit.Payload)));
}
public override Task ExecuteAsync(IContext context, SendRawMessageSettings settings, CancellationToken cancellationToken)
{
var message = new Message(EnvelopeId.NewId())
{
Id = EnvelopeId.NewId(),
To = context.User.ToNode(),
Content = _documentSerializer.Deserialize(settings.RawContent, settings.MediaType),
Metadata = settings.Metadata
};
return(_sender.SendMessageAsync(message, cancellationToken));
}
private async Task <TModel> TranslateResponse <TModel>(HttpResponseMessage response)
{
var responseJson = await response.Content.ReadAsStringAsync();
var model = _jsonDocumentSerializer.Deserialize <TModel>(responseJson);
if (model is BaseResponse res)
{
res.StatusCode = (int)response.StatusCode;
}
return(model);
}
protected override Task ExecuteAsync(SendMessageOptions options, IEstablishedChannel channel, CancellationToken cancellationToken)
{
var content = _documentSerializer.Deserialize(options.JoinedContent, options.Type);
return(channel.SendMessageAsync(
new Message(options.Id)
{
From = options.From,
To = options.To,
Content = content
},
cancellationToken));
}
public Document ToDocument(IDocumentSerializer documentSerializer, JsonSerializer serializer)
{
var mediaType = Type;
if (mediaType == null)
{
// Use the old method to determine the document type
var jObject = JObject.Parse(Document);
mediaType = jObject[TYPE_KEY].ToObject <MediaType>(serializer);
}
return(documentSerializer.Deserialize(Document, mediaType));
}
public static ICommit ToCommit(this DocumentCommit commit, IDocumentSerializer serializer)
{
return(new Commit(
commit.BucketId,
commit.StreamId,
commit.StreamRevision,
commit.CommitId,
commit.CommitSequence,
commit.CommitStamp,
commit.CheckpointNumber.ToString(CultureInfo.InvariantCulture),
commit.Headers,
serializer.Deserialize <IList <EventMessage> >(commit.Payload)
));
}
public static ICommit ToCommit(this RavenCommit commit, IDocumentSerializer serializer)
{
return new Commit(
commit.BucketId,
commit.StreamId,
commit.StreamRevision,
commit.CommitId,
commit.CommitSequence,
commit.CommitStamp,
commit.CheckpointNumber.ToString(CultureInfo.InvariantCulture),
commit.Headers,
serializer.Deserialize<IList<EventMessage>>(commit.Payload)
);
}
protected override Task ExecuteAsync(SendCommandOptions options, IEstablishedChannel channel, CancellationToken cancellationToken)
{
var resource = _documentSerializer.Deserialize(options.JoinedResource, options.Type);
return(channel.SendCommandAsync(
new Command(options.Id ?? EnvelopeId.NewId())
{
From = options.From,
To = options.To,
Method = options.Method,
Uri = new LimeUri(options.Uri),
Resource = resource
},
cancellationToken));
}
public override Task ExecuteAsync(IContext context, SendRawMessageSettings settings, CancellationToken cancellationToken)
{
var message = new Message(null)
{
To = context.Input.Message.From,
Content = _documentSerializer.Deserialize(settings.RawContent, settings.MediaType),
Metadata = settings.Metadata
};
if (message.Content?.GetMediaType() != ChatState.MediaType)
{
message.Id = EnvelopeId.NewId();
}
return(_sender.SendMessageAsync(message, cancellationToken));
}
public async Task <Image> UploadImage([Base64] string image, string authority)
{
var document = _documentSerializer.Deserialize(image);
var name = $"{Guid.NewGuid()}{document.Extension}";
var path = Path.Combine($"{_hostingEnvironment.ContentRootPath}/wwwroot/storage");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
await File.WriteAllBytesAsync($"{path}/{name}", document.Buffer);
return(new Image()
{
ImagePath = $"{authority}/storage/{name}"
});
}
public static Commit ToCommit(this BsonDocument doc, IDocumentSerializer serializer)
{
if (doc == null)
return null;
var id = doc["_id"].AsBsonDocument;
var streamId = id["StreamId"].AsGuid;
var commitSequence = id["CommitSequence"].AsInt32;
var events = doc["Events"].AsBsonArray.Select(e => e.AsBsonDocument["Payload"].IsBsonDocument ? BsonSerializer.Deserialize<EventMessage>(e.AsBsonDocument["Payload"].AsBsonDocument) : serializer.Deserialize<EventMessage>(e.AsBsonDocument["Payload"].AsByteArray)).ToList();
var streamRevision = doc["Events"].AsBsonArray.Last().AsBsonDocument["StreamRevision"].AsInt32;
return new Commit(
streamId,
streamRevision,
doc["CommitId"].AsGuid,
commitSequence,
doc["CommitStamp"].AsDateTime,
BsonSerializer.Deserialize<Dictionary<string, object>>(doc["Headers"].AsBsonDocument),
events);
}
protected override async Task ExecuteAsync(ProcessCommandOptions options, IEstablishedChannel channel, CancellationToken cancellationToken)
{
if (options.ExpectedResource != null && options.Method != CommandMethod.Get)
{
throw new Exception("The expected resource option can only be used with 'get' method");
}
var resource = _documentSerializer.Deserialize(options.JoinedResource, options.Type);
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(options.Timeout)))
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, cancellationToken))
{
var responseCommand = await channel.ProcessCommandAsync(
new Command(options.Id ?? EnvelopeId.NewId())
{
From = options.From,
To = options.To,
Method = options.Method,
Uri = new LimeUri(options.Uri),
Resource = resource
},
cancellationToken);
if (responseCommand.Status != options.ExpectedStatus)
{
throw new Exception($"Unexpected response status '{responseCommand.Status}' ({responseCommand.Reason?.ToString()})");
}
if (options.ExpectedResource != null)
{
var expectedResourceRegex = new Regex(options.ExpectedResource);
var responseResource = _documentSerializer.Serialize(responseCommand.Resource);
if (!expectedResourceRegex.IsMatch(responseResource))
{
throw new Exception($"Unexpected response resource: {responseResource}");
}
}
}
}
public async Task <TDocument> Get(string documentName)
{
var blobStorageType = Account.CreateCloudBlobClient();
var container = blobStorageType.GetContainerReference("finances");
var blobAddressUri = documentName;
var serializationStream = new MemoryStream();
try
{
var blobref = container.GetBlockBlobReference(blobAddressUri);
await blobref.DownloadToStreamAsync(serializationStream);
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
return(null);
}
throw;
}
return(documentSerializer.Deserialize(serializationStream));
}
protected async Task <Document> ParseDocumentAsync(HttpRequest request)
{
Document document = null;
MediaType mediaType;
if (MediaType.TryParse(request.Headers[HttpRequestHeader.ContentType], out mediaType))
{
using (var streamReader = new StreamReader(request.BodyStream))
{
var body = await streamReader.ReadToEndAsync().ConfigureAwait(false);
if (_traceWriter != null &&
_traceWriter.IsEnabled)
{
await _traceWriter.TraceAsync(body, DataOperation.Receive).ConfigureAwait(false);
}
document = _serializer.Deserialize(body, mediaType);
}
}
return(document);
}
internal async Task Init()
{
var content = await _storage.Read(_ref);
Data = _serializer.Deserialize <T>(content) ?? new T();
}