static async Task <string> Example12()
{
return(await Bolt.NewSession(async session =>
{
var movie = new IMDBMovie
{
imdb = "tt0110912",
released = 1994,
tagline =
"The lives of two mob hitmen, a boxer, a gangster's wife, and a pair of diner bandits intertwine in four tales of violence and redemption.",
title = "Pulp Fiction"
};
var parameters = new Neo4jParameters()
.WithEntity("newMovie", movie);
var cursor = await session.RunAsync(@"
CREATE (movie:Movie $newMovie)
RETURN movie", parameters);
var createdMovie = await cursor.MapSingleAsync <IMDBMovie>();
return createdMovie.Dump();
}));
}
static async Task <string> Example14()
{
return(await Bolt.NewSession(async session =>
{
var cursor = await session.RunAsync(@"
MATCH (movie:Movie {released: $year})
RETURN movie", new { year = 1999 });
var movies = await cursor.MapAsync <MovieEntity>();
var matrix = movies.Single(p => p.title == "The Matrix");
matrix.imdb = "tt0133093";
var updateParams = new Neo4jParameters()
.WithEntity("updatedMovie", matrix)
.WithValue("nodeId", matrix.id);
cursor = await session.RunAsync(@"
MATCH (movie)
WHERE id(movie) = $nodeId
SET movie = $updatedMovie
RETURN movie", updateParams);
var updatedMovie = await cursor.MapSingleAsync <MovieEntity>();
return updatedMovie.Dump();
}));
}
public async void CreateActor()
{
// arrange
IAsyncSession session = _neo4JResource.GetAsyncSession();
try
{
// act
var actor = new Actor("Keanu Reaves", 56);
IDictionary <string, object> parameters =
new Neo4jParameters().WithEntity("newActor", actor);
IResultCursor cursor = await session.RunAsync(
@"CREATE (actor:Actor $newActor) RETURN actor",
parameters);
Actor createdActor = await cursor.MapSingleAsync <Actor>();
await cursor.ConsumeAsync();
// assert
createdActor.MatchSnapshot();
}
finally
{
await session.CloseAsync();
}
}
public async Task Should_Create_New_Actor_From_Entity_Parameter()
{
var person = new Person
{
born = 1962,
name = "Tom Cruise"
};
var parameters = new Neo4jParameters().WithEntity("actor", person);
try
{
await Session.RunAsync(@"CREATE (:Actor $actor)", parameters);
var cursor = await Session.RunAsync(@"
MATCH (actor:Actor)
RETURN actor");
var tomCruise = await cursor.MapSingleAsync <Person>();
Assert.AreEqual(1962, tomCruise.born);
Assert.AreEqual("Tom Cruise", tomCruise.name);
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
finally
{
await Session.RunAsync(@"
MATCH (a:Actor)
DELETE a");
}
}
public void DeleteTutoringRelationship(string userId, string subjectId)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userId).WithValue("subjectId", subjectId);
string query = $@"MATCH (u:User)-[r:TUTORING]->(s:Subject)
WHERE u.UserID=$userId AND s.SubjectID=$subjectId DELETE r";
var result = session.Run(query, parameters);
}
}
public Subject FindSubjectBySubjectCode(string subjectCode)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("subjectCode", subjectCode);
string query = $@"MATCH (node:Subject) WHERE node.SubjectCode = $subjectCode RETURN node";
var result = session.Run(query, parameters);
return(result.SingleOrDefault().Map <Subject>());
}
}
public IEnumerable <Subject> GetSubjectsStudentHasPassed(string userID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userID);
string query = $@"MATCH(n: User) -[r: ENROLLED_TO]->(s: Subject)
WHERE n.UserID = $userId AND r.Grade > 1 RETURN s";
var result = session.Run(query, parameters);
return(result.Map <Subject>());
}
}
public IEnumerable <Subject> GetSubjectsStudentIsTutoring(string userId)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userId);
string query = $@"MATCH (n:User)-[:TUTORING]->(s:Subject)
WHERE n.UserID=$userId RETURN s";
var result = session.Run(query, parameters);
return(result.Map <Subject>());
}
}
public T Create(T node)
{
using (var session = Neo4jDriver.Session())
{
string classType = typeof(T).Name;
var parameters = new Neo4jParameters().WithEntity("newNode", node);
string query = $@"CREATE (node:{classType} $newNode ) RETURN node";
var result = session.Run(query, parameters);
return(result.Single().Map <T>());
}
}
public Student CreateUserStudent(Student student)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithEntity("newNode", student);
string query = $@"CREATE (node :User:Student $newNode ) RETURN node";
var result = session.Run(query, parameters);
var stud = result.Single().Map <Student>();
return(stud);
}
}
public void CreateAttendsToRelationShipWithCourse(Guid userID, Guid courseID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userID.ToString())
.WithValue("courseId", courseID.ToString());
string query = @"MATCH (stud :Student { UserID: $userId})
MATCH (course :Course { CourseID: $courseId })
MERGE (stud)-[:ATTENDS]->(course)";
var result = session.Run(query, parameters);
}
}
public void CreateTeachesRelationshipWithCourseIDs(Guid teacherID, Guid courseID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("teacherId", teacherID.ToString())
.WithValue("courseId", courseID.ToString());
string query = @"MATCH (teacher :Teacher { TeacherID: $teacherId})
MATCH (course :Course { CourseID: $courseId })
MERGE (teacher)-[:TEACHES]->(course)";
var result = session.Run(query, parameters);
}
}
public void AnonymizeStudentUser(string userID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userID);
string query =
$@"MATCH (n:User:Student)
WHERE n.UserID = $userId
SET n.InstagramName = 0, n.Email = 0, n.FirstName = 0, n.NeptunCode = 0, n.IsDisabled = 1, n.LastName = 0, n.GenderType = 2,n.MessengerName = 0,n.Password = 0";
var result = session.Run(query, parameters);
}
}
public void UpdateUserDisabledPropertyByUserId(string ID, bool isDisabled)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", ID)
.WithValue("isDisabled", isDisabled);
string query = @"MATCH(n: User)
WHERE n.UserID = $userId
SET n.IsDisabled = $isDisabled";
var result = session.Run(query, parameters);
}
}
public void CreateBelongsToRelationshipToSubject(Guid courseID, Guid subjectID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("courseId", courseID.ToString())
.WithValue("subjectId", subjectID.ToString());
string query = @"MATCH (course :Course { CourseID: $courseId })
MATCH (subject :Subject { SubjectID: $subjectId })
MERGE (course)-[:BELONGS_TO]->(subject)";
var result = session.Run(query, parameters);
}
}
public void Should_Convert_Entities_To_Dictionary()
{
var entities = new[]
{
new Entity
{
First = "Foo",
Second = "Bar",
Third = 56,
Fourth = new LocalDate(2019, 1, 13)
},
new Entity
{
First = "Lu",
Second = "Var",
Third = 65,
Fourth = new LocalDate(2019, 1, 26)
},
};
var parameters = new Neo4jParameters().WithEntities("p1", entities);
Assert.AreEqual(1, parameters.Count);
var p1 = parameters["p1"];
Assert.IsInstanceOf <IEnumerable <IReadOnlyDictionary <string, object> > >(p1);
var innerItems = ((IEnumerable <IReadOnlyDictionary <string, object> >)p1).ToArray();
Assert.AreEqual(2, innerItems.Length);
var firstItem = innerItems[0];
Assert.AreEqual("Foo", firstItem["First"]);
Assert.AreEqual("Bar", firstItem["Second"]);
Assert.AreEqual(56, firstItem["Third"]);
Assert.AreEqual(2019, ((LocalDate)firstItem["Fourth"]).Year);
Assert.AreEqual(1, ((LocalDate)firstItem["Fourth"]).Month);
Assert.AreEqual(13, ((LocalDate)firstItem["Fourth"]).Day);
var secondItem = innerItems[1];
Assert.AreEqual("Lu", secondItem["First"]);
Assert.AreEqual("Var", secondItem["Second"]);
Assert.AreEqual(65, secondItem["Third"]);
Assert.AreEqual(2019, ((LocalDate)secondItem["Fourth"]).Year);
Assert.AreEqual(1, ((LocalDate)secondItem["Fourth"]).Month);
Assert.AreEqual(26, ((LocalDate)secondItem["Fourth"]).Day);
}
public void CreateEnrolledToRelationShipWithSubject(Guid userID, Guid subjectID, string semester)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userID.ToString())
.WithValue("subjectId", subjectID.ToString())
.WithValue("semester", semester);
string query = @"MATCH (stud:Student { UserID: $userId})
MATCH (subj: Subject { SubjectID: $subjectId})
MERGE (stud)-[r: ENROLLED_TO {Semester: $semester}]->(subj)";
var result = session.Run(query, parameters);
}
}
//creates
public Course CreateCourseBelongingToSubject(Course course, string subjectCode)
{
var parameters = new Neo4jParameters().WithValue("subjectCode", subjectCode);
string courseLiteralMap = course.GetCypherFormattedNodeParameters();
using (var session = Neo4jDriver.Session())
{
string query = $@"MATCH (sub:Subject {{SubjectCode: $subjectCode }})
MERGE (sub)<-[r: BELONGS_TO]-(c: Course {{" + courseLiteralMap + @"})
RETURN c";
var result = session.Run(query, parameters);
return(result.Single().Map <Course>());
}
}
public User FindUserById(string userID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userID", userID);
string query = $@"MATCH (node:User) WHERE node.UserID = $userID RETURN node";
var result = session.Run(query, parameters);
var resultList = result.ToList();
if (resultList.Count() != 1)
{
return(null);
}
return(resultList.Single().Map <User>());
}
}
//public User FindUserByUserNameAndPassword(string username, string password)
//{
// using (var session = Neo4jDriver.Session())
// {
// var parameters = new Neo4jParameters().WithValue("username", username)
// .WithValue("password", password);
// string query = $@"MATCH (node:User) WHERE node.UserName = $username AND node.Password= $password RETURN node";
// var result = session.Run(query, parameters);
// var resultList = result.ToList();
// if (resultList.Count() == 0)
// {
// return null;
// }
// return resultList.Single().Map<User>();
// }
//}
public List <string> GetUserLabelsByUserID(string userID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userID);
string query = $@"MATCH (n:User)
WHERE n.UserID = $userId
UNWIND( labels(n)) as labels
RETURN distinct labels";
var result = session.Run(query, parameters);
var labels = result.Select(record => record[0].As <string>()).ToList();
return(labels);
}
}
public Student FindStudentByUserID(string userID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userID);
string query = $@"MATCH (node:Student) WHERE node.UserID = $userId RETURN node";
var result = session.Run(query, parameters);
var resultList = result.ToList();
if (resultList.Count == 0)
{
return(null);
}
return(resultList.Single().Map <Student>());
}
}
public Subject GetSubjectById(string subjectId)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("subjectId", subjectId);
string query = $@"MATCH (node:Subject) WHERE node.SubjectID = $subjectId RETURN node";
var result = session.Run(query, parameters);
var res = result.ToList();
if (res.Count == 0)
{
throw new NodeNotExistsException("Subject with given id does not exists");
}
return(res.SingleOrDefault().Map <Subject>());
}
}
public IEnumerable <Student> GetStudentsEnrolledToSubject(string subjectID)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("subjectId", subjectID);
string query = $@"MATCH (s:Student)-[:ENROLLED_TO]->(sub:Subject) WHERE sub.SubjectID = $subjectId RETURN s";
var result = session.Run(query, parameters);
var resultList = result.ToList();
if (resultList.Count == 0)
{
return(new List <Student>());
}
return(resultList.Map <Student>());
}
}
static async Task <string> Example13()
{
return(await Bolt.NewSession(async session =>
{
var actorWithMovies = new Person
{
name = "Samuel L. Jackson",
born = 1948,
MoviesActedIn = new List <Movie>
{
new Movie
{
released = 1994,
tagline =
"The lives of two mob hitmen, a boxer, a gangster's wife, and a pair of diner bandits intertwine in four tales of violence and redemption.",
title = "Pulp Fiction"
},
new Movie
{
released = 1996,
tagline =
"A woman suffering from amnesia begins to recover her memories after trouble from her past finds her again.",
title = "The Long Kiss Goodnight"
},
new Movie
{
released = 2000,
tagline =
" A man learns something extraordinary about himself after a devastating accident.",
title = "Unbreakable"
}
}
};
var parameters = new Neo4jParameters()
.WithEntity("newActor", actorWithMovies)
.WithEntities("newMovies", actorWithMovies.MoviesActedIn);
await session.RunAsync(@"
CREATE (person:Person $newActor)
WITH person
UNWIND $newMovies AS newMovie
CREATE (person)-[:ACTED_IN]->(movie:Movie)
SET movie = newMovie", parameters);
return string.Empty;
}));
}
public void CreateTeachesRelationshipWithCourseParams(string subjectCode, string courseCode, string semester, string teacherName)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("teacherName", teacherName)
.WithValue("subjectCode", subjectCode)
.WithValue("courseCode", courseCode)
.WithValue("semester", semester);
string query = @"MATCH (sub:Subject {SubjectCode:$subjectCode })<-[BELONGS_TO]-
(course: Course { CourseCode: $courseCode, Semester:$semester})
MATCH (teacher: Teacher { Name:$teacherName})
MERGE (teacher)-[r: TEACHES]->(course)";
var result = session.Run(query, parameters);
}
}
public void Should_Not_Convert_Value_If_ValueConvert_Is_Not_Implemented()
{
Neo4jParameters.ValueConvert = o => o.value;
var parameters = new Neo4jParameters()
.WithValue("1", DateTime.Now)
.WithValue("2", true)
.WithValue("3", "Read")
.WithValue("4", 123);
Assert.AreEqual(4, parameters.Count);
Assert.IsAssignableFrom <DateTime>(parameters["1"]);
Assert.IsAssignableFrom <bool>(parameters["2"]);
Assert.IsAssignableFrom <string>(parameters["3"]);
Assert.IsAssignableFrom <int>(parameters["4"]);
}
public IEnumerable <Student> GetStudentsTutoringSubjectByID(string subjectId)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("subjectId", subjectId);
string query = $@"MATCH (u:User)-[r:TUTORING]->(s:Subject)
WHERE s.SubjectID=$subjectId return u";
var result = session.Run(query, parameters);
var resultList = result.ToList();
if (resultList.Count == 0)
{
return(new List <Student>());
}
return(resultList.Map <Student>());
}
}
public override void Delete(User user, string ID)
{
using (var session = Neo4jDriver.Session())
{
if (ID == null)
{
var param = new Neo4jParameters().WithValue("userName", user.UserName);
string queryName = $@"MATCH (node:User) WHERE node.UserName =$userID DETACH DELETE node";
session.Run(queryName, param);
}
var parameters = new Neo4jParameters().WithValue("userID", ID);
string query = $@"MATCH (node:User) WHERE node.UserID =$userID DETACH DELETE node";
session.Run(query, parameters);
return;
}
}
public int GetStudentSemesterCount(string userId)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("userId", userId);
string query = $@"MATCH (u1:Student)-[r:ENROLLED_TO]->(:Subject)
WHERE u1.UserID = $userId
RETURN count(distinct r.Semester) as cnt";
var result = session.Run(query, parameters);
var resultList = result.ToList();
if (resultList.Count == 0)
{
return(0);
}
return(resultList.Single().Map <int>());
}
}
public IEnumerable <Student> GetStudentsCompletedSubjectWithGrade(string subjectID, int completedWithGrade)
{
using (var session = Neo4jDriver.Session())
{
var parameters = new Neo4jParameters().WithValue("subjectId", subjectID).WithValue("grade", completedWithGrade);
string query = @"MATCH (u2:Student)-[r:ENROLLED_TO]->(s:Subject)
WHERE s.SubjectID =$subjectId AND r.Grade = $grade RETURN u2";
var result = session.Run(query, parameters);
var resultList = result.ToList();
if (resultList.Count == 0)
{
return(new List <Student>());
}
return(resultList.Map <Student>());
}
}
