public async Task Update(DocumentModel model)
{
if (Disposed)
{
throw new ObjectDisposedException(nameof(model));
}
var entry = await _index.Get(model.Id);
var oldModel = _documentSerializer.Deserialize(_records.Find(entry.Item2));
_records.Update(entry.Item2, _documentSerializer.Serialize(model));
var oldDict = _indexingOperations.CreateIndexes(oldModel.Value, oldModel).Result;
foreach (var(k, v) in oldDict)
{
await _secondaryIndex.Delete(k, v);
}
var dict = await _indexingOperations.CreateIndexes(model.Value, model);
foreach (var(k, v) in dict)
{
await _secondaryIndex.Insert(k, v);
}
}
public async Task CheckIfOneIntentVariableIsValid()
{
// Arrange
LazyInput = new LazyInput(NoIntentMessage, UserIdentiy, BuilderConfiguration, DocumentSerializer, null, ArtificialIntelligenceExtension, CancellationToken);
Context = new ExtensionContext("me", "app", LazyInput, new Builder.Models.Flow(), new List <InputVariableProvider>(), null);
var target = GetTarget();
// Act
var actual = await target.GetVariableAsync("analysis", Context, CancellationToken);
// Assert
actual.ShouldBe(DocumentSerializer.Serialize(NoIntentResponse));
}
ReplaceOneResult ReplaceOneInternal(IClientSessionHandle session, FilterDefinition <TDocument> filter, TDocument replacement, CancellationToken cancellationToken = default)
{
var filteredDocs = Filter(filter);
if (filteredDocs.Count > 1)
{
throw new InvalidOperationException();
}
else if (filteredDocs.Count == 0)
{
return(ReplaceOneResult.Unacknowledged.Instance);
}
var docObject = filteredDocs[0];
var docIndex = docObjects.IndexOf(docObject);
if (docIndex == -1)
{
throw new InvalidOperationException();
}
var doc = docs[docIndex];
var docId = GetDocumentIdValue(doc);
var replacedDoc = new BsonDocument();
using (var bsonReader = new BsonDocumentWriter(replacedDoc))
{
var bsonSerializationContext = BsonSerializationContext.CreateRoot(bsonReader);
DocumentSerializer.Serialize(bsonSerializationContext, default, docObject);
private void InsertDocument(TDocument document)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
var bsonDocument = new BsonDocument();
using (var bsonReader = new BsonDocumentWriter(bsonDocument))
{
var bsonSerializationContext = BsonSerializationContext.CreateRoot(bsonReader);
DocumentSerializer.Serialize(bsonSerializationContext, new BsonSerializationArgs {
SerializeIdFirst = true
}, document);
}
var id = GetDocumentIdValue(bsonDocument);
if (docIds.ContainsKey(id))
{
throw new InvalidOperationException($"Document by id {id} already exists.");
}
var index = docIds.Count;
docIds.Add(id, index);
docs.Add(bsonDocument);
docObjects.Add(document);
}
public void DocumentTest3()
{
var a = new TestStruct {
a = 3, b = "testString"
};
var doc = DocumentSerializer.Serialize(a);
var a_deserialized = DocumentSerializer.Deserialize <TestStruct>(doc);
}
public void ВщсгьутеDictionaryTest()
{
var a = new DictionaryClass();
a.SetValues();
var serializedData = DocumentSerializer.Serialize(a);
var a1 = DocumentSerializer.Deserialize <DictionaryClass>(serializedData);
}
public void DocumentTest1()
{
var a = new TestClassA();
a.SetValues();
var doc = DocumentSerializer.Serialize(a);
var b = DocumentSerializer.Deserialize <TestClassA>(doc);
}
public void DocumentTest2()
{
var a = new DerivedA();
a.SetValues();
var doc = DocumentSerializer.Serialize(a);
var b = DocumentSerializer.Deserialize <Interface>(doc);
}
private void AssertToStringEquals(string expected, MdDocument document, MdSerializationOptions?options = null)
{
using (var writer = new StringWriter())
{
var serializer = new DocumentSerializer(writer, options);
serializer.Serialize(document);
var actual = writer.ToString();
Assert.Equal(expected, actual);
}
}
public void Serialize <T>(T instance, TextWriter writer)
{
if (!typeof(T).IsInstanceOfType((typeof(BaseDocument))))
{
PocoSerializer.Serialize(writer, instance);
}
else
{
DocumentSerializer.Serialize(writer, instance);
}
}
protected override void Ready()
{
Receive <AnalysisMessage>(r =>
{
Console.WriteLine("WORKING");
var self = Self;
var sender = Sender;
Task.Run <AnalysisDocument>(() =>
{
var analyzer = new PackageAnalyzer();
analyzer.UsedTypesOnly = r.UsedTypesOnly;
analyzer.AllEdges = r.AllEdges;
analyzer.CreateClustersForNamespaces = r.CreateClustersForNamespaces;
if (r.PackagesToAnalyze != null)
{
analyzer.PackagesToAnalyze.AddRange(r.PackagesToAnalyze);
}
var spec = SpecUtils.Deserialize(SpecUtils.Unzip(r.Spec));
return(analyzer.Execute(spec, CancellationToken));
}, CancellationToken)
.ContinueWith <object>(x =>
{
if (x.IsCanceled)
{
return(new CanceledMessage());
}
if (x.IsFaulted)
{
return(new FailedMessage {
Error = x.Exception.Dump()
});
}
Console.WriteLine("Writing response ...");
var serializer = new DocumentSerializer();
serializer.Serialize(x.Result, r.OutputFile);
return(new AnalysisResponse {
File = r.OutputFile
});
}, TaskContinuationOptions.ExecuteSynchronously)
.PipeTo(self, sender);
Become(Working);
});
}
public async Task <Document> ReplaceVariablesInDocumentAsync(Document source, UserContext userContext)
{
var documentSerialized = _serializer.Serialize(source);
var replaced = await ReplaceVariablesInStringAsync(documentSerialized, userContext);
if (replaced != documentSerialized)
{
return(_serializer.Deserialize(replaced, source.GetMediaType()));
}
return(source);
}
protected override void Ready()
{
Receive <GetInheritanceGraphMessage>(r =>
{
Console.WriteLine("WORKING");
var self = Self;
var sender = Sender;
Task.Run <TypeRelationshipDocument>(() =>
{
var analyzer = new InheritanceAnalyzer();
analyzer.IgnoreDotNetTypes = r.IgnoreDotNetTypes;
return(analyzer.Execute(r.AssemblyLocation, r.TypeToAnalyze, CancellationToken));
}, CancellationToken)
.ContinueWith <object>(x =>
{
if (x.IsCanceled)
{
return(new CanceledMessage());
}
if (x.IsFaulted)
{
return(new FailedMessage {
Error = x.Exception.Dump()
});
}
var serializer = new DocumentSerializer();
var blob = serializer.Serialize(x.Result);
return(new InheritanceGraphMessage {
Document = blob
});
}, TaskContinuationOptions.ExecuteSynchronously)
.PipeTo(self, sender);
Become(Working);
});
}
private void AssertToStringEquals(string expected, MdDocument document, MdSerializationOptions?options = null)
{
using (var writer = new StringWriter())
{
var serializer = new DocumentSerializer(writer, options);
serializer.Serialize(document);
var actual = writer.ToString();
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine("Expected:");
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine(expected);
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine("Actual:");
m_OutputHelper.WriteLine("--------------");
m_OutputHelper.WriteLine(actual);
m_OutputHelper.WriteLine("--------------");
Assert.Equal(expected, actual);
}
}
