async public Task AddHotel(Hotel newHotel, string travelIdentity)
{
await GraphClient.ConnectAsync();
var resp = await GraphClient.Cypher
.Match("(travel:Travel)--(hotel:Hotel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.Return(hotel => hotel.As <Hotel>())
.ResultsAsync;
if (resp.Any())
{
throw new TravelPlannerException(409, "Hotel for this travel already exists");
}
try
{
await GraphClient.Cypher
.Create("(hotel:Hotel $hotel)")
.WithParam("hotel", newHotel)
.Return(hotel => hotel.As <Hotel>())
.ResultsAsync;
}
catch (ClientException ce)
{
if (!ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw ce;
}
}
await GraphClient.Cypher
.Match("(hotel:Hotel)", "(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.AndWhere((Hotel hotel) => hotel.HotelId == newHotel.HotelId)
.Merge("(travel)-[r:HasHotel]->(hotel)")
.Return(hotel => hotel.As <Hotel>())
.ResultsAsync;
var registeredLocations = await GraphClient.Cypher
.Match("(location:Location)--(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.Return(location => location.As <Location>())
.ResultsAsync;
if (registeredLocations.Any())
{
var registeredLocation = registeredLocations.First();
await GraphClient.Cypher
.Match("(hotel:Hotel)", "(location:Location)")
.Where((Hotel hotel) => hotel.HotelId == newHotel.HotelId)
.AndWhere((Location location) => location.LocationId == registeredLocation.LocationId)
.Merge("(location)-[r:HasHotel]->(hotel)")
.Return(hotel => hotel.As <Hotel>())
.ResultsAsync;
}
}
public async Task <ICollection <DivisionDetails> > GetDivisionAsync(Guid userId)
{
await _client.ConnectAsync();
var query = _client.Cypher
.OptionalMatch("(user:User)-[:YOUR_DIVISION]->(division:Division)")
.Where((DivisionDetails user) => user.Id == userId)
.Return(division => division.As <DivisionDetails>());
return((await query.ResultsAsync).ToList());
}
public async Task <UserDetails> GetUserAsync(Guid id)
{
await _client.ConnectAsync();
var query = _client.Cypher
.Match("(user:User)")
.Where((UserDetails user) => user.Id == id)
.Return(user => user.As <UserDetails>())
.Limit(1);
return((await query.ResultsAsync).FirstOrDefault());
}
public async Task <BookDetails> GetBookAsync(Guid id)
{
await _client.ConnectAsync();
var query = _client.Cypher
.Match("(book:Book)")
.Where((BookDetails book) => book.Id == id)
.Return(book => book.As <BookDetails>())
.Limit(1);
return((await query.ResultsAsync).FirstOrDefault());
}
public async Task <BookDetails> GetUserBookAsync(Guid userId, Guid bookId)
{
await _client.ConnectAsync();
var query = _client.Cypher
.OptionalMatch("(user:User)-[:HAVE]->(book:Book)")
.Where((UserDetails user) => user.Id == userId)
.AndWhere((BookDetails book) => book.Id == bookId)
.Return(book => book.As <BookDetails>());
return((await query.ResultsAsync).FirstOrDefault());
}
async public Task AddTour(Tour newTour, string travelIdentity)
{
await GraphClient.ConnectAsync();
try
{
await GraphClient.Cypher
.Create("(tour:Tour $tour)")
.WithParam("tour", newTour)
.Return(tour => tour.As <Tour>())
.ResultsAsync;
}
catch (ClientException ce)
{
if (!ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw ce;
}
}
var t = await GraphClient.Cypher
.Match("(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.Return(travel => travel.As <Travel>())
.ResultsAsync;
var addedTour = await GraphClient.Cypher
.Match("(tour:Tour)", "(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.AndWhere((Tour tour) => tour.Id == newTour.Id)
.Merge("(travel)-[r:HasTour]->(tour)")
.Return(tour => tour.As <Tour>())
.ResultsAsync;
var registeredLocations = await GraphClient.Cypher
.Match("(location:Location)--(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.Return(location => location.As <Location>())
.ResultsAsync;
if (registeredLocations.Any())
{
var registeredLocation = registeredLocations.First();
await GraphClient.Cypher
.Match("(tour:Tour)", "(location:Location)")
.Where((Tour tour) => tour.Id == newTour.Id)
.AndWhere((Location location) => location.LocationId == registeredLocation.LocationId)
.Merge("(location)-[r:HasTour]->(tour)")
.Return(tour => tour.As <Tour>())
.ResultsAsync;
}
}
public async Task SerializesDateTimeOffsetsProperly()
{
var mockSession = new Mock <IAsyncSession>();
mockSession.Setup(s => s.RunAsync("CALL dbms.components()")).Returns(Task.FromResult <IResultCursor>(new ServerInfo()));
var mockDriver = new Mock <IDriver>();
mockDriver.Setup(d => d.AsyncSession(It.IsAny <Action <SessionConfigBuilder> >())).Returns(mockSession.Object);
var bgc = new BoltGraphClient(mockDriver.Object);
await bgc.ConnectAsync();
var cwd = new ClassWithDateTimeOffset {
Dt = new DateTimeOffset(new DateTime(2000, 1, 1), TimeSpan.FromHours(1))
};;
var cfq = bgc.Cypher.Create("(c)").WithParam("testParam", cwd);
var expectedParameters = new Dictionary <string, object>
{
{
"testParam", new Dictionary <string, object> {
{ "Dt", JsonConvert.SerializeObject(cwd.Dt).Trim('\"') }
}
}
};
var query = cfq.Query;
query.ToNeo4jDriverParameters(bgc).IsEqualTo(expectedParameters).Should().BeTrue();
}
public async Task SerializesGuidsProperlyWhenAutoGeneratingParams()
{
var mockSession = new Mock <IAsyncSession>();
mockSession.Setup(s => s.RunAsync("CALL dbms.components()")).Returns(Task.FromResult <IResultCursor>(new ServerInfo()));
var mockDriver = new Mock <IDriver>();
mockDriver.Setup(d => d.AsyncSession(It.IsAny <Action <SessionConfigBuilder> >())).Returns(mockSession.Object);
var bgc = new BoltGraphClient(mockDriver.Object);
await bgc.ConnectAsync();
var cwg = new ClassWithGuid();
var cfq = bgc.Cypher.Create("(c)").Where((ClassWithGuid c) => c.Id == cwg.Id);
var expectedParameters = new Dictionary <string, object> {
{ "p0", $"{cwg.Id}" }
};
var query = cfq.Query;
query.ToNeo4jDriverParameters(bgc).IsEqualTo(expectedParameters).Should().BeTrue();
}
public async Task ReturnsQueryStats_WhenInTransaction()
{
BoltClientTestHelper.GetDriverAndSession(out var mockDriver, out _, out _);
bool completedRaised = false;
QueryStats stats = null;
var client = new BoltGraphClient(mockDriver);
client.OperationCompleted += (o, e) =>
{
stats = e.QueryStats;
completedRaised = true;
};
await client.ConnectAsync();
using (var tx = client.BeginTransaction())
{
await client.Cypher.WithQueryStats.Match("n").Return(n => n.Count()).ExecuteWithoutResultsAsync();
completedRaised.Should().BeTrue();
stats.Should().NotBeNull();
}
}
private static async Task SerializesObjectProperlyWitDifferentStrategies(IDictionary <string, object> expectedParameters, Action <BoltGraphClient> setupClient)
{
var mockSession = new Mock <IAsyncSession>();
mockSession.Setup(s => s.RunAsync("CALL dbms.components()"))
.Returns(Task.FromResult <IResultCursor>(new ServerInfo()));
var mockDriver = new Mock <IDriver>();
mockDriver.Setup(d => d.AsyncSession(It.IsAny <Action <SessionConfigBuilder> >())).Returns(mockSession.Object);
var bgc = new BoltGraphClient(mockDriver.Object);
await bgc.ConnectAsync();
setupClient(bgc);
var obj = new
{
Param1 = 1,
Param2 = (object)null
};
var cfq = bgc.Cypher.Create("MATCH (node:FakeNode) SET node += $param").WithParam("param", obj);
var query = cfq.Query;
var t = query.ToNeo4jDriverParameters(bgc);
t.IsEqualTo(expectedParameters).Should().BeTrue();
}
//Issue from https://github.com/DotNet4Neo4j/Neo4jClient/issues/385
public async Task SerializerShouldTakeIntoAccountTheContractResolverProvided()
{
var mockSession = new Mock <IAsyncSession>();
mockSession.Setup(s => s.RunAsync("CALL dbms.components()")).Returns(Task.FromResult <IResultCursor>(new ServerInfo()));
var mockDriver = new Mock <IDriver>();
mockDriver.Setup(d => d.AsyncSession(It.IsAny <Action <SessionConfigBuilder> >())).Returns(mockSession.Object);
var bgc = new BoltGraphClient(mockDriver.Object);
bgc.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
await bgc.ConnectAsync();
var cwa = new ClassWithSomeNeo4jIgnoreAttributes {
Text = "foo"
};
var cfq = bgc.Cypher.Create("(c)").WithParam("testParam", cwa);
var expectedParameters = new Dictionary <string, object> {
{ "testParam", new Dictionary <string, object> {
{ "text", "foo" }, { "testInt", 0 }
} }
};
var query = cfq.Query;
query.ToNeo4jDriverParameters(bgc).IsEqualTo(expectedParameters).Should().BeTrue();
}
public async Task SkipsOverExtraFieldsInDbmsComponents()
{
const string uri = "bolt://localhost";
var record1Mock = new Mock <IRecord>();
record1Mock.Setup(r => r["name"]).Returns("another-value");
var record2Mock = new Mock <IRecord>();
record2Mock.Setup(r => r["name"]).Returns("neo4j kernel");
record2Mock.Setup(r => r["versions"]).Returns(new List <object> {
"3.2.3"
});
var testSr = new TestStatementResult(new[] { record1Mock.Object, record2Mock.Object });
var sessionMock = new Mock <IAsyncSession>();
sessionMock
.Setup(s => s.RunAsync("CALL dbms.components()"))
.Returns(Task.FromResult <IResultCursor>(testSr));
var driverMock = new Mock <IDriver>();
driverMock.Setup(d => d.AsyncSession(It.IsAny <Action <SessionConfigBuilder> >())).Returns(sessionMock.Object);
var bgc = new BoltGraphClient(driverMock.Object);
await bgc.ConnectAsync();
bgc.ServerVersion.Should().Be(new Version(3, 2, 3));
}
public async Task <IRawGraphClient> CreateAndConnectBoltGraphClient()
{
var bgc = new BoltGraphClient(MockDriver.Object);
await bgc.ConnectAsync();
MockDriver.Invocations.Clear();
return(bgc);
}
public async Task SetsTheVersionOfTheServer()
{
var driverMock = DriverTestHelper.MockDriverWithConnectionSet();
var bgc = new BoltGraphClient(driverMock.Object);
await bgc.ConnectAsync();
bgc.ServerVersion.Should().Be(new Version(3, 2, 3));
}
public async Task SetIsConnected()
{
var driverMock = DriverTestHelper.MockDriverWithConnectionSet();
var bgc = new BoltGraphClient(driverMock.Object);
await bgc.ConnectAsync();
bgc.IsConnected.Should().BeTrue();
}
async public Task <Location> AddLocation(Location newLocation, string travelIdentity)
{
await GraphClient.ConnectAsync();
var resp = await GraphClient.Cypher
.Match("(travel:Travel)--(location:Location)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.Return(location => location.As <Location>())
.ResultsAsync;
if (resp.Any())
{
throw new TravelPlannerException(409, "Location for this travel already exists");
}
try
{
await GraphClient.Cypher
.Create("(location:Location $location)")
.WithParam("location", newLocation)
.Return(location => location.As <Location>())
.ResultsAsync;
}
catch (ClientException ce)
{
if (!ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw ce;
}
}
var response = await GraphClient.Cypher
.Match("(location:Location)", "(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.AndWhere((Location location) => location.LocationId == newLocation.LocationId)
.Merge("(travel)-[r:HasLocation]->(location)")
.Return(location => location.As <Location>())
.ResultsAsync;
if (response.Any())
{
return(response.First());
}
return(null);
}
private IGraphClient GetGraphClient(IServiceProvider provider)
{
//Create our IGraphClient instance.
var client = new BoltGraphClient(Configuration["Neo4j:Host"], Configuration["Neo4j:User"], Configuration["Neo4j:Pass"]);
//We have to connect - as this is fully async, we need to 'Wait()'
client.ConnectAsync().Wait();
return(client);
}
public static IGraphClient CreateGraphClient()
{
var client = new BoltGraphClient(new Uri("BOLT_URL"), "NEO4J_USER", "NEO4J_PASSWORD")
{
JsonContractResolver = new CamelCasePropertyNamesContractResolver()
};
client.ConnectAsync().Wait();
return(client.WithAnnotations <GraphContext>());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddScoped <IRedisConnectionBuilder, RedisConnectionBuilder>();
services.AddScoped <IRedisService, RedisService>();
services.AddScoped <IRedisRepository, RedisRepository>();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "back", Version = "v1"
});
});
var graphClient = new BoltGraphClient("bolt://localhost:7687", "neo4j", "adminadmin");
graphClient.ConnectAsync();
services.AddSingleton <IBoltGraphClient>(graphClient);
services.AddScoped(typeof(IRentererRepository), typeof(RentererRepository));
services.AddScoped(typeof(IRentererService), typeof(RentererService));
services.AddScoped(typeof(IRenteeService), typeof(RenteeService));
services.AddScoped(typeof(IRenteeRepository), typeof(RenteeRepository));
services.AddScoped(typeof(IContestRepository), typeof(ContestRepository));
services.AddScoped(typeof(ISonyRepository), typeof(SonyRepository));
services.AddScoped(typeof(IGameRepository), typeof(GameRepository));
services.AddScoped(typeof(ICommentRepository), typeof(CommentRepository));
services.AddScoped(typeof(IFriendRequestRepository), typeof(FriendRequestRepository));
services.AddScoped(typeof(IMessageRepository), typeof(MessageRepository));
services.AddScoped(typeof(IForumRepository), typeof(ForumRepository));
services.AddScoped(typeof(IReservationRepository), typeof(ReservationRepository));
services.AddScoped(typeof(IReservationService), typeof(ReservationService));
services.AddMvc().AddJsonOptions(options =>
{
options.JsonSerializerOptions.WriteIndented = true;
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
}).AddMvcOptions(options =>
{
options.EnableEndpointRouting = false;
});
services.AddCors(options =>
{
options.AddPolicy("CORS", builder =>
{
builder.AllowAnyHeader()
.AllowAnyMethod()
.SetIsOriginAllowed((host) => true)
.AllowCredentials();
});
});
services.AddSignalR(options =>
{
options.EnableDetailedErrors = true;
});
}
public static void GetAndConnectGraphClient(out IGraphClient graphClient, out IDriver driver, out IAsyncSession session, out IAsyncTransaction transaction)
{
GetDriverAndSession(out driver, out session, out transaction);
var client = new BoltGraphClient(driver);
client.ConnectAsync().Wait();
driver.ClearReceivedCalls();
session.ClearReceivedCalls();
graphClient = client;
}
public async Task DoesntDoAnything()
{
BoltClientTestHelper.GetDriverAndSession(out var mockDriver, out _, out _);
var client = new BoltGraphClient(mockDriver);
await client.ConnectAsync();
using (var tx = client.BeginTransaction())
{
await tx.KeepAliveAsync();
}
}
public async Task <ICollection <UserDetails> > GetFollowingAsync(Guid userId)
{
await _client.ConnectAsync();
var query = _client.Cypher
.OptionalMatch("(user:User)-[SUBSCRIBE]->(subscriber:User)")
.Where((UserDetails user) => user.Id == userId)
.Return(subscriber => subscriber.As <UserDetails>());
return((await query.ResultsAsync).ToList());
}
async private Task AddFlight(Flight newFlight, string travelIdentity, string relationName)
{
await GraphClient.ConnectAsync();
var resp = await GraphClient.Cypher
.Match($"(travel:Travel)-[:{relationName}]-(flight:Flight)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.Return(flight => flight.As <Flight>())
.ResultsAsync;
if (resp.Any())
{
throw new TravelPlannerException(409, "Flight for this travel already exists");
}
try
{
await GraphClient.Cypher
.Create("(flight:Flight $flight)")
.WithParam("flight", newFlight)
.Return(flight => flight.As <Flight>())
.ResultsAsync;
}
catch (ClientException ce)
{
if (!ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw ce;
}
}
await GraphClient.Cypher
.Match("(flight:Flight)", "(travel:Travel)")
.Where((Travel travel) => travel.TravelId == travelIdentity)
.AndWhere((Flight flight) => flight.FlightId == newFlight.FlightId)
.Merge($"(travel)-[:{relationName}]->(flight)")
.Return(flight => flight.As <Flight>())
.ResultsAsync;
}
async public Task <CityWalk> AddCityWalk(CityWalk newWalk, string travelIdentity, string locationId)
{
await GraphClient.ConnectAsync();
try
{
var resp = await GraphClient.Cypher
.Match("(travel:Travel)", "(location:Location)")
.Where((Location location) => location.LocationId == locationId)
.AndWhere((Travel travel) => travel.TravelId == travelIdentity)
.Create("(walk:CityWalk $walk)")
.WithParam("walk", newWalk)
.Create("(travel)-[r:HasCityWalk]->(walk)")
.Create("(location)-[k:HasCityWalk]->(walk)")
.Return(walk => walk.As <CityWalk>())
.ResultsAsync;
if (resp.Any())
{
return(resp.First());
}
else
{
return(null);
}
}
catch (ClientException ce)
{
if (ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
newWalk.CityWalkId = new Guid().ToString();
return(await AddCityWalk(newWalk, travelIdentity, locationId));
}
else
{
throw ce;
}
}
}
public async Task QueryInTransaction_ThrowsExceptionWhen_ExecutingCypherQueryAgainstADifferentDatabaseName()
{
BoltClientTestHelper.GetDriverAndSession(out var mockDriver, out _, out var mockTransaction);
var client = new BoltGraphClient(mockDriver);
await client.ConnectAsync();
using (var tx = client.BeginTransaction())
{
var ex = Assert.Throws <InvalidOperationException>(() => client.Cypher.WithDatabase("foo").Match("n").Return(n => n.Count()));
ex.Should().NotBeNull();
}
}
public async Task CallsRollsback_IfTransactionIsOpen()
{
BoltClientTestHelper.GetDriverAndSession(out var mockDriver, out _, out var mockTransaction);
var client = new BoltGraphClient(mockDriver);
await client.ConnectAsync();
using (var tx = client.BeginTransaction())
{
await client.Cypher.Match("n").Return(n => n.Count()).ExecuteWithoutResultsAsync();
}
await mockTransaction.Received(1).RollbackAsync();
}
public async Task IsTrueWhen_Open()
{
BoltClientTestHelper.GetDriverAndSession(out var mockDriver, out _, out _);
var client = new BoltGraphClient(mockDriver);
await client.ConnectAsync();
using (var tx = client.BeginTransaction())
{
await client.Cypher.Match("n").Return(n => n.Count()).ExecuteWithoutResultsAsync();
tx.IsOpen.Should().BeTrue();
}
}
async public Task RegisterUser(User user)
{
await GraphClient.ConnectAsync();
try
{
var resp = await GraphClient.Cypher
.Create("(user:User $user)")
.WithParam("user", user)
.Return(user => user.As <User>())
.ResultsAsync;
} catch (ClientException ce)
{
if (ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw new TravelPlannerException(409, "User already exists");
}
else
{
throw ce;
}
}
}
async public Task <Travel> AddTravelToUser(Travel travel, string userMail)
{
await GraphClient.ConnectAsync();
try
{
var resp = await GraphClient.Cypher
.Match("(user:User)")
.Where((User user) => user.Mail == userMail)
.Create("(travel:Travel $travel)")
.WithParam("travel", travel)
.Create("(user)-[r:HasTravel]->(travel)")
.Return(travel => travel.As <Travel>())
.ResultsAsync;
if (resp.Any())
{
return(resp.First());
}
else
{
return(null);
}
}
catch (ClientException ce)
{
if (ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw new TravelPlannerException(409, "Travel already exists");
}
else
{
throw ce;
}
}
}
async public Task AddPoi(Poi poi)
{
await GraphClient.ConnectAsync();
try
{
var resp = await GraphClient.Cypher
.Create("(poi:Poi $poi)")
.WithParam("poi", poi)
.Return(poi => poi.As <Poi>())
.ResultsAsync;
}
catch (ClientException ce)
{
if (ce.Message.Contains("already exists", StringComparison.InvariantCultureIgnoreCase))
{
throw new TravelPlannerException(409, "Poi already exists");
}
else
{
throw ce;
}
}
}
