private static void Main()
{
try
{
Console.WriteLine($"Starting {Assembly.GetEntryAssembly().GetName().Name}...{Environment.NewLine}");
DependencyConfig.BuildContainer();
var categoryModels = new List <CategoryModel>
{
new CategoryModel {
CategoryName = "CategoryName", Description = "Description"
},
new CategoryModel {
CategoryName = "CategoryName", Description = "Description"
},
new CategoryModel {
CategoryName = "CategoryName", Description = "Description"
}
};
using (var northwindUoW = DependencyConfig.Container.GetInstance <INorthwindSingleDbContextUnitOfWork>())
{
Console.WriteLine($"Inserting {categoryModels.Count} Categories into Northwind.Categories...{Environment.NewLine}");
var results = northwindUoW.InsertCategoriesAsync(categoryModels).GetAwaiter().GetResult();
Console.WriteLine($"New IDs: {string.Join(',', results.Select(x => x.CategoryId))}{Environment.NewLine}");
Console.WriteLine($"Query Northwind.Categories for new records...{Environment.NewLine}");
}
Console.WriteLine("Press ENTER to exit.");
Console.ReadLine();
}
finally
{
DependencyConfig.Container.Dispose();
}
}
/// <summary>
///
/// </summary>
protected void Application_Start()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
// Register your types, for instance using the scoped lifestyle:
// Since the interfaces and models exisit in a service project, we will set them up there...
DependencyConfig.Setup(container);
container.Verify();
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public void ConfigExceptionTests()
{
DependencyConfig dependencies = new DependencyConfig();
dependencies.Register <IRepository, RepositoryImpl>(LifeTime.Instance);
ArgumentException ex = Assert.Throws <ArgumentException>(() => dependencies.Register <IRepository, RepositoryImpl>(LifeTime.Instance));
Assert.AreEqual("Such dependency is already registered", ex.Message);
ArgumentException ex2 = Assert.Throws <ArgumentException>(() => dependencies.Register(typeof(IRepository), typeof(ServiceImpl1), LifeTime.Instance));
Assert.AreEqual("TImplementation doesn't implement TDependency interface", ex2.Message);
ArgumentException ex3 = Assert.Throws <ArgumentException>(() => dependencies.Register(typeof(IService), typeof(AbstractClass), LifeTime.Instance));
Assert.AreEqual("TImplementation can't be an abstract class", ex3.Message);
ArgumentException ex4 = Assert.Throws <ArgumentException>(() => dependencies.Register(typeof(IService), typeof(NonConstructor), LifeTime.Instance));
Assert.AreEqual("TImplementation doesn't have any public constructors", ex4.Message);
}
protected override void RegisterApplicationComponents(IApplicationBuilder app, IKernel kernel)
{
app.UseSignalR(routes =>
{
routes.MapHub <TasksHub>("/tasks");
});
_applicationBuilder = app;
kernel.Bind <IHubContext <TasksHub> >().ToMethod(x => GetHubContext <TasksHub>());
kernel.Bind <IHostedService>().To <TasksMessagingService>();
DependencyConfig.Configure(kernel);
DependencyResolver.SetResolver(kernel);
var tuple = kernel.Get <Tuple <IContextStorage, IConnectionContext> >();
var storage = tuple.Item1;
var context = tuple.Item2;
using (context.Scope())
{
storage.Get().Database.Migrate();
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info
{
Title = "My Core.WebApi Starter kit",
Version = "v1",
Description = "This is a WebApi.Core starter kit.",
//TermsOfService = "None",
//Contact = new Contact { Name = "Vinicius Paiva", Email = "*****@*****.**", Url = "https://www.linkedin.com/in/vinicius-da-silva-50963923" },
});
//Set the comments path for the swagger json and ui.
var basePath = PlatformServices.Default.Application.ApplicationBasePath;
var xmlPath = Path.Combine(basePath, "WebApi.BaseApp.xml");
c.IncludeXmlComments(xmlPath);
});
services.AddMvcCore().AddApiExplorer();
DependencyConfig.ConfigureDependencies(services, Configuration);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
//UnityConfig.RegisterComponents();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilter(GlobalFilters.Filters);
DependencyConfig.Config();
//FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
//RouteConfig.RegisterRoutes(RouteTable.Routes);
//BundleConfig.RegisterBundles(BundleTable.Bundles);
//var container = new Container();
////container.Register<IDbContext, IocDbContext>();
//container.Register<IDbContext, IocDbContext>();
////container.Register<IUserService, UserService>();
//container.Register<IRepository<User>, Repository<User>>();
//container.Register<IRepository<UserProfile>, Repository<UserProfile>>();
//container.Verify();
//DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
//GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorDependencyResolver(container);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
DependencyConfig.Register();
}
public void Should_return_true_if_identical_but_BuildInfos_are_ordered_different(DependencyConfig config)
{
List <BuildInfo> buildInfos = config.BuildInfos.ToList();
buildInfos.Reverse();
var otherConfig = new DependencyConfig()
{
BuildConfigId = config.BuildConfigId,
BuildInfos = buildInfos,
};
Assert.Equal(config, otherConfig);
}
protected BaseTest(ITestOutputHelper output)
{
Output = output;
Container = DependencyConfig.BuildContainer();
}
public async Task SerilogUsedWhenCakeMissing(Mock <IServiceCollection> mockColl, ClearVariableSetArgs args)
{
await DependencyConfig.Setup(args, null, mockColl.Object, false).ConfigureAwait(false);
mockColl.Verify(m => m.Add(It.Is <ServiceDescriptor>(s => s.ServiceType == typeof(ILogger) && ((CakeLoggerAbstraction)s.ImplementationInstance)._serilogLogger != null)), Times.Once);
}
public async Task NullOrEmptyApiKeyThrows(string apiKey, Mock <IServiceCollection> mockColl, ArgsBase args)
{
args.ApiKey = apiKey;
Func <Task> sut = () => DependencyConfig.Setup(args, null, mockColl.Object, false);
await sut.Should().ThrowAsync <ArgumentException>().ConfigureAwait(false);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
Services.Services.TaskScheduler.Instance.ScheduleTask(02, 30, 24,
() =>
{
new Services.Services.MailService("morning");
});
Services.Services.TaskScheduler.Instance.ScheduleTask(14, 30, 24,
() =>
{
new Services.Services.MailService("evening");
});
services.AddControllers();
DependencyConfig.RegisterConfig(services);
services.AddCors(o => o.AddPolicy("CabOPolicy", builder =>
{
builder.AllowAnyMethod()
.AllowAnyHeader()
.AllowAnyOrigin();
}));
services.AddDbContext <CabODbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("SqlServerConnection")), ServiceLifetime.Transient);
var key = "Experion.CabO,CabBookingSystemDevelepedByFreshersBatch";
var symmetricToken = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = true,
ValidateIssuer = true,
ValidateIssuerSigningKey = true,
ValidateLifetime = true,
ValidIssuer = "CabOAdmin",
ValidAudience = "CabOUser",
IssuerSigningKey = symmetricToken
};
});
services.AddSwaggerGen(c => {
c.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "CabO",
Description = "Cab Booking System"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = @"JWT Authorization header using the Bearer scheme. \r\n\r\n
Enter 'Bearer' [space] and then your token in the text input below.
\r\n\r\nExample: 'Bearer ANCDDDDDDDDDDDDKDKJDKWJ'",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
new List <string>()
}
});
});
services.AddControllers();
}
protected void Application_Start()
{
DependencyConfig.Configure();
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public static async Task <int> Main(string[] cmdArgs)
{
return(await Parser.Default.ParseArguments <ValidateArgs, ClearVariableSetArgs, LibraryTargetArgs, ValidateTenantArgs, UploadTenantArgs, UploadProjectArgs, ClearProjectArgs, ClearTenantArgs>(cmdArgs)
.MapResult <ValidateArgs, ClearVariableSetArgs, LibraryTargetArgs, ValidateTenantArgs, UploadTenantArgs, UploadProjectArgs, ClearProjectArgs, ClearTenantArgs, Task <int> >(
async validateArgs =>
{
await DependencyConfig.Setup(validateArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <ValidateLibraryCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async clearArgs =>
{
await DependencyConfig.Setup(clearArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <ClearVariableSetCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async libArgs =>
{
await DependencyConfig.Setup(libArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <UploadLibraryCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async validateTeanantArgs =>
{
await DependencyConfig.Setup(validateTeanantArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <ValidateTenantCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async uploadTenantArgs =>
{
await DependencyConfig.Setup(uploadTenantArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <UploadTenantCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async uploadProjectArgs =>
{
await DependencyConfig.Setup(uploadProjectArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <UploadProjectCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async clearProjectArgs =>
{
await DependencyConfig.Setup(clearProjectArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <ClearProjectCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
async clearTenantArgs =>
{
await DependencyConfig.Setup(clearTenantArgs).ConfigureAwait(false);
var cmd = DependencyConfig.Container.GetService <ClearTenantCommand>();
await cmd.Execute().ConfigureAwait(false);
return 0;
},
_ => Task.FromResult(1)
).ConfigureAwait(false));
}
public void Configuration(IAppBuilder app)
{
DependencyConfig.RegisterDependencies(app);
}
public void Should_return_false_if_not_identical(DependencyConfig config, DependencyConfig otherConfig)
{
Assert.NotEqual(config, otherConfig);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
DependencyConfig.SetAutofacWebAPI();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().ConfigureApiBehaviorOptions(options =>
{
options.SuppressConsumesConstraintForFormFileParameters = true;
});
services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
{
builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader();
}));
DependencyConfig.RegisterConfig(services);
services.AddControllers();
services.AddDbContext <MyCartDBContext>(opt => opt.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
var key = Configuration.GetValue <string>("SecretKey");
var symmetricToken = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = true,
ValidateIssuer = true,
ValidateIssuerSigningKey = true,
ValidateLifetime = true,
ValidIssuer = "Admin",
ValidAudience = "User",
IssuerSigningKey = symmetricToken
};
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "MyCart API",
Description = "Contains list of all the APIs used in MyCart",
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = @"JWT Authorization header using the Bearer scheme.
Enter 'Bearer' [space] and then your token in the text input below.
Example: 'Bearer your token'",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement()
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
},
Scheme = "oauth2",
Name = "Bearer",
In = ParameterLocation.Header,
},
new List <string>()
}
});
});
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
DependencyConfig.Register(GlobalConfiguration.Configuration);
}
public void SetUp()
{
var routeNames = Substitute.For <IRouteNames>();
_dependencyConfig = new DependencyConfig(routeNames);
}
public void ShouldDependencyRosolverWork()
{
var checkout = DependencyConfig.GetInstance <ICheckout>();
Assert.True(checkout.GetType() == typeof(Checkout.Services.Checkout));
}
public void Setup()
{
DependencyConfig.Setup();
}
public async Task UnknownTypeThrows(Mock <IServiceCollection> mockColl, UnkonwnArgs args)
{
Func <Task> sut = () => DependencyConfig.Setup(args, null, mockColl.Object, false);
await sut.Should().ThrowAsync <ArgumentException>().ConfigureAwait(false);
}
