public void TestSetUp()
{
GraphClient = new GraphClient(new Uri("http://localhost:7474/db/data"), "neo4j", "dkschlos");
GraphClient.Connect();
ResetDb();
}
public GraphRepository(IConfiguration configuration)
{
var client = new GraphClient(new Uri(configuration.GetGraphDbUrl()));
client.Connect();
Client = client;
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
//Use an IoC container and register as a Singleton
var url = ConfigurationManager.AppSettings["GraphDBUrl"];
var client = new GraphClient(new Uri(url),"neo4j","123456");
client.Connect();
GraphClient = client;
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
static void Main(string[] args)
{
var graphClient = new GraphClient(new Uri("http://localhost:7474/db/data"));
graphClient.Connect();
Fill(graphClient);
}
public void Init()
{
try
{
_graphClient = new GraphClient(new Uri("http://localhost:7474/db/data"));
_graphClient.Connect();
}
catch (Exception)
{
throw new Exception("Not Connected To Neo4j Server");
}
_relationshipManager = new Neo4jRelationshipManager();
//Chicken and Egg...
INodeRepoCreator repoCreator = new NodeRepoCreator(_graphClient,_relationshipManager);
var idGenerator = new IdGenerator(repoCreator);
idGenerator.LoadGenerator(50);
_ownedByService = repoCreator.CreateNode<OwnedBy, StorageLocation>("Name");
_initialAddRef = _ownedByService.UpdateOrInsert(new StorageLocation { Id = 1, Name = "Main WH" }, _graphClient.RootNode);
}
public DBconennector()
{
client = new GraphClient(new Uri("http://*****:*****@localhost:7474/db/data"));
client.Connect();
cities = new List<string>();
}
static void Main(string[] args)
{
neo4j = new GraphClient(new Uri("http://localhost:7474/db/data"));
neo4j.Connect();
DoBlock("0000000000000000b6359c198b89747d41ebd833fc118e0d920a44ad63af0578");
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == Neo4jSettings.METADATA_TYPE);
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
//Use an IoC container and register as a Singleton
string url = Properties.Settings.Default.GraphDBUrl;
string user = Properties.Settings.Default.GraphDBUser;
string password = Properties.Settings.Default.GraphDBPassword;
IGraphClient client = new GraphClient(new Uri(url), user, password);
client.Connect();
GraphClient = client;
DataService = new Neo4jDataService(GraphClient);
Cache = new Neo4jCacheQuery();
Helper = new Neo4jHelper(DataService, Cache);
}
private static IGraphClient InitNeo4jClient(IContext context)
{
var neo4jUri = new Uri(ConfigurationManager.ConnectionStrings["assets"].ConnectionString);
var graphClient = new GraphClient(neo4jUri);
graphClient.Connect();
return graphClient;
}
private GraphClient CreateGraphClient()
{
var graphClient = new GraphClient(new Uri("http://localhost:7474/db/data"));
graphClient.Connect();
DeleteAll(graphClient);
return graphClient;
}
public void Init()
{
_graphClient = new GraphClient(new Uri("http://localhost:7475/db/data"), "neo4j", "extra");
_graphClient.Connect();
_graphClient.BeginTransaction();
_dataGenerator = new DbTestDataGenerator(_graphClient);
}
public IGraphClient Create(IHttpClient httpClient)
{
var client = new GraphClient(_configuration.RootUri, httpClient);
client.Connect(_configuration);
return client;
}
public Scaffolding()
{
_client = new GraphClient(new Uri("http://10.0.9.50:7474/db/data"));
_client.Connect();
CreateNodesRelationshipsIndexes();
}
public static GraphClient ConnectToStagedDatabase()
{
var graphClient = new GraphClient(new Uri(ConfigurationManager.AppSettings["neo4j_database_url"]));
graphClient.Connect();
return graphClient;
}
protected void Connect()
{
if (null == _client)
{
//var client = new GraphClient(new Uri("http://nidhugg.mydomain.local:7474/db/data"));
_client = new GraphClient(new Uri("http://nidhugg:7474/db/data"));
_client.Connect();
}
}
protected async void setHW_Click(object sender, EventArgs e)
{
Institute i = JsonConvert.DeserializeObject<Institute>(Session["u"].ToString());
GraphClient g = new GraphClient(new Uri("http://neo4jvm1.cloudapp.net:7474/db/data"));
g.Connect();
string cc = class_.InnerText;
string c= (g.Cypher.Match("(i:`institute`)--(n:`class` {school:\""+i.self+"\",standard:\""+cc[0]+"\",section:\""+cc[4]+"\"})").Where("id(i)="+i.self).Return<string>("id(n)").Results.ToList())[0];
Homework hw = new Homework { detail = detail.InnerText, class_ = c, on = DateTime.Today.ToString("dd-MMM-yy"), subject = "" };
await h.PostAsync(url+"hw/",new StringContent(JsonConvert.SerializeObject(hw),System.Text.Encoding.UTF8,"application/json"));
}
public IGraphClient GetClient(Uri rootUri)
{
return _clients.GetOrAdd(
rootUri.ToString(),
(key) =>
{
var client = new GraphClient(rootUri);
client.Connect();
return client;
});
}
static IGraphClient GetGraphClient(string endpoint = "http://*****:*****@localhost:7474/db/data")
{
// https://github.com/Readify/Neo4jClient/wiki/connecting
var client = new GraphClient(new Uri(endpoint));
client.Connect();
//SetupTestData(client);
return client;
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(
Component.For<IGraphClient>()
.UsingFactoryMethod(() =>
{
var client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
return client;
}));
}
public IGraphClient Create()
{
var client = new GraphClient(
_configuration.RootUri,
_configuration.Username,
_configuration.Password);
client.Connect(_configuration);
return client;
}
public TranspornetzRepository()
{
System.Configuration.ConnectionStringSettings connectionSettings = System.Configuration.ConfigurationManager.ConnectionStrings["Neo4j"];
Contract.Assert(connectionSettings != null, "A Neo4j connection setting needs to be defined in the App.config.");
string connectionString = connectionSettings.ConnectionString;
Contract.Assert(connectionString != null, "A Neo4j connection string needs to be defined in the App.config.");
gc = new GraphClient(new Uri(connectionString));
gc.Connect();
gc.CreateIndex("LokationIdx", new IndexConfiguration() { Provider = IndexProvider.lucene, Type = IndexType.fulltext }, IndexFor.Node);
}
/// <summary>
/// Initialisiert den Bootloader
/// </summary>
/// <param name="container"></param>
/// <returns></returns>
public static Container Init(Container container)
{
GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"), "neo4j", "extra");
client.Connect();
container.RegisterInstance(client);
RegisterDaos(container);
RegisterServices(container);
return container;
}
private static void CleanupProperties()
{
var client = new GraphClient(new Uri("http://*****:*****@localhost:7474/db/data"));
client.Connect();
var data = client.Cypher
.Match("(device:Device)")
.Return(device => device.As<Device>())
.Results.ToList();
foreach (var result in data)
{
if (result.SN != result.SN.Trim())
{
client.Cypher
.Match("(device:Device {SN: {sn}})")
.Set("device.SN = {trimsn}")
.WithParams(new
{
sn = result.SN,
trimsn = result.SN.Trim()
})
.ExecuteWithoutResults();
}
if (result.AssetTag != result.AssetTag.Trim())
{
client.Cypher
.Match("(device:Device {AssetTag: {asset}})")
.Set("device.AssetTag = {trimasset}")
.WithParams(new
{
asset = result.AssetTag,
trimasset = result.AssetTag.Trim()
})
.ExecuteWithoutResults();
}
if (result.WSAsset != result.WSAsset.Trim())
{
client.Cypher
.Match("(device:Device {WSAsset: {wsasset}})")
.Set("device.WSAsset = {trimwsasset}")
.WithParams(new
{
wsasset = result.WSAsset,
trimwsasset = result.WSAsset.Trim()
})
.ExecuteWithoutResults();
}
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalConfiguration.Configuration.MessageHandlers.Add(new CorsHandler());
GraphClient = new GraphClient(new Uri("http://localhost:7474/db/data"));
GraphClient.Connect();
}
public static void Register(HttpConfiguration config)
{
// Web API 配置和服务
// Web API 路由
config.MapHttpAttributeRoutes();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
var url = ConfigurationManager.AppSettings["GraphDBUrl"];
var client = new GraphClient(new Uri(url));
client.Connect();
GraphClient = client;
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
var url = ConfigurationManager.AppSettings["GraphDBUrl"];
var client = new GraphClient(new Uri(url), "neo4j", "123456");
client.Connect();
GraphClient = client;
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public ActionResult About()
{
var client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
int id = Convert.ToInt32(Session["idUser"]);
var p = client.Cypher.OptionalMatch("(user:User)-[POSTED]->(post:Post)")
.Where((User user) => user.idUser == id)
.AndWhere((Post post) => post.idUserPosted == id)
.ReturnDistinct(post => post.As<Post>())
.Results;
List<Post> P = p.ToList();
foreach (Post pos in P)
{
if (pos != null)
posts.Add(pos);
}
P = posts.OrderByDescending((x) => x.Data).ToList();
return View("~/Views/Home/About.cshtml", P);
}
public ActionResult Users()
{
GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
var query = new Neo4jClient.Cypher.CypherQuery(
"start n=node(0) match n<-[r:HasCompleted]-e return e.UserName as Name;",
new Dictionary<string, object>(),CypherResultMode.Projection);
//var result = client.ExecuteGetCypherResults<User>(query);
// get all movies with any name using index
List<Node<User>> list = client.QueryIndex<User>("User", IndexFor.Node, "Name: *").ToList();
List<User> movies = new List<User>();
foreach (Node<User> movieNode in list)
{
movies.Add(movieNode.Data);
}
return View(movies);//movies);
}
private static void AddCustomRepositoriesTo(IWindsorContainer container)
{
container.Register(
AllTypes
.FromAssemblyNamed("CliqFlip.Infrastructure")
.Pick()
.WithService.FirstNonGenericCoreInterface("CliqFlip.Domain")
.WithService.FirstNonGenericCoreInterface("CliqFlip.Infrastructure"));
container
.Register(Component
.For<IGraphClient>()
.LifeStyle.Singleton.UsingFactoryMethod(() =>
{
string connectionString = WebConfigurationManager.ConnectionStrings[Constants.GRAPH_URL].ConnectionString;
var rootUri = new Uri(connectionString);
var graphClient = new GraphClient(rootUri) { EnableSupportForNeo4jOnHeroku = true };
graphClient.Connect();
return graphClient;
}));
}
private void ConfigureNeo4j(IAppBuilder app)
{
// Create and connect GraphClient for use in dal and identity framework
Client = new GraphClient(new Uri(ConfigurationManager.ConnectionStrings["neo4j"].ConnectionString));
Client.Connect();
// Create dal and initiate DB
Dal = new DatabaseAbstrationLayer(Client, ConfigurationManager.AppSettings.Get("DataDir"));
InitiateDB();
// Create reference to dal in OwinContext, so it can be accessed by Controllers
app.CreatePerOwinContext(() => Dal);
// Create reference to GraphClientWrapper in OwinContext, so it can be accessed by SolitudeUserStore
app.CreatePerOwinContext(() => {
return new GraphClientWrapper(Client);
});
// Create Solitude UserManager and SignInManager to control users
app.CreatePerOwinContext<SolitudeUserManager>(SolitudeUserManager.Create);
app.CreatePerOwinContext<SolitudeSignInManager>(SolitudeSignInManager.Create);
}