public void Camelcase_Mixed_Mode_Combined_Reversed()
{
var model = GraphModel
.FromBaseTypes <Vertex, Edge>()
.ConfigureProperties(pm => pm
.UseCamelCaseNames())
.ConfigureElements(em => em
.UseCamelCaseLabels());
model
.VerticesModel
.Metadata
.TryGetValue(typeof(TimeFrame))
.Map(x => x.Label)
.Should()
.BeEqual("timeFrame");
model
.PropertiesModel
.Metadata
.TryGetValue(typeof(Person).GetProperty(nameof(Person.RegistrationDate)))
.Map(x => x.Name)
.Should()
.BeSome("registrationDate");
}
public static object SetUpConfig()
{
return(g.ConfigureEnvironment(env => env
.UseLogger(LoggerFactory
.Create(builder => builder
.AddFilter(__ => true)
// .AddConsole()
)
.CreateLogger("Queries")))
.ConfigureEnvironment(env => env.UseModel(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
//For CosmosDB, we exclude the 'PartitionKey' property from being included in updates.
.ConfigureProperties(model => model
.ConfigureElement <Vertex>(conf => conf
.IgnoreOnUpdate(x => x.PartitionKey))))
//Disable query logging for a noise free console output.
//Enable logging by setting the verbosity to anything but None.
.ConfigureOptions(options => options
.SetValue(WebSocketGremlinqOptions.QueryLogLogLevel, LogLevel.None))
.UseCosmosDb(builder => builder
.At(new Uri("wss://emmacosmos.gremlin.cosmos.azure.com:443/"), "AirlineGremlin2", "Airline1")
.AuthenticateBy("bEtnhLU5vuwh28rmSTvxWQNZiKBAznXM94kbrST4MgfwQpPnJaosvbIN1i5U6dc3enmJffR3CTBpqO48xacZYw==")
.ConfigureWebSocket(_ => _
.ConfigureGremlinClient(client => client
.ObserveResultStatusAttributes((requestMessage, statusAttributes) =>
{
//Uncomment to log request charges for CosmosDB.
//if (statusAttributes.TryGetValue("x-ms-total-request-charge", out var requestCharge))
// env.Logger.LogInformation($"Query {requestMessage.RequestId} had a RU charge of {requestCharge}.");
}))))));
}
public async Task Configuration_After_Model_Changes()
{
var model = GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureProperties(pm => pm
.ConfigureMemberMetadata(m => m
.UseCamelCaseNames())
.ConfigureElement <Person>(conf => conf
.IgnoreAlways(p => p.Name)))
.ConfigureElements(em => em
.UseCamelCaseLabels());
await Verify((
model
.VerticesModel
.Metadata
.GetValueOrDefault(typeof(TimeFrame)),
model
.PropertiesModel
.MemberMetadata
.GetValueOrDefault(typeof(Person).GetProperty(nameof(Person.RegistrationDate)) !),
model
.PropertiesModel
.MemberMetadata
.GetValueOrDefault(typeof(Person).GetProperty(nameof(Person.Name)) !)));
}
public Program(IGremlinQuerySource gremlinQuerySource)
{
_gremlinQuerySource = gremlinQuerySource.ConfigureEnvironment(env => env
.UseModel(GraphModel.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())))
.UseCosmosDb(new Uri(""), "", "", "");
}
public Program()
{
_g = g
.ConfigureEnvironment(env => env //We call ConfigureEnvironment twice so that the logger is set on the environment from now on.
.UseLogger(LoggerFactory
.Create(builder => builder
.AddFilter(__ => true)
.AddConsole())
.CreateLogger("Queries")))
.ConfigureEnvironment(env => env
//Since the Vertex and Edge classes contained in this sample implement IVertex resp. IEdge,
//setting a model is actually not required as long as these classes are discoverable (i.e. they reside
//in a currently loaded assembly). We explicitly set a model here anyway.
.UseModel(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
//For CosmosDB, we exclude the 'PartitionKey' property from being included in updates.
.ConfigureProperties(model => model
.ConfigureElement <Vertex>(conf => conf
.IgnoreOnUpdate(x => x.PartitionKey))))
//Disable query logging for a noise free console output.
//Enable logging by setting the verbosity to anything but None.
.ConfigureOptions(options => options
.SetValue(WebSocketGremlinqOptions.QueryLogLogLevel, LogLevel.None))
#if GremlinServer
.UseGremlinServer(builder => builder
.AtLocalhost()));
public async Task TryGetFilterLabels_does_not_include_abstract_type()
{
var model = GraphModel.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesFromAppDomain());
await Verify(model.VerticesModel
.TryGetFilterLabels(typeof(Authority), FilterLabelsVerbosity.Maximum) ?? ImmutableArray <string> .Empty);
}
public void Relax_outside_hierarchy()
{
GraphModel.FromBaseTypes <Vertex, Edge>().Relax()
.VerticesModel
.TryGetConstructiveLabel(typeof(VertexOutsideHierarchy))
.Should()
.BeSome("VertexOutsideHierarchy");
}
public void Relax_in_hierarchy_inside_model()
{
GraphModel.FromBaseTypes <Vertex, Edge>().Relax()
.VerticesModel
.TryGetConstructiveLabel(typeof(Person))
.Should()
.BeSome("Person");
}
public void No_Relax_in_hierarchy_outside_model()
{
GraphModel.FromBaseTypes <Vertex, Edge>()
.VerticesModel
.TryGetConstructiveLabel(typeof(VertexInsideHierarchy))
.Should()
.BeNone();
}
public static GremlinqSetup UseGremlinServer <TVertex, TEdge>(this GremlinqSetup setup)
{
return(setup
.UseGremlinServer()
.UseModel(GraphModel
.FromBaseTypes <TVertex, TEdge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())));
}
public void Lowercase()
{
GraphModel.FromBaseTypes <Vertex, Edge>()
.WithLowercaseLabels()
.VerticesModel
.TryGetConstructiveLabel(typeof(Person))
.Should()
.BeSome("person");
}
public void Camelcase_Edges()
{
GraphModel.FromBaseTypes <Vertex, Edge>()
.WithCamelcaseLabels()
.EdgesModel
.TryGetConstructiveLabel(typeof(LivesIn))
.Should()
.BeEqual("livesIn");
}
public static GremlinqSetup UseJanusGraph <TVertex, TEdge>(this GremlinqSetup setup, Action <ProviderSetup <IJanusGraphConfigurator> >?extraSetupAction = null)
{
return(setup
.UseJanusGraph(extraSetupAction)
.ConfigureEnvironment(env => env
.UseModel(GraphModel
.FromBaseTypes <TVertex, TEdge>(lookup => lookup
.IncludeAssembliesOfBaseTypes()))));
}
public async Task Hierarchy_inside_model()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.VerticesModel
.Metadata
.GetValueOrDefault(typeof(Person)));
}
public async Task Outside_hierarchy()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.VerticesModel
.Metadata
.TryGetValue(typeof(VertexOutsideHierarchy), out var _));
}
public async Task Configuration_Unconfigured()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.PropertiesModel
.MemberMetadata
.GetValueOrDefault(typeof(Person).GetProperty(nameof(Person.Name)) !));
}
public void CamelcaseLabel_Verticies()
{
GraphModel.FromBaseTypes <Vertex, Edge>()
.WithCamelcaseLabels()
.VerticesModel
.TryGetConstructiveLabel(typeof(TimeFrame))
.Should()
.BeEqual("timeFrame");
}
public void Outside_hierarchy()
{
GraphModel
.FromBaseTypes <Vertex, Edge>()
.VerticesModel
.Metadata
.TryGetValue(typeof(VertexOutsideHierarchy))
.Should()
.BeNone();
}
async static Task Main(string[] args)
{
var logger = LoggerFactory
.Create(builder => builder
.AddFilter(__ => true)
.AddConsole())
.CreateLogger("Queries");
_g = g
.ConfigureEnvironment(env => env
.UseLogger(logger)
//Since the Vertex and Edge classes contained in this sample implement IVertex resp. IEdge,
//setting a model is actually not required as long as these classes are discoverable (i.e. they reside
//in a currently loaded assembly). We explicitly set a model here anyway.
.UseModel(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
//For CosmosDB, we exclude the 'PartitionKey' property from being included in updates.
.ConfigureProperties(model => model
.ConfigureElement <Vertex>(conf => conf
.IgnoreOnUpdate(x => x.PartitionKey))))
.UseJanusGraph(builder => builder
.At("ws://192.168.181.5:31410")
//Disable query logging for a noise free console output.
//Enable logging by setting the verbosity to anything but None.
.ConfigureQueryLoggingOptions(o => o
.SetQueryLoggingVerbosity(QueryLoggingVerbosity.None))));
var marko = await _g
.AddV(new Person { Name = "Marko", Age = 29 })
.AddV(new Person {
Name = "Marko", Age = 29
})
.AddV(new Person {
Name = "Marko", Age = 29
})
.AddV(new Person {
Name = "Marko", Age = 29
})
.AddV(new Person {
Name = "Marko", Age = 29
})
.AddV(new Person {
Name = "Marko", Age = 29
})
.AddV(new Person {
Name = "Marko", Age = 29
})
.AddV(new Person {
Name = "Marko", Age = 29
})
.FirstAsync();
await GetEntities();
}
public static GremlinqSetup UseCosmosDb <TVertex, TEdge>(this GremlinqSetup setup, Expression <Func <TVertex, object> > partitionKeyExpression)
{
return(setup
.UseCosmosDb()
.UseModel(GraphModel
.FromBaseTypes <TVertex, TEdge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureProperties(model => model
.ConfigureElement <TVertex>(conf => conf
.IgnoreOnUpdate(partitionKeyExpression)))));
}
public async Task CamelcaseLabel_Vertices()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureElements(em => em
.UseCamelCaseLabels())
.VerticesModel
.Metadata
.TryGetValue(typeof(TimeFrame)));
}
public void Hierarchy_inside_model()
{
GraphModel
.FromBaseTypes <Vertex, Edge>()
.VerticesModel
.Metadata
.TryGetValue(typeof(Person))
.Map(x => x.Label)
.Should()
.BeSome("Person");
}
public void Outside_hierarchy()
{
GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.VerticesModel
.Metadata
.TryGetValue(typeof(VertexOutsideHierarchy))
.Should()
.BeNone();
}
public async Task Repro()
{
await g
.ConfigureEnvironment(env => env
.UseModel(GraphModel.FromBaseTypes <VertexBaseAbstract, Edge>())
.EchoGroovyGremlinQuery())
.V <Thing>("id")
.Update(new Thing())
.Cast <string>()
.Verify();
}
public async Task Camelcase_Edges()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureElements(em => em
.UseCamelCaseLabels())
.EdgesModel
.Metadata
.GetValueOrDefault(typeof(LivesIn)));
}
public async Task Lowercase()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureElements(em => em
.UseLowerCaseLabels())
.VerticesModel
.Metadata
.GetValueOrDefault(typeof(Person)));
}
public async Task Lowercase_Identifier_By_ParameterExpression()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureProperties(pm => pm
.ConfigureMemberMetadata(m => m
.UseLowerCaseNames()))
.PropertiesModel
.MemberMetadata
.GetValueOrDefault(typeof(Person).GetProperty(nameof(Person.RegistrationDate)) !));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddGremlinq(setup => setup
.ConfigureEnvironment(e => e
.UseModel(GraphModel.FromBaseTypes <TestClassLib.Vertex, Edge>(x => x.IncludeAssembliesOfBaseTypes())
.ConfigureProperties(model =>
model.ConfigureElement <Vertex>(config => config.IgnoreOnUpdate(x => x.group))))
.UseCosmosDb(builder => builder
.At(YOUR_CONNECTION_HERE)
.AuthenticateBy(
YOUR_KEY_HERE))));
}
public async Task Configuration_IgnoreAlways_Id()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureProperties(pm => pm
.ConfigureElement <Vertex>(conf => conf
.IgnoreAlways(p => p.Id)))
.PropertiesModel
.MemberMetadata
.GetValueOrDefault(typeof(Person).GetProperty(nameof(Person.Id)) !));
}
public async Task Configuration_can_be_found_for_derived_class()
{
await Verify(GraphModel
.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())
.ConfigureProperties(pm => pm
.ConfigureElement <Authority>(conf => conf
.IgnoreOnUpdate(p => p.Name)))
.PropertiesModel
.MemberMetadata
.GetValueOrDefault(typeof(Person).GetProperty(nameof(Person.Name)) !));
}
