public async Task Post(/*[FromBody] string value*/)
{
var service = new MovieDataService();
var settings = ConnectionSettings.CreateBasicAuth(url, username, password);
using (var client = new Neo4JClient(settings))
{
// Create Indices for faster Lookups:
//await client.CreateIndices();
//// Create Base Data:
//await client.CreateMovies(service.Movies);
//await client.CreatePersons(service.Persons);
//await client.CreateGenres(service.Genres);
//// Create Relationships:
//await client.CreateRelationships(service.Metadatas);
//await client.CreateServices(service.Services);
//await client.CreateFrontEnds(service.FrontEnds);
//await client.CreateDatabases(service.Databases);
//await client.CreateRelationships_Service(service.Metadatas_service);
//await client.CreateRelationships_Database(service.Metadatas_database);
//await client.CreateRelationships_FrontEnd(service.Metadatas_frontend);
//await client.CreateServices(service.Services_sc1);
//await client.CreateRelationships_Service(service.Metadatas_service_sc1);
}
}
public async Task Index()
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
await client.CreateIndices();
}
}
public ActionResult GetDegree()
{
var settings = ConnectionSettings.CreateBasicAuth(url, username, password);
using (var client = new Neo4JClient(settings))
{
return(Ok(client.GetDegrees()));
}
}
public ActionResult GetPathLengths()
{
var settings = ConnectionSettings.CreateBasicAuth(url, username, password);
using (var client = new Neo4JClient(settings))
{
var result = client.GetPathLengths();
return(Ok(result));
}
}
public async Task <List <Category> > Index()
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, "neo4j", "admin");
using (var client = new Neo4JClient(settings))
{
CategoryService myService = new CategoryService(client);
return(await myService.GetAllCategories());
}
}
public async Task <List <Like> > Index()
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
LikeService myService = new LikeService(client);
return(await myService.getAllLikes());
}
}
public static void Main(string[] args)
{
var settings = ConnectionSettings.CreateBasicAuth("bolt://localhost:7687/db/flights", "neo4j", "test_pwd");
using (var client = new Neo4JClient(settings))
{
// Create Indices for faster Lookups:
client.CreateIndices();
// Insert the Base Data (Airports, Carriers, ...):
InsertBaseData(client);
// Insert the Flight Data:
InsertFlightData(client);
}
}
public async Task <List <User> > FilterByCategory(string name)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
Category category = new Category
{
Name = name
};
CategoryService myService = new CategoryService(client);
myService.addCategory(category);
return(await myService.GetUsers(myService.Categories));
}
}
public async Task <List <User> > FilterByLike(string name)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
Like like = new Like
{
Name = name
};
LikeService myService = new LikeService(client);
myService.addLike(like);
return(await myService.GetUsers(myService.likes));
}
}
public async Task <IActionResult> Report(ReportInfo reportInfo)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
ReportService myService = new ReportService(client);
string ans = await myService.CreateReport(reportInfo);
Response response = new Response {
Ans = ans
};
return(Created(Neo4JClient.uri, response));
}
}
public async Task <ActionResult> InsertTraces()
{
var dataService = new MovieDataService();
var settings = ConnectionSettings.CreateBasicAuth(url, username, password);
using (var client = _factory.CreateClient())
{
//read from json
var tracesfromFile = JsonConvert.DeserializeObject <List <List <SpanDto> > >(System.IO.File.ReadAllText("traces.json"));
var traces_model = dataService.Create(tracesfromFile);
using (var client_2 = new Neo4JClient(settings))
{
//delete the existing graph first
await client_2.DeleteGraph();
foreach (var trace in traces_model)
{
//await client_2.CreateServices(trace.services);
//await client.CreateFrontEnds(service.FrontEnds);
//await client.CreateDatabases(service.Databases);
//if (traces_model[0] == trace)
// System.IO.File.WriteAllText("traces_1.json", JsonConvert.SerializeObject(trace.serviceinformation));
//if (traces_model[1] == trace)
// System.IO.File.WriteAllText("traces_2.json", JsonConvert.SerializeObject(trace.serviceinformation));
//if (traces_model[2] == trace)
// System.IO.File.WriteAllText("traces_3.json", JsonConvert.SerializeObject(trace.serviceinformation));
//if (traces_model[3] == trace)
// System.IO.File.WriteAllText("traces_4.json", JsonConvert.SerializeObject(trace.serviceinformation));
await client_2.CreateRelationships_Service(trace.serviceinformation);
//await client.CreateRelationships_Database(service.Metadatas_database);
//await client.CreateRelationships_FrontEnd(service.Metadatas_frontend);
//await client.CreateServices(service.Services_sc1);
//await client.CreateRelationships_Service(service.Metadatas_service_sc1);
}
}
return(Ok(traces_model));
}
}
public async Task <List <Like> > UsersLikes(string id)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
UserService myService = new UserService(client);
User auxUser = new User {
Id = id
};
myService.addUser(auxUser);
List <Like> ans = await myService.UsersLikes(myService.Users);
return(ans);
}
}
private static async Task ProcessLocalWeatherData(CancellationToken cancellationToken = default(CancellationToken))
{
var settings = ConnectionSettings.CreateBasicAuth("bolt://localhost:7687/db/weather", "neo4j", "test_pwd");
using (var client = new Neo4JClient(settings))
{
// Create Indices for faster Lookups:
await client.CreateIndicesAsync();
// Insert the Base Data (Airports, Carriers, ...):
await InsertStationsAsync(client);
// Insert the Flight Data:
await InsertLocalWeatherDataAsync(client);
}
}
public async Task <bool> ExistLike(string name)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
Like like = new Like
{
Name = name
};
LikeService myService = new LikeService(client);
myService.addLike(like);
List <bool> ans = await myService.ExistLike(myService.likes);
return(ans[0]);
}
}
public async Task <IActionResult> NewIs(LikeInfo likeInfo)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
LikeService myService = new LikeService(client);
myService.addMetadata(likeInfo);
string aux = await myService.CreateRelationshipLike(myService.likeInfos);
Response ans = new Response()
{
Ans = aux
};
return(Created(Neo4JClient.uri, ans));
}
}
public async Task <bool> ExistCategory(string name)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
Category category = new Category
{
Name = name
};
CategoryService myService = new CategoryService(client);
myService.addCategory(category);
List <bool> ans = await myService.ExistCategory(myService.Categories);
return(ans[0]);
}
}
public async Task <IActionResult> Deactivate(Suggestion suggestion)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
SuggestionService myService = new SuggestionService(client);
myService.addSuggestion(suggestion);
string aux = await myService.ChangeIsActive(myService.Suggestions);
Response ans = new Response()
{
Ans = aux
};
return(Ok(ans));
}
}
public async Task <IActionResult> NewGather(UserInfo userInfo)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
UserService myService = new UserService(client);
myService.addMetadata(userInfo);
string aux = await myService.CreateRelationGatherUser(myService.UserInfos);
Response ans = new Response()
{
Ans = aux
};
return(Created(Neo4JClient.uri, ans));
}
}
public async Task <IActionResult> NewCategory(Category category)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, "neo4j", "admin");
using (var client = new Neo4JClient(settings))
{
CategoryService myService = new CategoryService(client);
myService.addCategory(category);
string aux = await myService.CreateCategory(myService.Categories);
Response ans = new Response()
{
Ans = aux
};
return(Created(Neo4JClient.uri, ans));
}
}
public async Task <IActionResult> GetSuggestion(string id)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
User user = new User {
Id = id
};
UserService aux = new UserService(client);
aux.addUser(user);
SuggestionService myService = new SuggestionService(client);
List <SuggestionInfo> ans = await myService.getSuggestion(aux.Users);
return(Ok(ans));
}
}
public static async Task RunAsync(IMovieDataService service)
{
//var settings = ConnectionSettings.CreateBasicAuth("bolt://localhost:7687/db/actors", "neo4j", "test_pwd");
var settings = ConnectionSettings.CreateBasicAuth("bolt://localhost:7687/db/actors", "neo4j", "test_pwd");
//using (var client = new Neo4JClient(settings))
//{
// // Create Indices for faster Lookups:
// //await client.CreateIndices();
// // Create Base Data:
// await client.CreateMovies(service.Movies);
// await client.CreatePersons(service.Persons);
// await client.CreateGenres(service.Genres);
// // Create Relationships:
// await client.CreateRelationships(service.Metadatas);
//}
}
public ActionResult GetCC()
{
var settings = ConnectionSettings.CreateBasicAuth(url, username, password);
using (var client = new Neo4JClient(settings))
{
var result = client.GetCC();
//we omit cc values for nodes in chains by checking null for traceid. It will consider only the main graph nodes
//var result2 = result.Where(y => y.GUID == "null").GroupBy(x => x.Name).Select(y => new
//{
// //id = y.First().Id,
// name = y.First().Name,
// cc = y.OrderByDescending(c => c.CC).First().CC
//});
var result2 = result.Where(y => y.GUID == "null");
return(Ok(result2));
}
}
public async Task <IList <SuggestionInfo> > CreateSuggest(User user)
{
var settings = ConnectionSettings.CreateBasicAuth(Neo4JClient.uri, Neo4JClient.user, Neo4JClient.password);
using (var client = new Neo4JClient(settings))
{
SuggestionService myService = new SuggestionService(client);
UserService myService2 = new UserService(client);
myService2.addUser(user);
IList <SuggestionInfo> toReturn = await myService.CreateSuggestedRelation(myService2.Users);
UserInfo metadata = new UserInfo
{
User = user,
Suggestions = myService.Suggestions
};
myService2.addMetadata(metadata);
await myService2.CreateRelationSuggUser(myService2.UserInfos);
return(toReturn);
}
}
