/// <summary>
/// Sets up the IOC Container loading modules from the Currently Executing Assembly
/// </summary>
public static void RegisterAssembly()
{
_resolver = new NinjectResolver(Assembly.GetExecutingAssembly());
//This is where the actual hookup to the MVC Pipeline is done.
DependencyResolver.SetResolver(_resolver);
}
public void GivenNoConfiguration_ShouldReturnsNull()
{
var depResolver = new NinjectResolver();
//act & assert
Assert.That(depResolver.GetService(typeof(IFakeService)), Is.Null);
}
/// <summary>
/// Configuração do método de autenticação do API.
/// </summary>
/// <param name="appBuilder"></param>
/// <param name="dependencyResolver"></param>
public static void ConfigureAuth(this IAppBuilder appBuilder, NinjectResolver dependencyResolver)
{
//// Microsoft.Owin.Security.Cookies
//// Microsoft.AspNet.Identity.Core
//// We're enabling cookie authentication, but with a specific cookie name.
//appBuilder.UseCookieAuthentication(new CookieAuthenticationOptions
//{
// AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
// CookieHttpOnly = true,
// CookieName = "KlinderRH.Auth"
//});
appBuilder.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/api/auth"),
Provider = (IOAuthAuthorizationServerProvider)dependencyResolver.Get<IAuthorizationServerProvider>(),
AccessTokenExpireTimeSpan = TimeSpan.FromMinutes(30),
ApplicationCanDisplayErrors = true,
AllowInsecureHttp = true
});
appBuilder.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions()
{
AuthenticationMode = AuthenticationMode.Active,
AuthenticationType = "Bearer"
});
}
public void Ninject_Resolve_Success()
{
IKernel kernel = new StandardKernel();
kernel.Bind<IMath>().To<Math>();
ISlowpoke<IKernel> slowpoke = new NinjectResolver();
slowpoke.Resolve(typeof(IMath), kernel);
}
public void GivenSingletonConfiguration_WhenResolveDepedency_ShouldReturnsTheRightType()
{
//arrange
var depResolver = new NinjectResolver(new FakeNinjectModule());
//act & assert
Assert.That(depResolver.GetService(typeof(IFakeService)), Is.TypeOf <FakeService>());
}
public void NinjectResolver_DoesNot_Resolve_NonRegistered_ContactRepository_Test()
{
var kernel = new StandardKernel();
var resolver = new NinjectResolver(kernel);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNull(instance);
}
public void NinjectResolver_DoesNot_Resolve_NonRegistered_ContactRepository_Test()
{
var kernel = new StandardKernel();
var resolver = new NinjectResolver(kernel);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNull(instance);
}
public void CanResolve_RequestScopedDependency()
{
//arrange
var depResolver = new NinjectResolver();
depResolver.AddRequestScopedModules(new FakeNinjectModule());
//assert
Assert.That(depResolver.BeginScope().GetService(typeof(IFakeService)), Is.TypeOf <FakeService>());
}
public void Ninject_Resolve_Success()
{
IKernel kernel = new StandardKernel();
kernel.Bind <IMath>().To <Math>();
ISlowpoke <IKernel> slowpoke = new NinjectResolver();
slowpoke.Resolve(typeof(IMath), kernel);
}
public void NinjectResolver_Resolves_Registered_ContactRepository_Test()
{
var kernel = new StandardKernel();
kernel.Bind<IContactRepository>().ToConstant(new InMemoryContactRepository());
var resolver = new NinjectResolver(kernel);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNotNull(instance);
}
public void GivenSingletonConfiguration_WhenCallingBeginScope_EachTimeShouldReturnTheSame()
{
//arrange
var depResolver = new NinjectResolver(new FakeNinjectModule());
//act
var instance1 = depResolver.BeginScope().GetService(typeof(IFakeService));
var instance2 = depResolver.BeginScope().GetService(typeof(IFakeService));
Assert.That(instance1, Is.EqualTo(instance2));
}
public void NinjectResolver_Resolves_Registered_ContactRepository_Test()
{
var kernel = new StandardKernel();
kernel.Bind <IContactRepository>().ToConstant(new InMemoryContactRepository());
var resolver = new NinjectResolver(kernel);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNotNull(instance);
}
private void ConfigureResolver(HttpConfiguration config, IAppBuilder app)
{
var resolver = new NinjectResolver(new SingletonServiceRegistrations());
resolver.AddRequestScopedModules(new ScopedServiceRegistration());
if (app.IsTestingEnvironment())
{
resolver.AddRequestScopedModules(new DbContextRegistration());
}
config.DependencyResolver = resolver;
}
public void GivenSingletonConfiguration_WhenWeResolveDependencies_ShouldTheSameInstance()
{
//arrange
var depResolver = new NinjectResolver(new FakeNinjectModule());
//act
var instanceFirstCall = depResolver.GetService(typeof(IFakeService));
var instanceSecondCall = depResolver.GetService(typeof(IFakeService));
//assert
Assert.That(instanceFirstCall, Is.EqualTo(instanceSecondCall));
}
public void GivenScopedConfiguration_WhenCallingBeginScope_EachTimeShouldReturnNewInstance()
{
//arrange
var depResolver = new NinjectResolver();
depResolver.AddRequestScopedModules(new FakeNinjectModule());
//act
var instance1 = depResolver.BeginScope().GetService(typeof(IFakeService));
var instance2 = depResolver.BeginScope().GetService(typeof(IFakeService));
Assert.That(instance1, Is.Not.EqualTo(instance2));
}
/// <summary>
/// Registra o container de IoC do API.
/// </summary>
/// <param name="appBuilder"></param>
public static HttpConfiguration Register(IAppBuilder appBuilder)
{
var dependencyResolver = new NinjectResolver(new IoC().Kernel);
dependencyResolver.Load(Assembly.GetExecutingAssembly());
appBuilder.ConfigureAuth(dependencyResolver);
return new HttpConfiguration()
{
DependencyResolver = dependencyResolver
};
}
/// <summary>
/// Creates the kernel that will manage your application.
/// </summary>
/// <returns>The created kernel.</returns>
private static IKernel CreateKernel()
{
var kernel = NinjectResolver.BuildKernel();
try
{
kernel.Bind <Func <IKernel> >().ToMethod(ctx => () => new Bootstrapper().Kernel);
kernel.Bind <IHttpModule>().To <HttpApplicationInitializationHttpModule>();
RegisterServices(kernel);
return(kernel);
}
catch
{
kernel.Dispose();
throw;
}
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var createservice = new NinjectResolver(Startup.CreateKernel());
var service = createservice.GetService <IUserService>();
var password = Utilities.Encrypt(context.Password);
var User = service.GetUserbyCredential(context.UserName, password).Result;
if (User == null)
{
context.SetError("Error", "Provided credentials are not valid");
context.Rejected();
return;
}
else
{
ClaimsIdentity identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity = new ClaimsIdentity(Startup.OAuthServerOptions.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName));
var props = new AuthenticationProperties(new Dictionary <string, string>
{
{
"Id", User.Id.ToString()
},
{
"userTypeId", User.UserTypeId.ToString()
},
{
"fullName", User.FullName.ToString()
},
{
"email", User.Email.ToString()
},
});
var ticket = new AuthenticationTicket(identity, props);
context.Validated(ticket);
}
}
internal static void ConfigureIdentityServer(IAppBuilder app)
{
_kernel = NinjectResolver.BuildKernel();
var userService = _kernel.Get <IUserService>();
var scopeStore = _kernel.Get <IScopeStore>();
var clientStore = _kernel.Get <IClientStore>();
var factory = new IdentityServerServiceFactory
{
ScopeStore = new Registration <IScopeStore>(scopeStore),
ClientStore = new Registration <IClientStore>(clientStore),
UserService = new Registration <IUserService>(userService),
CorsPolicyService = new Registration <ICorsPolicyService>(new DefaultCorsPolicyService
{
AllowAll = true,
})
};
factory.Register(new Registration <HttpContext>(resolver => HttpContext.Current));
factory.Register(
new Registration <HttpContextBase>(resolver => new HttpContextWrapper(resolver.Resolve <HttpContext>())));
factory.Register(new Registration <HttpRequestBase>(resolver => resolver.Resolve <HttpContextBase>().Request));
factory.Register(new Registration <HttpResponseBase>(resolver => resolver.Resolve <HttpContextBase>().Response));
factory.Register(
new Registration <HttpServerUtilityBase>(resolver => resolver.Resolve <HttpContextBase>().Server));
factory.Register(
new Registration <HttpSessionStateBase>(resolver => resolver.Resolve <HttpContextBase>().Session));
app.Map("/core", idsrvApp =>
{
idsrvApp.UseIdentityServer(new IdentityServerOptions
{
Factory = factory,
SigningCertificate = LoadCertificate(),
SiteName = "Photograph.IdentityServer",
RequireSsl = false
});
});
}
/// <summary>
/// Creates the kernel that will manage your application.
/// </summary>
/// <returns>The created kernel.</returns>
private static IKernel CreateKernel()
{
var kernel = new StandardKernel();
try
{
kernel.Bind <Func <IKernel> >().ToMethod(ctx => () => new Bootstrapper().Kernel);
kernel.Bind <IHttpModule>().To <HttpApplicationInitializationHttpModule>();
RegisterServices(kernel);
// Install our Ninject-based IDependencyResolver into the Web API config
NinjectResolver nR = new NinjectResolver(kernel);
GlobalConfiguration.Configuration.DependencyResolver = (System.Web.Http.Dependencies.IDependencyResolver)nR;
return(kernel);
}
catch
{
kernel.Dispose();
throw;
}
}
/// <summary>
/// Register types for copy, convert, and compare with
/// Ninject and create a resolver which is assigned to the
/// <see cref="IocHandler.IocResolver"/>. The <see cref="INinjectContainer"/>
/// which is used within the <see cref="IocHandler.IocResolver"/> is being
/// returned for further manipulation from within the calling test or test setup method.
/// </summary>
public static IKernel Initialize()
{
var settings = new NinjectSettings();
var kernel = new StandardKernel(settings);
var resolver = new NinjectResolver(kernel);
IocHandler.Instance.IocResolver = resolver;
// Dependencies from BBT.StrategyPattern
kernel.Bind(typeof(IStrategyLocator <>)).To(typeof(NinjectStrategyLocator <>));
kernel.Bind(typeof(IInstanceCreator <,>)).To(typeof(GenericInstanceCreator <,>));
IocHandler.Instance.DoIocRegistrations(
(Type abstraction, Type implementation) =>
kernel.Bind(abstraction).To(implementation),
(Type abstraction, Type implementation) =>
kernel.Bind(abstraction).To(implementation).InTransientScope());
return(kernel);
}
public static void Register(HttpConfiguration config)
{
var registrations = new NinjectRegistrations();
var kernel = new StandardKernel(registrations);
var ninjectResolver = new NinjectResolver(kernel);
config.DependencyResolver = ninjectResolver;
config.Routes.MapHttpRoute(
name: "GetCommands",
routeTemplate: "api/commands",
defaults: new { controller = "commands", action = "Commands" },
constraints: new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) }
);
config.Routes.MapHttpRoute(
name: "MetaApi",
routeTemplate: "api/commands/meta",
defaults: new { controller = "commands", action = "Meta" },
constraints: new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) }
);
config.Routes.MapHttpRoute(
name: "PerformApi",
routeTemplate: "api/commands/perform",
defaults: new { controller = "commands", action = "Perform" },
constraints: new { httpMethod = new HttpMethodConstraint(HttpMethod.Post) }
);
config.Routes.MapHttpRoute(
name: "CommandApi",
routeTemplate: "api/commands/{cmdName}/{action}",
defaults: new { controller = "commands", action = "Get" },
constraints: new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) }
);
}
protected override void OnStart(string[] args)
{
try
{
_logger.Info("Try start");
var ninjectResolver = new NinjectResolver();
ninjectResolver.Kernel.Bind <IMonitorService>().To <MonitorService>()
.WithConstructorArgument("messageBus", _messageBus)
.WithConstructorArgument("dateFromUpdater", ConfigService.Instance)
.WithConstructorArgument("repository", _repository);
var config = new HttpSelfHostConfiguration(ConfigService.Instance.HealthCheck.Url);
config.DependencyResolver = ninjectResolver;
config.Routes.MapHttpRoute(name: "API", routeTemplate: "{controller}/{action}");
_server = new HttpSelfHostServer(config);
_server.OpenAsync().Wait();
_logger.Info("Api server started");
_messageBus.AddConsumerHandler(new GAActivationMessageHandler());
_messageBus.AddConsumerHandler(new GAConnectionMessageHandler());
_consumer = _messageBus.Consume("main");
_sendService.Start();
_logger.Info("Start successful");
}
catch (Exception ex)
{
_logger.Error(ex);
throw;
}
}
public NinjectMvcResolver(NinjectResolver resolver, IKernel kernel) : base(kernel)
{
_resolver = resolver;
}
public NinjectControllerFactory()
{
ninjectKernel = new StandardKernel();
NinjectResolver.AddBindings(ninjectKernel);
}
/// <summary>
/// Init the Resolver
/// </summary>
/// <param name="resolver"></param>
protected virtual void InitResolver(NinjectResolver resolver)
{
}
public void SetUp()
{
resolver = new NinjectResolver(new MainModule());
}
/// <summary>
/// Sets up the IOC using the Ninject Modules provided
/// </summary>
/// <param name="modules">Modules</param>
public static void RegisterModules(NinjectModule[] modules)
{
_resolver = new NinjectResolver(modules);
DependencyResolver.SetResolver(_resolver);
}
public NinjectMvcResolver(NinjectResolver resolver, IKernel kernel) : base(kernel)
{
_resolver = resolver;
}
