public DbInitializerShould() { //Given var dbOptions = new DbContextOptionsBuilder <ReactAdvantageContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; var loggerMock = new Mock <ILogger <ReactAdvantageContext> >(); var tenantProviderMock = new Mock <ITenantProvider>(); tenantProviderMock.Setup(x => x.GetTenantId()).Returns((int?)null); _db = new ReactAdvantageContext(dbOptions, loggerMock.Object, tenantProviderMock.Object); _envMock = new Mock <IHostingEnvironment>(); _envMock.Setup(x => x.EnvironmentName).Returns("Test"); var userStoreMock = new Mock <IUserStore <User> >(); _userManagerMock = new Mock <UserManager <User> >(userStoreMock.Object, null, null, null, null, null, null, null, null); var roleStore = new Mock <IRoleStore <Role> >(); _roleManagerMock = new Mock <RoleManager <Role> >(roleStore.Object, null, null, null, null); _dbInitializer = new DbInitializer( _db, _envMock.Object, _userManagerMock.Object, _roleManagerMock.Object ); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, ReactAdvantageContext db) { if (env.IsDevelopment()) { app.UseBrowserLink(); app.UseDeveloperExceptionPage(); app.UseDatabaseErrorPage(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseDefaultFiles(); app.UseStaticFiles(); app.UseAuthentication(); loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); app.UseMvc(); db.EnsureSeedData(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
public ProfileService( ReactAdvantageContext db, UserManager <User> userManager, IUserClaimsPrincipalFactory <User> claimsFactory) { _db = db; _userManager = userManager; _claimsFactory = claimsFactory; }
public TaskType(ReactAdvantageContext db) { Field(c => c.Id); Field(c => c.Name, nullable: true); Field(o => o.Description, nullable: true); Field(o => o.DueDate, nullable: true); Field(o => o.Completed, nullable: false); Field(o => o.CompletionDate, nullable: true); Field <ProjectType>("project", resolve: context => db.Projects.FindAsync(context.Source.ProjectId)); }
public async Task <IActionResult> SaveAsync([FromBody] ProjectEditDto project) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var context = new ReactAdvantageContext("ReactAdvantage"); var projectService = new ProjectService(context); await projectService.CreateAsync(project); return(CreatedAtAction(nameof(GetByIdAsync), new { id = project.Id }, project)); }
public async Task <IActionResult> GetAll() { //This makes controller dependent on implementation of ProjectService var context = new ReactAdvantageContext("ReactAdvantage"); var projectService = new ProjectService(context); try { return(new ObjectResult(await projectService.GetAllAsync())); } catch (Exception ex) { return(StatusCode(500, ex)); } }
public void HaveAssignedLogger() { //Given var dbLogger = new Mock <ILogger <ReactAdvantageContext> >(); var options = new DbContextOptionsBuilder <ReactAdvantageContext>() .UseInMemoryDatabase(databaseName: "ReactAdvantage") .Options; //When using (var db = new ReactAdvantageContext(options, dbLogger.Object)) { //Then Assert.NotNull(db.Logger); Assert.Equal(dbLogger.Object, db.Logger); } }
public AccountController( ReactAdvantageContext db, UserManager <User> userManager, SignInManager <User> signInManager, IIdentityServerInteractionService interaction, IClientStore clientStore, IAuthenticationSchemeProvider schemeProvider, IEventService events) { _db = db; _userManager = userManager; _signInManager = signInManager; _interaction = interaction; _clientStore = clientStore; _schemeProvider = schemeProvider; _events = events; }
public async Task <IActionResult> GetByIdAsync(int id) { var context = new ReactAdvantageContext("ReactAdvantage"); var projectService = new ProjectService(context); try { var projectDto = await projectService.GetByIdAsync(id); if (projectDto.NoData) { return(NotFound()); } return(Ok(projectDto)); } catch (Exception ex) { return(StatusCode(500, ex)); } }
public ReactAdvantageMutation(ReactAdvantageContext db) { Field <UserType>( "addUser", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <UserInputType> > { Name = "user" } ), resolve: context => { var user = context.GetArgument <User>("user"); user.Id = 0; db.Add(user); db.SaveChanges(); return(user); }); Field <UserType>( "editUser", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <UserInputType> > { Name = "user" } ), resolve: context => { var user = context.GetArgument <User>("user"); var entity = db.Users.Find(user.Id); db.Entry(entity).CurrentValues.SetValues(user); db.SaveChanges(); return(user); }); Field <ProjectType>( "addProject", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <ProjectInputType> > { Name = "project" } ), resolve: context => { var project = context.GetArgument <Project>("project"); project.Id = 0; db.Add(project); db.SaveChanges(); return(project); }); Field <ProjectType>( "editProject", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <ProjectInputType> > { Name = "project" } ), resolve: context => { var project = context.GetArgument <Project>("project"); var entity = db.Projects.Find(project.Id); db.Entry(entity).CurrentValues.SetValues(project); db.SaveChanges(); return(project); }); Field <TaskType>( "addTask", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <TaskInputType> > { Name = "task" } ), resolve: context => { var task = context.GetArgument <Task>("task"); task.Id = 0; db.Add(task); db.SaveChanges(); return(task); }); Field <TaskType>( "editTask", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <TaskInputType> > { Name = "task" } ), resolve: context => { var task = context.GetArgument <Task>("task"); var entity = db.Tasks.Find(task.Id); db.Entry(entity).CurrentValues.SetValues(task); db.SaveChanges(); return(task); }); }
public ProjectService(ReactAdvantageContext dbContext) { _dbContext = dbContext; }
public ReactAdvantageQuery(ReactAdvantageContext db) { Name = "Query"; Field <UserType>( "user", arguments: new QueryArguments(new QueryArgument <IntGraphType> { Name = "id" }), resolve: context => db.Users.FindAsync(context.GetArgument <int>("id")) ); Field <ListGraphType <UserType> >( "users", arguments: new QueryArguments( new QueryArgument <ListGraphType <IntGraphType> > { Name = "id" }, new QueryArgument <StringGraphType> { Name = "firstname" }, new QueryArgument <StringGraphType> { Name = "lastname" }, new QueryArgument <StringGraphType> { Name = "name" }, new QueryArgument <StringGraphType> { Name = "email" }, new QueryArgument <BooleanGraphType> { Name = "isactive" } ), resolve: context => db.Users .HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <string>("firstname", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.FirstName.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <string>("lastname", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.LastName.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <string>("email", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Email.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <bool>("isactive", context), (arg, query) => query.Where(x => x.IsActive == arg)) ); Field <ProjectType>( "project", arguments: new QueryArguments(new QueryArgument <IntGraphType> { Name = "id" }), resolve: context => db.Projects.FindAsync(context.GetArgument <int>("id")) ); Field <ListGraphType <ProjectType> >( "projects", arguments: new QueryArguments( new QueryArgument <ListGraphType <IntGraphType> > { Name = "id" }, new QueryArgument <StringGraphType> { Name = "name" } ), resolve: context => db.Projects .HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))) ); Field <TaskType>( "task", arguments: new QueryArguments(new QueryArgument <IntGraphType> { Name = "id" }), resolve: context => db.Tasks.FindAsync(context.GetArgument <int>("id")) ); Field <ListGraphType <TaskType> >( "tasks", arguments: new QueryArguments( new QueryArgument <ListGraphType <IntGraphType> > { Name = "id" }, new QueryArgument <IntGraphType> { Name = "projectid" }, new QueryArgument <StringGraphType> { Name = "name" }, new QueryArgument <BooleanGraphType> { Name = "iscompleted" }, new QueryArgument <DateGraphType> { Name = "duedate" }, new QueryArgument <DateGraphType> { Name = "completiondate" } ), resolve: context => db.Tasks .HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <int>("projectid", context), (arg, query) => query.Where(x => x.ProjectId == arg)) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <bool>("iscompleted", context), (arg, query) => query.Where(x => x.Completed == arg)) .HandleQueryArgument(new ArgumentGetter <DateTime>("duedate", context), (arg, query) => query.Where(x => x.DueDate >= arg.Date && x.DueDate < arg.Date.AddDays(1))) .HandleQueryArgument(new ArgumentGetter <DateTime>("completiondate", context), (arg, query) => query.Where(x => x.CompletionDate >= arg.Date && x.CompletionDate < arg.Date.AddDays(1))) ); }
public ReactAdvantageMutation( ReactAdvantageContext db, UserManager <User> userManager, RoleManager <Role> roleManager, IDbInitializer dbInitializer ) { _db = db; _userManager = userManager; Field <TenantType>( "addTenant", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <TenantInputType> > { Name = "tenant" }, new QueryArgument <NonNullGraphType <UserInputType> > { Name = "adminUser" } ), resolve: context => { context.GetUserContext().EnsureIsInRole(RoleNames.HostAdministrator); var tenantInput = context.GetArgument <Tenant>("tenant"); //tenantInput.Id = 0; var tenant = new Tenant(); tenant.UpdateValuesFrom(tenantInput); db.Add(tenant); db.SaveChanges(); dbInitializer.SeedTenantRoles(tenant.Id); using (_db.SetTenantFilterValue(tenant.Id)) { var adminUser = context.GetArgument <UserInput>("adminUser"); adminUser.UserName = "******"; adminUser.TenantId = tenant.Id; adminUser.IsActive = true; adminUser.Roles = adminUser.Roles ?? new List <string>(); adminUser.Roles.Add(RoleNames.Administrator); AddUser(adminUser); _userManager.AddToRoleAsync(adminUser, RoleNames.Administrator).GetAwaiter().GetResult(); } return(tenant); }); Field <TenantType>( "editTenant", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <TenantInputType> > { Name = "tenant" } ), resolve: context => { context.GetUserContext().EnsureIsInRole(RoleNames.HostAdministrator); var tenantInput = context.GetArgument <Tenant>("tenant"); var entity = db.Tenants.Find(tenantInput.Id); entity.UpdateValuesFrom(tenantInput); db.SaveChanges(); return(tenantInput); }); Field <UserType>( "addUser", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <UserInputType> > { Name = "user" } ), resolve: context => { context.GetUserContext().EnsureIsInEitherRole(RoleNames.HostAdministrator, RoleNames.Administrator); var userInput = context.GetArgument <UserInput>("user"); userInput.SetTenantIdOrThrow(context); var userDto = AddUser(userInput); return(userDto); }); Field <UserType>( "editUser", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <UserInputType> > { Name = "user" } ), resolve: context => { var userInput = context.GetArgument <UserInput>("user"); var userContext = context.GetUserContext(); var isAdmin = userContext.IsInRole(RoleNames.HostAdministrator) || userContext.IsInRole(RoleNames.Administrator); var isEditingSelf = userContext.Id == userInput.Id; if (!isAdmin && !isEditingSelf) { throw new ExecutionError($"Unauthorized. You have to be a member of {RoleNames.HostAdministrator}" + $" or {RoleNames.Administrator} role to be able to edit any user," + $" otherwise you can only edit your own user (id: {userContext.Id})."); } if (!isAdmin && userInput.Roles != null) { throw new ExecutionError($"Unauthorized. You have to be a member of {RoleNames.HostAdministrator}" + $" or {RoleNames.Administrator} role to be able to change user roles."); } var userDto = EditUser(userInput); return(userDto); }); Field <RoleType>( "addRole", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <RoleInputType> > { Name = "role" } ), resolve: context => { context.GetUserContext().EnsureIsInEitherRole(RoleNames.HostAdministrator, RoleNames.Administrator); var role = context.GetArgument <Role>("role"); role.Id = null; role.IsStatic = false; role.SetTenantIdOrThrow(context); roleManager.CreateAsync(role).GetAwaiter().GetResult(); return(role); }); Field <RoleType>( "editRole", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <RoleInputType> > { Name = "role" } ), resolve: context => { var roleInput = context.GetArgument <Role>("role"); context.GetUserContext().EnsureIsInEitherRole(RoleNames.HostAdministrator, RoleNames.Administrator); var role = roleManager.FindByIdAsync(roleInput.Id).GetAwaiter().GetResult(); if (role.IsStatic) { throw new ExecutionError("You can't edit static roles"); } role.UpdateValuesFrom(roleInput); roleManager.UpdateAsync(role).GetAwaiter().GetResult().ThrowOnError(); return(role); }); Field <ProjectType>( "addProject", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <ProjectInputType> > { Name = "project" } ), resolve: context => { var project = context.GetArgument <Project>("project"); project.Id = 0; project.SetTenantIdOrThrow(context); db.Add(project); db.SaveChanges(); return(project); }); Field <ProjectType>( "editProject", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <ProjectInputType> > { Name = "project" } ), resolve: context => { var project = context.GetArgument <Project>("project"); var entity = db.Projects.Find(project.Id); entity.UpdateValuesFrom(project); db.SaveChanges(); return(project); }); Field <TaskType>( "addTask", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <TaskInputType> > { Name = "task" } ), resolve: context => { var task = context.GetArgument <Task>("task"); task.Id = 0; task.SetTenantIdOrThrow(context); db.Add(task); db.SaveChanges(); return(task); }); Field <TaskType>( "editTask", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <TaskInputType> > { Name = "task" } ), resolve: context => { var task = context.GetArgument <Task>("task"); var entity = db.Tasks.Find(task.Id); entity.UpdateValuesFrom(task); db.SaveChanges(); return(task); }); }
public ReactAdvantageQuery(ReactAdvantageContext db) { Name = "Query"; Field <TenantType>( "tenant", arguments: new QueryArguments(new QueryArgument <IntGraphType> { Name = "id" }), resolve: context => { var idInput = context.GetArgument <int>("id"); var userContext = context.GetUserContext(); var isHostAdmin = userContext.IsInRole(RoleNames.HostAdministrator); var isUserFromThisTenant = userContext.TenantId == idInput; if (!isHostAdmin && !isUserFromThisTenant) { throw new ExecutionError($"Unauthorized. You have to be a member of {RoleNames.HostAdministrator}" + " role to be able to query any tenant, otherwise you can only query" + $" your own tenant (id: {userContext.TenantId})."); } return(db.Tenants.Find(idInput)); } ); Field <ListGraphType <TenantType> >( "tenants", arguments: new QueryArguments( new QueryArgument <ListGraphType <IntGraphType> > { Name = "id" }, new QueryArgument <StringGraphType> { Name = "name" } ), resolve: context => { context.GetUserContext().EnsureIsInRole(RoleNames.HostAdministrator); return(db.Tenants .HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))); } ); Field <UserType>( "user", arguments: new QueryArguments(new QueryArgument <StringGraphType> { Name = "id" }), resolve: context => db.Users .Where(x => x.Id == context.GetArgument <string>("id", null)) .Select(x => new UserDto { Id = x.Id, FirstName = x.FirstName, LastName = x.LastName, UserName = x.UserName, Email = x.Email, IsActive = x.IsActive, Roles = x.UserRoles.Select(r => r.Role.Name).ToArray() }) .FirstOrDefault() ); Field <ListGraphType <UserType> >( "users", arguments: new QueryArguments( new QueryArgument <ListGraphType <StringGraphType> > { Name = "id" }, new QueryArgument <StringGraphType> { Name = "firstname" }, new QueryArgument <StringGraphType> { Name = "lastname" }, new QueryArgument <StringGraphType> { Name = "username" }, new QueryArgument <StringGraphType> { Name = "email" }, new QueryArgument <BooleanGraphType> { Name = "isactive" } ), resolve: context => db.Users .HandleQueryArgument(new ArgumentGetter <List <string> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <string>("firstname", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.FirstName.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <string>("lastname", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.LastName.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <string>("username", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.UserName.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <string>("email", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Email.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <bool>("isactive", context), (arg, query) => query.Where(x => x.IsActive == arg)) .Select(x => new UserDto { Id = x.Id, FirstName = x.FirstName, LastName = x.LastName, UserName = x.UserName, Email = x.Email, IsActive = x.IsActive, Roles = x.UserRoles.Select(r => r.Role.Name).ToArray() }) ); Field <ListGraphType <RoleType> >( "roles", arguments: new QueryArguments( new QueryArgument <ListGraphType <StringGraphType> > { Name = "id" }, new QueryArgument <StringGraphType> { Name = "name" }, new QueryArgument <StringGraphType> { Name = "isstatic" } ), resolve: context => db.Roles .HandleQueryArgument(new ArgumentGetter <List <string> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <bool>("isstatic", context), (arg, query) => query.Where(x => x.IsStatic == arg)) ); Field <ProjectType>( "project", arguments: new QueryArguments(new QueryArgument <IntGraphType> { Name = "id" }), resolve: context => db.Projects.FindAsync(context.GetArgument <int>("id")) ); Field <ListGraphType <ProjectType> >( "projects", arguments: new QueryArguments( new QueryArgument <ListGraphType <IntGraphType> > { Name = "id" }, new QueryArgument <StringGraphType> { Name = "name" } ), resolve: context => db.Projects .HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))) ); Field <TaskType>( "task", arguments: new QueryArguments(new QueryArgument <IntGraphType> { Name = "id" }), resolve: context => db.Tasks.FindAsync(context.GetArgument <int>("id")) ); Field <ListGraphType <TaskType> >( "tasks", arguments: new QueryArguments( new QueryArgument <ListGraphType <IntGraphType> > { Name = "id" }, new QueryArgument <IntGraphType> { Name = "projectid" }, new QueryArgument <StringGraphType> { Name = "name" }, new QueryArgument <BooleanGraphType> { Name = "iscompleted" }, new QueryArgument <DateGraphType> { Name = "duedate" }, new QueryArgument <DateGraphType> { Name = "completiondate" } ), resolve: context => db.Tasks .HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) => query.Where(x => arg.Contains(x.Id))) .HandleQueryArgument(new ArgumentGetter <int>("projectid", context), (arg, query) => query.Where(x => x.ProjectId == arg)) .HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) => string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))) .HandleQueryArgument(new ArgumentGetter <bool>("iscompleted", context), (arg, query) => query.Where(x => x.Completed == arg)) .HandleQueryArgument(new ArgumentGetter <DateTime>("duedate", context), (arg, query) => query.Where(x => x.DueDate >= arg.Date && x.DueDate < arg.Date.AddDays(1))) .HandleQueryArgument(new ArgumentGetter <DateTime>("completiondate", context), (arg, query) => query.Where(x => x.CompletionDate >= arg.Date && x.CompletionDate < arg.Date.AddDays(1))) ); }