protected virtual void Remove(Transaction trans, Relationship relationship, OGM?inItem, OGM?outItem)
{
string cypher;
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
if (inItem is not null)
{
parameters.Add("inKey", inItem !.GetKey());
}
if (outItem is not null)
{
parameters.Add("outKey", outItem !.GetKey());
}
Entity?inEntity = inItem?.GetEntity();
Entity?outEntity = outItem?.GetEntity();
string inLabel = (inEntity is null) ? "in" : $"in:{inEntity.Label.Name} {{ {inEntity.Key.Name}: $inKey }}";
string outLabel = (outEntity is null) ? "out" : $"out:{outEntity.Label.Name} {{ {outEntity.Key.Name}: $outKey }}";
cypher = $"MATCH ({inLabel})-[r:{relationship.Neo4JRelationshipType}]->({outLabel}) DELETE r";
relationship.RaiseOnRelationDelete(trans);
RawResult result = trans.Run(cypher, parameters);
}
/// <summary>
/// Writes the entity result to the response message.
/// </summary>
/// <param name="graph">The entity result to write.</param>
/// <param name="type">The type of the entity.</param>
/// <param name="messageWriter">The message writer.</param>
/// <param name="writeContext">The writing context.</param>
public override void WriteObject(
object graph,
Type type,
ODataMessageWriter messageWriter,
ODataSerializerContext writeContext)
{
RawResult rawResult = graph as RawResult;
if (rawResult != null)
{
graph = rawResult.Result;
type = rawResult.Type;
}
if (writeContext != null)
{
graph = RestierPrimitiveSerializer.ConvertToPayloadValue(graph, writeContext);
}
if (graph == null)
{
// This is to make ODataRawValueSerializer happily serialize null value.
graph = string.Empty;
}
base.WriteObject(graph, type, messageWriter, writeContext);
}
protected IReadOnlyList <T> LoadData <T>(string procedure, Func <RawRecord, T> processor)
{
bool retry;
IReadOnlyList <T>?data = null;
do
{
try
{
retry = false;
RawResult result = Transaction.RunningTransaction.Run(procedure);
data = result.Select(processor).ToArray();
}
catch (Exception clientException)
{
if (!clientException.Message.Contains("is still populating"))
{
throw;
}
retry = true;
Thread.Sleep(500);
}
} while (retry);
return(data ?? throw new NotSupportedException("Could not load the data."));
}
public void EnsureEntityIsCreatedEvenFlushedWithoutTransaction()
{
using (Transaction.Begin())
{
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Flush();
}
using (Transaction.Begin())
{
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
}
}
protected virtual void Add(Transaction trans, Relationship relationship, OGM inItem, OGM outItem)
{
string match = string.Format("MATCH (in:{0}) WHERE in.{1} = $inKey \r\n MATCH (out:{2}) WHERE out.{3} = $outKey",
inItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Label.Name,
outItem.GetEntity().Key.Name);
string create = string.Format("MERGE (in)-[outr:{0}]->(out) ON CREATE SET outr.CreationDate = ${1} SET outr += $node", relationship.Neo4JRelationshipType, relationship.CreationDate);
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("inKey", inItem.GetKey());
parameters.Add("outKey", outItem.GetKey());
Dictionary <string, object> node = new Dictionary <string, object>();
parameters.Add(relationship.CreationDate, Conversion <DateTime, long> .Convert(Transaction.RunningTransaction.TransactionDate));
parameters.Add("node", node);
string query = match + "\r\n" + create;
relationship.RaiseOnRelationCreate(trans);
RawResult result = trans.Run(query, parameters);
}
protected override void ApplyFunctionalId(FunctionalId functionalId)
{
if (functionalId == null)
{
return;
}
if (functionalId.wasApplied || functionalId.highestSeenId == -1)
{
return;
}
lock (functionalId)
{
string getFidQuery = $"CALL blueprint41.functionalid.current('{functionalId.Label}')";
RawResult result = Run(getFidQuery);
long? currentFid = result.FirstOrDefault()?.Values["Sequence"].As <long?>();
if (currentFid.HasValue)
{
functionalId.SeenUid(currentFid.Value);
}
string setFidQuery = $"CALL blueprint41.functionalid.setSequenceNumber('{functionalId.Label}', {functionalId.highestSeenId}, {(functionalId.Format == IdFormat.Numeric).ToString().ToLowerInvariant()})";
Run(setFidQuery);
functionalId.wasApplied = true;
functionalId.highestSeenId = -1;
}
}
public override void Delete(OGM item)
{
Transaction trans = Transaction.RunningTransaction;
Entity entity = item.GetEntity();
string match;
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("key", item.GetKey());
if (entity.RowVersion == null)
{
match = string.Format("MATCH (node:{0}) WHERE node.{1} = {{key}} DELETE node", entity.Label.Name, entity.Key.Name);
}
else
{
parameters.Add("lockId", Conversion <DateTime, long> .Convert(item.GetRowVersion()));
match = string.Format("MATCH (node:{0}) WHERE node.{1} = {{key}} AND node.{2} = {{lockId}} DELETE node", entity.Label.Name, entity.Key.Name, entity.RowVersion.Name);
}
Dictionary <string, object?>?customState = null;
var args = entity.RaiseOnNodeDelete(trans, item, match, parameters, ref customState);
RawResult result = trans.Run(args.Cypher, args.Parameters);
if (result.Statistics().NodesDeleted == 0)
{
throw new DBConcurrencyException($"The {entity.Name} with {entity.Key.Name} '{item.GetKey()?.ToString() ?? "<NULL>"}' was changed or deleted by another process or thread.");
}
entity.RaiseOnNodeDeleted(trans, args);
item.PersistenceState = PersistenceState.Deleted;
}
/// <summary>
/// Get sensor raw-values
/// </summary>
/// <returns></returns>
public async Task <RawResult> CheckSensorsRaw()
{
var packet = new byte[16];
packet[0] = 1;
var response = await this.SendPacket(0x6a, packet);
// Authentication is required before obtaining the value.
var err = response[0x22] | (response[0x23] << 8);
if (err == 0)
{
var result = new RawResult();
var payload = this.Decrypt(response.Skip(0x38).Take(int.MaxValue).ToArray());
var charInt = ((char)payload[0x4]).ToString();
var tmpInt = 0;
if (int.TryParse(charInt, out tmpInt))
{
// character returned
result.Temperature
= (
(
int.Parse(((char)payload[0x4]).ToString()) * 10
+ int.Parse(((char)payload[0x5]).ToString())
)
/ 10.0
);
result.Humidity
= (
(
int.Parse(((char)payload[0x6]).ToString()) * 10
+ int.Parse(((char)payload[0x7]).ToString())
)
/ 10.0
);
result.Light = int.Parse(((char)payload[0x8]).ToString());
result.AirQuality = int.Parse(((char)payload[0x0a]).ToString());
result.Noise = int.Parse(((char)payload[0xc]).ToString());
}
else
{
// int returned
result.Temperature = ((payload[0x4] * 10) + payload[0x5]) / 10.0;
result.Humidity = ((payload[0x6] * 10) + payload[0x7]) / 10.0;
result.Light = (int)payload[0x8];
result.AirQuality = (int)payload[0x0a];
result.Noise = (int)payload[0xc];
}
return(result);
}
return(null);
}
public async void Google_ParseRawReponse_Should_Return_Results_On_Valid_Input_HtmlContent()
{
var sut = this._fixture.Create <SearchResponseParser>();
var rawResult = new RawResult(GoogleSearchTestResponse.Content, SearchEngineTypeEnum.Google);
var result = await sut.ParseRawResponse(rawResult);
// test content has 2 real results
result.Should().HaveCount(2);
}
private bool HasXmlChanges()
{
if (RawResult == null)
{
return(false);
}
return(RawResult
?.Element("AssemblyComparison")
?.Element("Groups")
?.Descendants("Group")
.Any(w => w.Attribute("Change")?.Value != "None" || w.Attribute("HasErrors") != null) ?? false);
}
public async Task <IEnumerable <SearchResultItem> > ParseRawResponse(RawResult rawResult)
{
if (rawResult == null)
{
throw new ArgumentNullException(nameof(rawResult));
}
try
{
var searchEngine =
this._searchEngines
.FirstOrDefault(engine => engine.SearchEngineTypeEnum == rawResult.SearchEngineTypeEnum);
if (searchEngine == null)
{
throw new UnknownSearchEngineException(Enum.GetName(typeof(SearchEngineTypeEnum), rawResult.SearchEngineTypeEnum));
}
var browsingContext = BrowsingContext.New();
var document = await browsingContext.OpenAsync(request => request.Content(rawResult.Content));
var links = document.QuerySelectorAll(searchEngine.Selector.Links).Take(10);
var l1 = document.QuerySelectorAll(searchEngine.Selector.Text).Take(10);
var items = new List <SearchResultItem>();
foreach (var link in links)
{
var url = link.QuerySelector(searchEngine.Selector.Url)?.GetAttribute("href");
var title = link.QuerySelector(searchEngine.Selector.Title)?.TextContent;
var content = link.QuerySelector(searchEngine.Selector.Text)?.TextContent;
if (string.IsNullOrWhiteSpace(url) ||
string.IsNullOrWhiteSpace(title) ||
string.IsNullOrWhiteSpace(content))
{
continue;
}
items.Add(new SearchResultItem(title, content, url));
}
return(items);
}
catch (Exception ex)
{
this._logger.LogError(ex, $"{nameof(ParseRawResponse)} method failed)");
return(new List <SearchResultItem>());
}
}
/// <summary>
/// Processes the raw result from the merchant one web result
/// Example: response=1&responsetext=SUCCESS&authcode=123456&transactionid=5158550654&avsresponse=N&cvvresponse=N&orderid=&type=sale&response_code=100
/// </summary>
/// <param name="result"></param>
public MerchantOnePaymentResult(string result)
{
RawResult = $"&{result.TrimEnd(';')}";
ResultParts = RawResult.Split("&").ToList().Where(v => v != string.Empty).ToList();
// 1, 2, 3 are the only valid responses according to the documentation
Response = GetValue(ResultParts.FirstOrDefault(v => v.Contains("response=1") || v.Contains("response=2") || v.Contains("response=3")));
ResponseText = GetValue(ResultParts.FirstOrDefault(v => v.Contains("responsetext=")));
AuthorizationCode = GetValue(ResultParts.FirstOrDefault(v => v.Contains("authcode=")));
TransactionId = GetValue(ResultParts.FirstOrDefault(v => v.Contains("transactionid=")));
AvsResponse = GetValue(ResultParts.FirstOrDefault(v => v.Contains("avsresponse=")));
CvvResponse = GetValue(ResultParts.FirstOrDefault(v => v.Contains("cvvresponse=")));
OrderId = GetValue(ResultParts.FirstOrDefault(v => v.Contains("orderid=")));
Type = GetValue(ResultParts.FirstOrDefault(v => v.Contains("type=")));
ResponseCode = GetValue(ResultParts.FirstOrDefault(v => v.Contains("response_code=")));
}
protected virtual void Remove(Transaction trans, Relationship relationship, OGM?inItem, OGM?outItem, DateTime moment)
{
// Expected behavior time dependent relationship:
// ----------------------------------------------
//
// Match existing relation where in & out item (omit the check for the item which is null, Remove will be used to execute RemoveAll)
// IsAfter -> Remove relation
// Overlaps -> Set relation.EndDate to "moment"
Entity?inEntity = inItem?.GetEntity();
Entity?outEntity = outItem?.GetEntity();
string inLabel = (inEntity is null) ? "in" : $"in:{inEntity.Label.Name} {{ {inEntity.Key.Name}: $inKey }}";
string outLabel = (outEntity is null) ? "out" : $"out:{outEntity.Label.Name} {{ {outEntity.Key.Name}: $outKey }}";
StringBuilder sb = new StringBuilder();
sb.AppendLine($"MATCH ({inLabel})-[rel:{relationship.Neo4JRelationshipType}]->({outLabel})");
sb.AppendLine("WHERE COALESCE(rel.StartDate, $min) >= $moment");
sb.AppendLine("DELETE rel");
string delete = sb.ToString();
sb.Clear();
sb.AppendLine($"MATCH ({inLabel})-[rel:{relationship.Neo4JRelationshipType}]->({outLabel})");
sb.AppendLine("WHERE COALESCE(rel.StartDate, $min) <= $moment AND COALESCE(rel.EndDate, $max) >= $moment");
sb.AppendLine("SET rel.EndDate = $moment");
string update = sb.ToString();
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
if (inItem is not null)
{
parameters.Add("inKey", inItem !.GetKey());
}
if (outItem is not null)
{
parameters.Add("outKey", outItem !.GetKey());
}
parameters.Add("min", Conversion.MinDateTimeInMS);
parameters.Add("max", Conversion.MaxDateTimeInMS);
parameters.Add("moment", Conversion <DateTime, long> .Convert(moment));
relationship.RaiseOnRelationCreate(trans);
RawResult deleteResult = trans.Run(delete, parameters);
RawResult updateResult = trans.Run(update, parameters);
}
private string GetXmlChangeMessage()
{
if (RawResult == null)
{
return(null);
}
var errorNode = RawResult
?.Element("AssemblyComparison")
?.Element("Groups")
?.Descendants("Group")
.FirstOrDefault(w => w.Attribute("Change")?.Value != "None" || w.Attribute("HasErrors") != null);
return(errorNode?.Attribute("ErrorDetail")?.Value ??
errorNode?.Attribute("Change")?.Value);
}
public void NullWorks()
{
var result = new RawResult(ResultType.BulkString, ReadOnlySequence <byte> .Empty, true);
Assert.Equal(ResultType.BulkString, result.Type);
Assert.True(result.IsNull);
var value = result.AsRedisValue();
Assert.True(value.IsNull);
string s = value;
Assert.Null(s);
byte[] arr = (byte[])value;
Assert.Null(arr);
}
public void EnsureCanCreateAnEntity()
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Commit();
}
}
public void EnsureEntityShouldNotBeRollbackedAfterCommitedAndViceVersa()
{
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() =>
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Commit();
Transaction.Rollback();
}
});
Assert.That(exception.Message, Contains.Substring("The transaction was already committed or rolled back."));
InvalidOperationException exception2 = Assert.Throws <InvalidOperationException>(() =>
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Rollback();
Transaction.Commit();
}
});
Assert.That(exception2.Message, Contains.Substring("The transaction was already committed or rolled back."));
}
public RawResult GetResultAtPosition(long filePosition)
{
RawResult result = new RawResult();
result.Accel = new List <double>();
result.Green = new List <double>();
result.Ir = new List <double>();
result.Red = new List <double>();
using (FileStream fin = File.OpenRead(_fileName))
{
using (BinaryReader br = new BinaryReader(fin))
{
br.BaseStream.Seek(filePosition, SeekOrigin.Begin);
for (int c = 0; c < 100; c++)
{
long fileTime = br.ReadInt64();
double r = br.ReadDouble();
double ir = br.ReadDouble();
double g = br.ReadDouble();
double m = 0;
byte marker = br.ReadByte();
if (marker != 0x69)
{
br.BaseStream.Seek(-1, SeekOrigin.Current);
m = br.ReadDouble();
marker = br.ReadByte();
}
if (marker == 0x69)
{
result.Accel.Add(m);
result.Green.Add(g);
result.Ir.Add(ir);
result.Red.Add(r);
}
}
}
}
return(result);
}
public void EnsureEntityIsRolledbackWhenExceptionIsThrown()
{
Assert.Throws <Exception>(() =>
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
throw new Exception();
}
});
using (Transaction.Begin())
{
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
Assert.IsNull(record);
}
}
internal static void ExecuteBatched(string cypher, Dictionary <string, object> parameters)
{
if (!ShouldExecute)
{
return;
}
RawResultStatistics counters;
do
{
using (Transaction.Begin(true))
{
RawResult result = Parser.PrivateExecute(cypher, parameters);
Transaction.Commit();
counters = result.Statistics();
}
}while (counters.ContainsUpdates);
}
/// <summary>
/// Writes the entity result to the response message.
/// </summary>
/// <param name="graph">The entity result to write.</param>
/// <param name="type">The type of the entity.</param>
/// <param name="messageWriter">The message writer.</param>
/// <param name="writeContext">The writing context.</param>
public override void WriteObject(
object graph,
Type type,
ODataMessageWriter messageWriter,
ODataSerializerContext writeContext)
{
RawResult rawResult = graph as RawResult;
if (rawResult != null)
{
graph = rawResult.Result;
}
if (writeContext != null)
{
graph = RestierPrimitiveSerializer.ConvertToPayloadValue(writeContext.Model, graph);
}
base.WriteObject(graph, type, messageWriter, writeContext);
}
public override void Add(Relationship relationship, OGM inItem, OGM outItem, DateTime?moment, bool timedependent)
{
Transaction trans = Transaction.RunningTransaction;
Checks(relationship, inItem, outItem);
string match = string.Format("MATCH (in:{0}) WHERE in.{1} = {{inKey}} \r\n MATCH (out:{2}) WHERE out.{3} = {{outKey}}",
inItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Label.Name,
outItem.GetEntity().Key.Name);
string create = string.Format("MERGE (in)-[outr:{0}]->(out) ON CREATE SET outr.CreationDate = {{{1}}} SET outr += {{node}}", relationship.Neo4JRelationshipType, relationship.CreationDate);
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("inKey", inItem.GetKey());
parameters.Add("outKey", outItem.GetKey());
Dictionary <string, object> node = new Dictionary <string, object>();
parameters.Add(relationship.CreationDate, Conversion <DateTime, long> .Convert(trans.TransactionDate));
if (timedependent)
{
DateTime startDate = moment.HasValue ? moment.Value : DateTime.MinValue;
node.Add(relationship.StartDate, Conversion <DateTime, long> .Convert(startDate));
node.Add(relationship.EndDate, Conversion <DateTime, long> .Convert(DateTime.MaxValue));
}
parameters.Add("node", node);
string query = match + "\r\n" + create;
relationship.RaiseOnRelationCreate(trans);
RawResult result = trans.Run(query, parameters);
relationship.RaiseOnRelationCreated(trans);
//if (result.Summary.Counters.RelationshipsCreated == 0)
// throw new ApplicationException($"Unable to create relationship '{relationship.Neo4JRelationshipType}' between {inItem.GetEntity().Label.Name}({inItem.GetKey()}) and {outItem.GetEntity().Label.Name}({outItem.GetKey()})");
}
public string CleanRawResult()
{
if (string.IsNullOrEmpty(RawResult))
{
return(RawResult);
}
var lines = RawResult.SplitLines();
if (lines.First() == Text)
{
lines = lines.Skip(1).ToArray();
}
if (Regex.IsMatch(lines.Last(), @"[a-zA-Z]:\\.*?\>$"))
{
lines = lines.Take(lines.Length - 1).ToArray();
}
return(lines.Join("\r\n"));
}
private CompletionMessage CreateCompletionMessage(ref MessagePackReader reader, IInvocationBinder binder)
{
var headers = ReadHeaders(ref reader);
var invocationId = ReadInvocationId(ref reader);
var resultKind = ReadInt32(ref reader, "resultKind");
string?error = null;
object?result = null;
var hasResult = false;
switch (resultKind)
{
case ErrorResult:
error = ReadString(ref reader, "error");
break;
case NonVoidResult:
var itemType = binder.GetReturnType(invocationId);
if (itemType == typeof(RawResult))
{
result = new RawResult(reader.ReadRaw());
}
else
{
result = DeserializeObject(ref reader, itemType, "argument");
}
hasResult = true;
break;
case VoidResult:
hasResult = false;
break;
default:
throw new InvalidDataException("Invalid invocation result kind.");
}
return(ApplyHeaders(headers, new CompletionMessage(invocationId, error, result, hasResult)));
}
public void EnsureEntityIsCreatedRegardlessAnExceptionIsThrown()
{
Assert.Throws <Exception>(() =>
{
using (Transaction.Begin())
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
throw new Exception();
}
});
using (Transaction.Begin())
{
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
}
}
private List <T> Load <T>(Entity entity, NodeEventArgs args, RawResult result, Transaction trans)
where T : class, OGM
{
IReadOnlyList <Entity> concretes = entity.GetConcreteClasses();
List <T> items = new List <T>();
foreach (var record in result)
{
var node = record[0].As <RawNode>();
if (node == null)
{
continue;
}
var key = node.Properties[entity.Key.Name];
Entity?concrete = null;
if (entity.IsAbstract)
{
if (entity.NodeType != null)
{
string label = node.Properties[entity.NodeTypeName].As <string>();
concrete = concretes.FirstOrDefault(item => item.Label.Name == label);
}
if (concrete == null)
{
concrete = GetEntity(entity.Parent, node.Labels);
}
if (concrete == null)
{
throw new KeyNotFoundException($"Unable to find the concrete class for entity {entity.Name}, labels in DB are: {string.Join(", ", node.Labels)}.");
}
}
else
{
concrete = entity;
}
T?wrapper = (T?)Transaction.RunningTransaction.GetEntityByKey(concrete.Name, key);
if (wrapper == null)
{
wrapper = Activator <T>(concrete);
wrapper.SetKey(key);
args.Sender = wrapper;
args = entity.RaiseOnNodeLoaded(trans, args, node.Id, node.Labels, (Dictionary <string, object?>)node.Properties);
wrapper.SetData(args.Properties !);
wrapper.PersistenceState = PersistenceState.Loaded;
}
else
{
args.Sender = wrapper;
args = entity.RaiseOnNodeLoaded(trans, args, node.Id, node.Labels, (Dictionary <string, object?>)node.Properties);
PersistenceState tmp = wrapper.PersistenceState;
if (tmp == PersistenceState.HasUid || tmp == PersistenceState.Loaded || tmp == PersistenceState.Persisted)
{
wrapper.SetData(args.Properties !);
wrapper.PersistenceState = PersistenceState.Loaded;
}
}
items.Add(wrapper);
}
entity.RaiseOnBatchFinished(trans, args);
return(items);
}
public override void AddUnmanaged(Relationship relationship, OGM inItem, OGM outItem, DateTime?startDate, DateTime?endDate, bool fullyUnmanaged = false)
{
Transaction trans = Transaction.RunningTransaction;
Checks(relationship, inItem, outItem);
if (!fullyUnmanaged)
{
string find = string.Format(
"MATCH (in:{0})-[r:{1}]->(out:{2}) WHERE in.{3} = {{inKey}} and out.{4} = {{outKey}} and (r.{5} <= {{endDate}} OR r.{5} IS NULL) AND (r.{6} > {{startDate}} OR r.{6} IS NULL) RETURN min(COALESCE(r.{5}, {{MinDateTime}})) as MinStartDate, max(COALESCE(r.{6}, {{MaxDateTime}})) as MaxEndDate, count(r) as Count",
inItem.GetEntity().Label.Name,
relationship.Neo4JRelationshipType,
outItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Key.Name,
relationship.StartDate,
relationship.EndDate);
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("inKey", inItem.GetKey());
parameters.Add("outKey", outItem.GetKey());
parameters.Add("startDate", Conversion <DateTime, long> .Convert(startDate ?? DateTime.MinValue));
parameters.Add("endDate", Conversion <DateTime, long> .Convert(endDate ?? DateTime.MaxValue));
parameters.Add("MinDateTime", Conversion <DateTime, long> .Convert(DateTime.MinValue));
parameters.Add("MaxDateTime", Conversion <DateTime, long> .Convert(DateTime.MaxValue));
RawResult result = trans.Run(find, parameters);
RawRecord record = result.FirstOrDefault();
int count = record["Count"].As <int>();
if (count > 0)
{
DateTime?minStartDate = Conversion <long?, DateTime?> .Convert(record["MinStartDate"].As <long?>());
DateTime?maxEndDate = Conversion <long?, DateTime?> .Convert(record["MaxEndDate"].As <long?>());
if (startDate > minStartDate)
{
startDate = minStartDate ?? DateTime.MinValue;
}
if (endDate < maxEndDate)
{
endDate = maxEndDate ?? DateTime.MaxValue;
}
}
string delete = string.Format(
"MATCH (in:{0})-[r:{1}]->(out:{2}) WHERE in.{3} = {{inKey}} and out.{4} = {{outKey}} and (r.{5} <= {{endDate}}) AND (r.{6} > {{startDate}}) DELETE r",
inItem.GetEntity().Label.Name,
relationship.Neo4JRelationshipType,
outItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Key.Name,
relationship.StartDate,
relationship.EndDate);
trans.Run(delete, parameters);
}
string match = string.Format("MATCH (in:{0}) WHERE in.{1} = {{inKey}} MATCH (out:{2}) WHERE out.{3} = {{outKey}}",
inItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Label.Name,
outItem.GetEntity().Key.Name);
string create = string.Format("CREATE (in)-[outr:{0} {{node}}]->(out)", relationship.Neo4JRelationshipType);
Dictionary <string, object> node = new Dictionary <string, object>();
node.Add(relationship.CreationDate, Conversion <DateTime, long> .Convert(trans.TransactionDate));
if (relationship.IsTimeDependent)
{
node.Add(relationship.StartDate, Conversion <DateTime, long> .Convert(startDate ?? DateTime.MinValue));
node.Add(relationship.EndDate, Conversion <DateTime, long> .Convert(endDate ?? DateTime.MaxValue));
}
Dictionary <string, object?> parameters2 = new Dictionary <string, object?>();
parameters2.Add("inKey", inItem.GetKey());
parameters2.Add("outKey", outItem.GetKey());
parameters2.Add("node", node);
string query = match + "\r\n" + create;
relationship.RaiseOnRelationCreate(trans);
trans.Run(query, parameters2);
relationship.RaiseOnRelationCreated(trans);
}
public override void Remove(Relationship relationship, OGM inItem, OGM outItem, DateTime?moment, bool timedependent)
{
Transaction trans = Transaction.RunningTransaction;
Checks(relationship, inItem, outItem);
string cypher;
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("inKey", inItem.GetKey());
parameters.Add("outKey", outItem.GetKey());
if (timedependent)
{
parameters.Add("moment", Conversion <DateTime, long> .Convert(moment ?? DateTime.MinValue));
// End Current
cypher = string.Format(
"MATCH (in:{0})-[r:{1}]->(out:{2}) WHERE in.{3} = {{inKey}} and out.{4} = {{outKey}} and (r.{6} > {{moment}} OR r.{6} IS NULL) AND (r.{5} <={{moment}} OR r.{5} IS NULL) SET r.EndDate = {{moment}}",
inItem.GetEntity().Label.Name,
relationship.Neo4JRelationshipType,
outItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Key.Name,
relationship.StartDate,
relationship.EndDate);
trans.Run(cypher, parameters);
// Remove Future
cypher = string.Format(
"MATCH (in:{0})-[r:{1}]->(out:{2}) WHERE in.{3} = {{inKey}} and out.{4} = {{outKey}} and r.{5} > {{moment}} DELETE r",
inItem.GetEntity().Label.Name,
relationship.Neo4JRelationshipType,
outItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Key.Name,
relationship.StartDate);
relationship.RaiseOnRelationDelete(trans);
RawResult result = trans.Run(cypher, parameters);
relationship.RaiseOnRelationDeleted(trans);
if (result.Statistics().RelationshipsDeleted == 0)
{
throw new ApplicationException($"Unable to delete time dependent future relationship '{relationship.Neo4JRelationshipType}' between {inItem.GetEntity().Label.Name}({inItem.GetKey()}) and {outItem.GetEntity().Label.Name}({outItem.GetKey()})");
}
}
else
{
cypher = string.Format(
"MATCH (in:{0})-[r:{1}]->(out:{2}) WHERE in.{3} = {{inKey}} and out.{4} = {{outKey}} DELETE r",
inItem.GetEntity().Label.Name,
relationship.Neo4JRelationshipType,
outItem.GetEntity().Label.Name,
inItem.GetEntity().Key.Name,
outItem.GetEntity().Key.Name);
relationship.RaiseOnRelationDelete(trans);
RawResult result = trans.Run(cypher, parameters);
relationship.RaiseOnRelationDeleted(trans);
if (result.Statistics().RelationshipsDeleted == 0)
{
throw new ApplicationException($"Unable to delete relationship '{relationship.Neo4JRelationshipType}' between {inItem.GetEntity().Label.Name}({inItem.GetKey()}) and {outItem.GetEntity().Label.Name}({outItem.GetKey()})");
}
}
}
protected override bool SetResultCore(PhysicalConnection connection, Message message, RawResult result)
{
switch (result.Type)
{
case ResultType.BulkString:
var raw = result.GetString();
var clients = Parse(raw);
SetResult(message, clients);
return(true);
}
return(false);
}
public async Task <SearchResult> SearchOnlineAsync(string question, IEnumerable <SearchEngineTypeEnum> searchEngineTypes = null)
{
if (string.IsNullOrWhiteSpace(question))
{
throw new ArgumentNullException(nameof(question));
}
try
{
var searchEngines = searchEngineTypes == null
? this.SearchEngines
: this.SearchEngines
.Where(engine =>
searchEngineTypes
.Any(engineType =>
(int)engineType == engine.Key));
var engineSearchTasks = new List <Task <RawResult> >();
using var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
foreach (var pair in searchEngines)
{
var searchTask = pair.Value.Search(question, token);
engineSearchTasks.Add(searchTask);
}
var foundedItems = new List <SearchResultItem>();
RawResult rawResult = null;
while (engineSearchTasks.Count > 0)
{
var completedTask = await Task.WhenAny(engineSearchTasks);
engineSearchTasks.Remove(completedTask);
rawResult = await completedTask;
var parsedItems = await this._searchResponseParser.ParseRawResponse(rawResult);
var parsedList = parsedItems.ToList();
if (parsedList.Any())
{
tokenSource.Cancel();
foundedItems.AddRange(parsedList);
break;
}
}
if (rawResult == null)
{
return(null);
}
var searchResult = new SearchResult(question, foundedItems, DateTime.Now, rawResult.SearchEngineTypeEnum);
await this._searchResultRepository.AddAsync(searchResult);
this._searchResultsCache.Add(searchResult);
return(searchResult);
}
catch (Exception ex)
{
this._logger.LogError(ex, $"{nameof(SearchOnlineAsync)} method failed");
return(null);
}
}
//http://jakubdziworski.github.io/enkel/2016/03/11/enkel_2_technology.html
public void ParseLines(ref string text, string relativePath)
{
int currentIndex = 0;
int currentLine = 1;
int currentColumn = 0;
var rawResult = new RawResult();
rawResult.path = relativePath;
var tokenizer = new Lexer();
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Comment,
new Regex(@"//.*"),
true));
/*
https://msdn.microsoft.com/en-us/library/az24scfc(v=vs.110).aspx
https://msdn.microsoft.com/en-us/library/h21280bw.aspx
http://stackoverflow.com/questions/13024073/regex-c-sharp-extract-text-within-double-quotes
*/
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Comment,
new Regex(@"\/\*(.|\n)*?\*\/"),
true));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.String,
new Regex("\"[^\"]*\"|\'[^\']*\'")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Assignment,
new Regex(@"\=")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Parenthesis_Open,
new Regex(@"\(")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Parenthesis_Close,
new Regex(@"\)")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Bracket_Open,
new Regex(@"\[")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Bracket_Close,
new Regex(@"\]")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Operator,
new Regex(@"\*|\/|\+|\-|\.\.")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Dot,
new Regex(@"\.")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Colon,
new Regex(@"\:")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Comma,
new Regex(@"\,")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Number,
new Regex(@"\d+")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Tree_Reference,
new Regex(@"\$\w+")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Using_Reference,
new Regex(@"using [\w\.\d]+")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Include_Reference,
new Regex(@"include [\w\.\d]+")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Variable,
new Regex(@"\w+")));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Indentation,
new Regex(@"\t+"),
false));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Whitespace,
new Regex(@"[^\S\r\n]+"),
true));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Newline,
new Regex(@"\r\n|\r|\n"),
true));
tokenizer.AddDefinition(new TokenDefinition(
TokenType.Semicolon,
new Regex(@";")));
var tokens = tokenizer.Tokenize(text);
var tokenList = new List<Token>();
foreach (var token in tokens)
{
tokenList.Add(token);
Debug.Log(token);
}
//tokenList = tokenList;
}
