public GraphStoreTests()
{
var configuration = MockBuilder.BuildConfiguration();
var graphClientFactory = new GraphClientFactory(NeoServerConfiguration.GetConfiguration(new Uri($"{configuration.GraphStore.Url}/db/data"), configuration.GraphStore.Username, configuration.GraphStore.Password));
_graphStore = new GraphStore(graphClientFactory.Create(), false);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//Adding GraphClient
services.AddSingleton <IGraphClientFactory>(factory =>
new GraphClientFactory(
NeoServerConfiguration.GetConfiguration(new Uri(Configuration["Graph:Uri"]), Configuration["Graph:Username"], Configuration["Graph:Password"])
));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
//Adding Configuration
services.AddSingleton(Configuration);
//Adding Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Contraindicator API", Version = "v1"
});
});
//Adding Logging
services.AddLogging();
//Adding GraphClientRepository
services.AddScoped <IGraphClientRepository, GraphClientRepository>();
//Adding Seed Data
services.AddTransient <IGraphClientSeedData, GraphClientSeedData>();
}
public static void ConfigureGraphAccess(this IServiceCollection services)
{
services.AddSingleton(c =>
NeoServerConfiguration.GetConfiguration(new Uri("http://localhost:7474/db/data"), "neo4j", "MeLikeGraph"
));
services.AddSingleton <IGraphClientFactory, GraphClientFactory>();
services.AddSingleton <IUserConnectionsRepository, UserConnectionsRepository>();
}
public static void Configure(IServiceCollection services, IConfiguration config)
{
services.AddSingleton(
NeoServerConfiguration.GetConfiguration(
new Uri(config.GetConnectionString("WorldBuilder")),
config["BlackFolderGames:Authentication:Neo4j:Username"],
config["BlackFolderGames:Authentication:Neo4j:Password"]));
services.AddSingleton <IGraphClientFactory, GraphClientFactory>();
services.AddScoped <IWorldBuilderRepository, WorldBuilderRepository>();
}
protected override void Load(ContainerBuilder builder)
{
Assembly assembly = typeof(LibraryModule).Assembly;
// if (_environment.IsDevelopment())
// {
// builder.RegisterAssemblyTypes(assembly)
// .Where(t => t.Name.StartsWith("Mock")
// && !t.IsInterface
// && t.Name.EndsWith("Processor"))
// .AsImplementedInterfaces()
// .InstancePerLifetimeScope();
// builder.RegisterAssemblyTypes(assembly)
// .Where(t => t.Name.StartsWith("Mock")
// && !t.IsInterface
// && t.Name.EndsWith("Manager"))
// .AsImplementedInterfaces()
// .SingleInstance();
// }
builder.RegisterAssemblyTypes(assembly)
.Where(t => !t.Name.StartsWith("Mock") &&
!t.IsInterface &&
t.Name.EndsWith("Processor"))
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(assembly)
.Where(t => !t.Name.StartsWith("Mock") &&
!t.IsInterface &&
t.Name.EndsWith("Manager"))
.AsImplementedInterfaces()
.SingleInstance();
builder.Register(context =>
{
var neo4jOptions = context.Resolve <IOptionsSnapshot <Neo4jOptions> >();
return(NeoServerConfiguration.GetConfiguration(new Uri(neo4jOptions.Value.Uri), neo4jOptions.Value.UserName, neo4jOptions.Value.Password));
})
.SingleInstance();
builder.RegisterType <GraphClientFactory>()
.As <IGraphClientFactory>()
.SingleInstance();
builder.RegisterType <ProjectReferencesContext>().SingleInstance();
builder.RegisterType <DocumentContext>().SingleInstance();
}
public static NeoClient Create()
{
if (_neoClient == null)
{
_neoClient = new NeoClient();
NeoServerConfiguration config = NeoServerConfiguration.GetConfiguration(
new Uri("https://hobby-cbepnjdfkcnpgbkeccdhepbl.dbs.graphenedb.com:24780/db/data/"), "serviceuser",
"b.oTEvTxwdQmJa.8MkxAIV51kGfdcFu");
IGraphClientFactory factory = new GraphClientFactory(config);
_neoClient._client = factory.Create();
}
return(_neoClient);
}
public async Task Test1()
{
var graphClientFactory = new GraphClientFactory(
NeoServerConfiguration.GetConfiguration(
new Uri("http://localhost:32772/db/data"),
"neo4j",
"Password1"));
var timeTreeFactory = new TimeTreeServiceFactory(graphClientFactory, new TimeTreeConfiguration());
var timeTreeService = timeTreeFactory.Create();
var date = DateTimeOffset.UtcNow;
for (var index = 0; index < 100; ++index)
{
await timeTreeService.Get(date).ConfigureAwait(true);
date = date.AddSeconds(18).AddMinutes(14).AddHours(1.3).AddDays(2.3);
}
}
public void ShouldThrowExceptionIfRootApiIsNotDefined()
{
using (var testHarness = new RestTestHarness
{
{ MockRequest.Get("/"), new MockResponse {
StatusCode = HttpStatusCode.OK
} }
})
{
var httpClient = testHarness.GenerateHttpClient(testHarness.BaseUri);
var executeConfiguration = new ExecutionConfiguration
{
HttpClient = httpClient,
UserAgent =
string.Format("Neo4jClient/{0}", typeof(NeoServerConfiguration).Assembly.GetName().Version),
UseJsonStreaming = true,
JsonConverters = GraphClient.DefaultJsonConverters
};
NeoServerConfiguration.GetConfiguration(new Uri(testHarness.BaseUri), null, null, executeConfiguration);
}
}
public async Task GraphClientFactoryUseCase()
{
const string queryText = @"RETURN d";
var cypherQuery = new CypherQuery(queryText, new Dictionary <string, object>(), CypherResultMode.Set, CypherResultFormat.Rest, "neo4j");
var cypherApiQuery = new CypherStatementList {
new CypherTransactionStatement(cypherQuery)
};
using (var testHarness = new RestTestHarness
{
{ MockRequest.Get("/"), MockResponse.NeoRoot20() },
{ MockRequest.PostObjectAsJson("/transaction/commit", cypherApiQuery), new MockResponse {
StatusCode = HttpStatusCode.OK
} }
})
{
var httpClient = testHarness.GenerateHttpClient(testHarness.BaseUri);
var executeConfiguration = new ExecutionConfiguration
{
HttpClient = httpClient,
UserAgent = $"Neo4jClient/{typeof(NeoServerConfiguration).Assembly.GetName().Version}",
UseJsonStreaming = true,
JsonConverters = GraphClient.DefaultJsonConverters
};
var configuration = await NeoServerConfiguration.GetConfigurationAsync(new Uri(testHarness.BaseUri), null, null, null, null, executeConfiguration);
var factory = new GraphClientFactory(configuration);
using (var client = await factory.CreateAsync(httpClient))
{
await client.Cypher.Return <object>("d").ExecuteWithoutResultsAsync();
}
}
}
private void RegisterGraphStore(ILogger logger)
{
var verifier = new ProviderVerifier();
if (_configuration.GraphStore == null ||
string.IsNullOrEmpty(_configuration.GraphStore?.Url) ||
!verifier.IsGraphServiceRunning(_configuration.GraphStore?.Url,
_configuration.GraphStore?.Username,
_configuration.GraphStore?.Password,
logger))
{
_autofacContainerBuilder.RegisterType <NullGraphStore>()
.As <IGraphStore>()
.SingleInstance();
return;
}
_autofacContainerBuilder.Register(context => NeoServerConfiguration.GetConfiguration(new Uri($"{_configuration.GraphStore.Url}/db/data"),
_configuration.GraphStore.Username,
_configuration.GraphStore.Password))
.SingleInstance();
_autofacContainerBuilder.RegisterType <GraphClientFactory>()
.As <IGraphClientFactory>()
.SingleInstance();
_autofacContainerBuilder.Register(ctx =>
{
var transactionContext = AmbientTransactionContext.Current;
var unitOfWork = (UnitOfWork)transactionContext?.Items["UnitOfWork"];
return(unitOfWork != null ? unitOfWork.GraphStore :
new GraphStore(ctx.Resolve <IGraphClientFactory>().Create(), false));
})
.As <IGraphStore>()
.InstancePerLifetimeScope();
}
public void GraphClientFactoryUseCase()
{
const string queryText = @"MATCH (d) RETURN d";
var cypherQuery = new CypherQuery(queryText, null, CypherResultMode.Set, CypherResultFormat.Rest);
var cypherApiQuery = new CypherApiQuery(cypherQuery);
using (var testHarness = new RestTestHarness
{
{ MockRequest.Get("/"), MockResponse.NeoRoot() },
{ MockRequest.PostObjectAsJson("/cypher", cypherApiQuery), new MockResponse {
StatusCode = HttpStatusCode.OK
} }
})
{
var httpClient = testHarness.GenerateHttpClient(testHarness.BaseUri);
var executeConfiguration = new ExecutionConfiguration
{
HttpClient = httpClient,
UserAgent =
string.Format("Neo4jClient/{0}", typeof(NeoServerConfiguration).Assembly.GetName().Version),
UseJsonStreaming = true,
JsonConverters = GraphClient.DefaultJsonConverters
};
var configuration = NeoServerConfiguration.GetConfiguration(new Uri(testHarness.BaseUri), null, null, executeConfiguration);
var factory = new GraphClientFactory(configuration);
using (var client = factory.Create(httpClient))
{
client.Cypher.Match("(d)").Return <object>("d").ExecuteWithoutResults();
}
}
}
public async Task ShouldThrowExceptionIfRootApiIsNotDefined()
{
using (var testHarness = new RestTestHarness
{
{ MockRequest.Get("/"), new MockResponse {
StatusCode = HttpStatusCode.OK
} }
})
{
var httpClient = testHarness.GenerateHttpClient(testHarness.BaseUri);
var executeConfiguration = new ExecutionConfiguration
{
HttpClient = httpClient,
UserAgent = $"Neo4jClient/{typeof(NeoServerConfiguration).Assembly.GetName().Version}",
UseJsonStreaming = true,
JsonConverters = GraphClient.DefaultJsonConverters
};
await Assert.ThrowsAsync <InvalidOperationException>(async() => await NeoServerConfiguration.GetConfigurationAsync(new Uri(testHarness.BaseUri), null, null, null, null, executeConfiguration));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
//GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"), "neo4j", "misahaker69");
//client.Connect();
//services.AddSingleton<IGraphClient>(provider => client);
services.AddSingleton <IGraphClientFactory>(provider => new GraphClientFactory(NeoServerConfiguration.GetConfiguration(new Uri("http://localhost:7474/db/data"), "neo4j", "misacringeboy")));
services.AddSingleton <IRedisClientsManager>(c => new RedisManagerPool("127.0.0.1:6379"));
services.AddScoped <NotificationService, NotificationService>();
services.AddScoped <RedisMessageService, RedisMessageService>();
services.AddScoped <IUserRepository, UserRepoistory>();
services.AddScoped <IPostRepository, PostRepository>();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(Configuration.GetSection("AppSettings:Token").Value)),
RequireExpirationTime = true,
ValidateLifetime = true,
ClockSkew = TimeSpan.FromMinutes(0),
ValidateIssuer = false,
ValidateAudience = false
};
});
services.AddSignalR();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
RegisterAppInsights(services);
services
.AddCustomHealthCheck(Configuration)
.AddMvc(options =>
{
options.Filters.Add(typeof(HttpGlobalExceptionFilter));
})
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
.AddXmlSerializerFormatters()
.AddControllersAsServices();
services.Configure <PagesSettings>(Configuration);
ConfigureAuthService(services);
if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
{
services.AddSingleton <IServiceBusPersisterConnection>(sp =>
{
var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();
var serviceBusConnectionString = Configuration["EventBusConnection"];
var serviceBusConnection = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);
return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
});
}
else
{
services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
{
var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();
var factory = new ConnectionFactory()
{
HostName = Configuration["EventBusConnection"]
};
if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
{
factory.UserName = Configuration["EventBusUserName"];
}
if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
{
factory.Password = Configuration["EventBusPassword"];
}
var retryCount = 5;
if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
{
retryCount = int.Parse(Configuration["EventBusRetryCount"]);
}
return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
});
}
// Add framework services.
services.AddSwaggerGen(options =>
{
options.DescribeAllEnumsAsStrings();
options.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
{
Title = "Pages HTTP API",
Version = "v1",
Description = "The Pages Service HTTP API",
TermsOfService = "Terms Of Service"
});
options.AddSecurityDefinition("oauth2", new OAuth2Scheme
{
Type = "oauth2",
Flow = "implicit",
AuthorizationUrl = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/authorize",
TokenUrl = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/token",
Scopes = new Dictionary <string, string>()
{
{ "pages", "Pages API" }
}
});
options.OperationFilter <AuthorizeCheckOperationFilter>();
});
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder
//.SetIsOriginAllowed((host) => true)
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
RegisterEventBus(services);
services.AddSingleton <NeoServerConfiguration>(provider => {
return(NeoServerConfiguration
.GetConfiguration(new Uri(Configuration.GetValue <string>("Neo4jConnectionString")), "neo4j", "password"));
});
services.AddSingleton <IGraphClientFactory, GraphClientFactory>();
services.AddSingleton <PagesContext, PagesContext>();
services.AddTransient <IPageRepository, PageRepository>();
services.AddTransient <IPageService, PageService>();
services.AddTransient <IZoneRepository, ZoneRepository>();
services.AddTransient <IZoneService, ZoneService>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <IIdentityService, IdentityService>();
services.AddOptions();
//configure autofac
var container = new ContainerBuilder();
container.Populate(services);
return(new AutofacServiceProvider(container.Build()));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddSingleton(_ => Configuration);
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("Authentication")));
services.AddDefaultIdentity <IdentityUser>()
.AddEntityFrameworkStores <ApplicationDbContext>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddAuthentication().AddGoogle(g =>
{
g.ClientId = Configuration["BlackFolderGames:Authentication:Google:ClientId"];
g.ClientSecret = Configuration["BlackFolderGames:Authentication:Google:ClientSecret"];
string scopes = Configuration["BlackFolderGames:Authentication:Google:Scopes"];
if (!string.IsNullOrEmpty(scopes))
{
foreach (string scope in scopes.Split('|'))
{
g.Scope.Add(scope);
}
}
});
services.AddAuthorization(options =>
{
options.AddPolicy("CanEditClaims", policy =>
policy.RequireAssertion(context =>
context.User.HasClaim(c =>
c.Issuer == "LOCAL AUTHORITY" &&
c.Type == "CanEditClaims")));
options.AddPolicy("CanViewUsers", policy =>
policy.RequireAssertion(context =>
context.User.HasClaim(c =>
c.Issuer == "LOCAL AUTHORITY" &&
c.Type == "CanViewUsers")));
options.AddPolicy("CanSuspendUsers", policy =>
policy.RequireAssertion(context =>
context.User.HasClaim(c =>
c.Issuer == "LOCAL AUTHORITY" &&
c.Type == "CanSuspendUsers")));
options.AddPolicy("CanBanUsers", policy =>
policy.RequireAssertion(context =>
context.User.HasClaim(c =>
c.Issuer == "LOCAL AUTHORITY" &&
c.Type == "CanBanUsers")));
});
services.AddSingleton <NeoServerConfiguration>(
context => NeoServerConfiguration.GetConfiguration(
new Uri(Configuration["BlackFolderGames:WorldBuilder:Uri"])
, Configuration["BlackFolderGames:WorldBuilder:User"]
, Configuration["BlackFolderGames:WorldBuilder:Password"]));
services.AddSingleton <IGraphClientFactory, GraphClientFactory>();
services.AddSingleton <IImageServiceFactory, ImageServiceFactory>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IWorldBuilderRepository, WorldBuilderRepository>();
services.AddScoped <IWorldService, WorldService>();
}
public new void Connect(NeoServerConfiguration configuration = null)
{
}
public static void Initialize()
{
#region Neo4j
_container.RegisterType <NeoServerConfiguration>(new ContainerControlledLifetimeManager(), new InjectionFactory(o => NeoServerConfiguration.GetConfiguration(new Uri(Settings.Default.Neo4jServerUrl), Settings.Default.Neo4jUserName, Settings.Default.Neo4jPassword)));
_container.RegisterType <IGraphClientFactory, GraphClientFactory>(new ContainerControlledLifetimeManager());
_container.RegisterType <IUnitOfWorkFactory, UnitOfWorkFactory>(new ContainerControlledLifetimeManager());
#endregion
#region NHibernate
_container.RegisterInstance(NHibernateConfiguration.SessionFactory, new ContainerControlledLifetimeManager());
#endregion
#region AOP
#region Call Handlers
_container.RegisterType <ICallHandler, LoggingCallHandler>(typeof(LoggingCallHandler).Name, new ContainerControlledLifetimeManager(), new InjectionProperty(nameof(LoggingCallHandler.Order), 1));
_container.RegisterType <ICallHandler, TransactionCallHandler>(typeof(TransactionCallHandler).Name, new ContainerControlledLifetimeManager(), new InjectionProperty(nameof(TransactionCallHandler.Order), 2));
#endregion
#region Controllers Interception
_container.AddNewExtension <Interception>();
Interception interception = _container.Configure <Interception>();
Assembly.GetExecutingAssembly().GetTypes().Where(o => o.IsSubclassOf(typeof(ApiController))).ToList().ForEach(o => interception.SetInterceptorFor(o, new VirtualMethodInterceptor()));
#endregion
#endregion
#region DAOs
_container.RegisterType <IUserDao>(new ContainerControlledLifetimeManager(), new InjectionFactory(o =>
{
var dao = new UserDao();
dao.SetSessionFactory(NHibernateConfiguration.SessionFactory);
return(dao);
}));
#endregion
#region Validators
_container.RegisterType <CreateHotSpotInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <CreateRefugeeInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <UpdateRefugeeInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <UpdateRefugeeInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <AuthenticationInputDtoValidator>(new ContainerControlledLifetimeManager());
_container.RegisterType <CreateRefugeesFamilyRelationshipInputDtoValidator>(new ContainerControlledLifetimeManager());
#endregion
#region Utilities
_container.RegisterType <ICurrentHttpRequest, CurrentHttpRequest>(new ContainerControlledLifetimeManager());
#endregion
}
static void Main(string[] args)
{
BasicConfigurator.Configure();
var builder = new ContainerBuilder();
builder.Register(context => NeoServerConfiguration.GetConfiguration(new Uri("http://localhost:7474/db/data"), "neo4j", "falcons"))
.SingleInstance();
builder.RegisterType <GraphClientFactory>()
.As <IGraphClientFactory>()
.SingleInstance();
builder.Register(cc => new WriteDatabase(cc.Resolve <IGraphClientFactory>()))
.As <IWriteDb>()
.SingleInstance();
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
var scheduledImports = new List <Type>();
foreach (var assembly in assemblies)
{
var assemblyImports = (from t in assembly.GetTypes()
where t.IsClass && !t.IsAbstract && t.IsSubclassOf(typeof(ScheduledImport))
select t).ToList();
scheduledImports.AddRange(assemblyImports);
}
foreach (var scheduledImport in scheduledImports)
{
builder.RegisterType(scheduledImport)
.Named <IScheduledImport>(scheduledImport.Name)
.As <IScheduledImport>()
.SingleInstance();
}
builder.Register(c => new DataImporter(c.Resolve <IEnumerable <IScheduledImport> >())).As <DataImporter>().SingleInstance();
var container = builder.Build();
HostFactory.Run(x =>
{
x.UseAutofacContainer(container);
x.Service <DataImporter>(s =>
{
s.ConstructUsingAutofacContainer();
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
s.OwinEndpoint(app =>
{
app.Domain = "localhost";
app.Port = 45678;
app.ConfigureAppBuilder(appBuilder =>
{
appBuilder.UseCors(CorsOptions.AllowAll);
appBuilder.UseAutofacMiddleware(container);
appBuilder.UseNancy(bt => bt.Bootstrapper = new NancyBootstrapper(container));
});
});
});
x.RunAsPrompt();
x.SetDescription("Ballistic Reports UI");
x.SetDisplayName("BallisticReports");
x.SetServiceName("BallisticReports");
x.StartAutomatically();
});
}
