public UsersRepository(IdentityDataContext context)
{
_Context = context;
Users = _Context.Users;
UserRoles = _Context.UserRoles;
Roles = _Context.Roles;
}
public HomeController(IdentityDataContext context, UserManager <ApplicationUser> userManager, ILogger <HomeController> logger, IK8sInvoker k8sInvoker)
{
_context = context;
_userManager = userManager;
_logger = logger;
_k8sInvoker = k8sInvoker;
}
public UserPagesController(UserManager <CustomUserFields> userManager, IdentityDataContext users, OperaDataContext db, IHostingEnvironment env)
{
_userManager = userManager;
_db = db;
_users = users;
_folder = $@"{env.WebRootPath}";
}
public ImagesController(IdentityDataContext context, UserManager <ApplicationUser> userManager, IImageCreationSSEService imageCreationSSEService, IDockerInvoker dockerInvoker)
{
_context = context;
_userManager = userManager;
_imageCreationSSEService = imageCreationSSEService;
_dockerInvoker = dockerInvoker;
}
public void Configure(IApplicationBuilder app,
IHostingEnvironment env, DataContext context,
IdentityDataContext identityContext,
UserManager <IdentityUser> userManager,
RoleManager <IdentityRole> roleManager)
{
app.UseDeveloperExceptionPage();
app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions {
HotModuleReplacement = true
});
app.UseStaticFiles();
app.UseSession();
app.UseAuthentication();
app.UseMvc(routes => {
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routes.MapSpaFallbackRoute("angular-fallback",
new { controller = "Home", action = "Index" });
});
SeedData.SeedDatabase(context);
IdentitySeedData.SeedDatabase(identityContext,
userManager, roleManager).GetAwaiter().GetResult();
}
public static Dictionary <string, string> GetUsersDictionary(this Dictionary <string, string> value)
{
using (var targetUserDb = new IdentityDataContext("Name=SLMTargetUserDataContext"))
{
return(targetUserDb.Users.Where(x => x.Id != null).ToDictionary(field => field.Email, field => field.Id));
}
}
private async Task attachAccountToContext(HttpContext context, IdentityDataContext dataContext, string token)
{
try
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
tokenHandler.ValidateToken(token, new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
// set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
ClockSkew = TimeSpan.Zero
}, out SecurityToken validatedToken);
var jwtToken = (JwtSecurityToken)validatedToken;
var accountId = int.Parse(jwtToken.Claims.First(x => x.Type == "id").Value);
// attach account to context on successful jwt validation
context.Items["Account"] = await dataContext.Accounts.FindAsync(accountId);
}
catch
{
// do nothing if jwt validation fails
// account is not attached to context so request won't have access to secure routes
}
}
// GET: User
public ActionResult Index()
{
IdentityDataContext db = new IdentityDataContext();
var userroles = (from user in db.Users
select new
{
UserId = user.Id,
Username = user.UserName,
Email = user.Email,
RoleNames = (from userRole in user.Roles
join role in db.Roles on userRole.RoleId
equals role.Id
select role.Name).ToList()
}).ToList().Select(p => new UserListModel
{
UserId = p.UserId,
UserName = p.Username,
Email = p.Email,
Role = string.Join(" | ", p.RoleNames)
});
return(View(userroles));
}
public IdentityService(UserManager <ApplicationUser> userManager,
IdentityDataContext context, RoleManager <ApplicationRole> roleManager, ISortingPropertyMappingService sortingPropertyMappingService)
{
_userManager = userManager;
_context = context;
_roleManager = roleManager;
_sortingPropertyMappingService = sortingPropertyMappingService;
}
public AccountManager(
IdentityDataContext context,
UserManager <ApplicationUser> userManager,
IConfiguration configuration)
{
_userManager = userManager;
_configuration = configuration;
}
public UserManager(ClaimsFactory claimsFactory, IdentityDataContext context, IdentityValidator identityValidator)
{
_identityManager = new UserManager <User>(new UserStore <User>(context))
{
ClaimsIdentityFactory = claimsFactory,
UserValidator = identityValidator
};
}
public AccountController(IdentityDataContext identityCtx, UserManager <IdentityUser> userMgr,
SignInManager <IdentityUser> signInMgr, RoleManager <IdentityRole> roleMgr, DataContext dataCtx)
{
userManager = userMgr;
signInManager = signInMgr;
roleManager = roleMgr;
IdentityContext = identityCtx;
dataContext = dataCtx;
}
public HomeController(ILogger <HomeController> logger,
IdentityDataContext idcontext,
UserManager <AppUser> usermanager, DataContext context)
{
_logger = logger;
this.idcontext = idcontext;
this.userManager = usermanager;
this.context = context;
}
public AccountController(ILogger <HomeController> logger, UserManager <AppUser> userManager, SignInManager <AppUser> signInManager, RoleManager <AppRole> roleManager, IWebHostEnvironment env, IdentityDataContext context)
{
_logger = logger;
_signInManager = signInManager;
_userManager = userManager;
_roleManager = roleManager;
_env = env;
_context = context;
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
IdentityDataContext identityContext,
UserManager <IdentityUser> userManager,
RoleManager <IdentityRole> roleManager,
IAntiforgery antiforgery)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseSpaStaticFiles();
app.UseSession();
app.UseAuthentication();
app.Use(nextDelegate => requestContext => {
if (requestContext.Request.Path.StartsWithSegments("/api") ||
requestContext.Request.Path.StartsWithSegments("/"))
{
requestContext.Response.Cookies.Append("XSRF-TOKEN",
antiforgery.GetAndStoreTokens(requestContext).RequestToken);
}
return(nextDelegate(requestContext));
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
app.UseSwagger();
app.UseSwaggerUI(options =>
options.SwaggerEndpoint("/swagger/v1/swagger.json", "BooksStore API v1"));
app.UseSpa(spa =>
{
spa.Options.SourcePath = "ClientApp/dist/ClientApp";
if (env.IsDevelopment())
{
spa.UseProxyToSpaDevelopmentServer("http://localhost:4200");
//spa.UseAngularCliServer(npmScript: "start");
}
});
IdentitySeedData.SeedDatabase(identityContext,
userManager, roleManager).GetAwaiter().GetResult();
}
public async Task Invoke(HttpContext context, IdentityDataContext dataContext)
{
var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
if (token != null)
{
await attachAccountToContext(context, dataContext, token);
}
await _next(context);
}
public AccountService(
IdentityDataContext context,
IMapper mapper,
IOptions <AppSettings> appSettings,
IEmailService emailService)
{
_context = context;
_mapper = mapper;
_appSettings = appSettings.Value;
_emailService = emailService;
}
public WorkerService(ILogger <WorkerService> logger, IHostApplicationLifetime appLifetime,
IdentityDataContext identityDataContext,
RoleManager <ApplicationRole> roleManager,
IIdentityService identityService
)
{
_identityDataContext = identityDataContext;
_roleManager = roleManager;
_identityService = identityService;
_logger = logger;
_appLifetime = appLifetime;
}
public UserController() // contructor
{
var userContext = new IdentityDataContext();
var userStore = new UserStore <ApplicationUser>(userContext);
userManager = new UserManager <ApplicationUser>(userStore);
var roleContext = new IdentityDataContext();
var roleStore = new RoleStore <ApplicationRole>(roleContext);
roleManager = new RoleManager <ApplicationRole>(roleStore);
}
protected override async Task <VoatIdentityUser> GetData()
{
using (var db = new IdentityDataContext())
{
using (var context = VoatUserManager.Create())
{
var user = await context.FindByNameAsync(_userToRetrieve);
return(user);
}
}
}
public RegisterModel(
IdentityDataContext dataContext,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender)
{
_context = dataContext;
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_emailSender = emailSender;
}
public UnitOfWork(IdentityDataContext db)
{
_db = db;
User = new UserRepository(_db);
InitiativeYear = new InitiativeYearRepository(_db);
Initiative = new InitiativeRepository(_db);
InitiativeMember = new InitiativeMemberRepository(_db);
ActionItem = new ActionItemRepository(_db);
ItemAssignee = new ItemAssigneeRepository(_db);
ReviewCycle = new ReviewCycleRepository(_db);
CommentItem = new CommentItemRepository(_db);
EvaluationCriteria = new EvaluationCriteriaRepository(_db);
InitiativeMeeting = new InitiativeMeetingRepository(_db);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
Database.SetInitializer(new DataInitializer());
var ctx = new DataContext();
ctx.Database.Initialize(true);
Database.SetInitializer(new IdentityInitializer());
var ctx2 = new IdentityDataContext();
ctx2.Database.Initialize(true);
}
internal async Task <Container> ValidateContainerAsync(IdentityDataContext context, ApplicationUser user)
{
if (string.IsNullOrWhiteSpace(ContainerName))
{
throw new ArgumentNullException(nameof(ContainerName));
}
Container = new Container
{
Name = ContainerName
};
Volume = await context.Volume.FirstAsync(v => v.VolumeID == VolumeID);
Image = await context.Image.FirstAsync(v => v.VolumeID == ImageID);
Container.Image = Image;
Container.ImageID = Image.VolumeID;
Volume publicVolume = await context.Volume.FirstAsync(x => x.UserID == user.Id && x.Path == VolumePath.Public);
Volume dataVolume = await context.Volume.FirstAsync(x => x.UserID == user.Id && x.Path == VolumePath.Data);
Mounting publicMounting = new Mounting
{
Volume = publicVolume,
Container = this.Container,
User = user,
UserID = user.Id
};
Mounting dataMounting = new Mounting
{
Volume = dataVolume,
Container = this.Container,
User = user,
UserID = user.Id
};
Mounting homeMounting = new Mounting
{
Volume = this.Volume,
Container = this.Container,
User = user,
UserID = user.Id
};
Container.Mountings = new Mounting[] { publicMounting, dataMounting, homeMounting };
Container.User = user;
Container.UserID = user.Id;
return(Container);
}
public void Configure(IApplicationBuilder app,
IHostingEnvironment env, DataContext context,
IdentityDataContext identityContext,
UserManager <IdentityUser> userManager,
RoleManager <IdentityRole> roleManager,
IAntiforgery antiforgery)
{
//app.UseDeveloperExceptionPage();
//app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions {
// HotModuleReplacement = true
//});
app.UseStaticFiles();
app.UseSession();
app.UseAuthentication();
app.Use(nextDelegate => requestContext => {
if (requestContext.Request.Path.StartsWithSegments("/api") ||
requestContext.Request.Path.StartsWithSegments("/"))
{
requestContext.Response.Cookies.Append("XSRF-TOKEN",
antiforgery.GetAndStoreTokens(requestContext).RequestToken);
}
return(nextDelegate(requestContext));
});
app.UseMvc(routes => {
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routes.MapSpaFallbackRoute("angular-fallback",
new { controller = "Home", action = "Index" });
});
if ((Configuration["INITDB"] ?? "false") == "true")
{
System.Console.WriteLine("Preparing Database...");
context.Database.Migrate();
SeedData.SeedDatabase(context);
identityContext.Database.Migrate();
IdentitySeedData.SeedDatabase(identityContext,
userManager, roleManager).GetAwaiter().GetResult();
System.Console.WriteLine("Database Preparation Complete");
System.Environment.Exit(0);
}
}
public static async Task SeedDatabase(IdentityDataContext context,
UserManager <IdentityUser> userManager,
RoleManager <IdentityRole> roleManager)
{
if (context.Database.GetMigrations().Count() > 0 &&
context.Database.GetPendingMigrations().Count() == 0)
{
IdentityRole role = await roleManager.FindByNameAsync(adminRole);
IdentityUser user = await userManager.FindByNameAsync(adminUser);
if (role == null)
{
role = new IdentityRole(adminRole);
IdentityResult result = await roleManager.CreateAsync(role);
if (!result.Succeeded)
{
throw new Exception("Невозможно создать роль: " + result.Errors.FirstOrDefault());
}
}
if (user == null)
{
user = new IdentityUser(adminUser);
IdentityResult result = await userManager.CreateAsync(user, adminPassword);
if (!result.Succeeded)
{
throw new Exception("Невозможно создать пользователя: "
+ result.Errors.FirstOrDefault());
}
}
if (!await userManager.IsInRoleAsync(user, adminRole))
{
IdentityResult result
= await userManager.AddToRoleAsync(user, adminRole);
if (!result.Succeeded)
{
throw new Exception("Невозможно добавить пользователя к роли: "
+ result.Errors.FirstOrDefault());
}
}
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IdentityDataContext context)
{
app.UseMiddleware <ExceptionMiddleware>();
app.UseStatusCodePagesWithReExecute("/errors/{0}");
// migrate database changes on startup (includes initial db creation)
context.Database.Migrate();
// generated swagger json and swagger ui middleware
app.UseSwagger();
app.UseSwaggerUI(x => x.SwaggerEndpoint("/swagger/v1/swagger.json", "ASP.NET Core Sign-up and Verification API"));
app.UseHttpsRedirection();
app.UseRouting();
app.UseStaticFiles();
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(
Path.Combine(Directory.GetCurrentDirectory(), "Content")
), RequestPath = "/content"
});
// global cors policy
app.UseCors(x => x
.SetIsOriginAllowed(origin => true)
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
// app.UseCors("CorsPolicy");
app.UseAuthentication();
app.UseAuthorization();
// global error handler
app.UseMiddleware <ErrorHandlerMiddleware>();
// custom jwt auth middleware
app.UseMiddleware <JwtMiddleware>();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapFallbackToController("Index", "Fallback");
});
}
public ActionResult Delete(string id)
{
if (String.IsNullOrEmpty(id))
{
//Hata kontolü
return(RedirectToAction("Index", "Admin", null));
}
IdentityDataContext db = new IdentityDataContext();
var user = userManager.Users.FirstOrDefault(i => i.Id == id);
var cv = db.CVler.Where(i => i.PortalUserId == user.Id);
foreach (var item in cv)
{
db.CVler.Remove(item);
}
db.SaveChanges();
userManager.Delete(user);
TempData["Success"] = "Kullanıcı silindi !";
return(RedirectToAction("Index", "Admin", null));
}
public static void AlimentarBaseDados(IdentityDataContext db)
{
try
{
#region AddUsuario
List <Usuarios> usuarios = new List <Usuarios>();
var usu1 = new Usuarios();
usu1.Id = "666ef5e2-b9b3-4691-8449-52c6444bb6b2";
usu1.UserName = "******";
usu1.NormalizedUserName = "******";
usu1.Email = "*****@*****.**";
usu1.NormalizedEmail = "*****@*****.**";
usu1.EmailConfirmed = true;
usu1.PasswordHash = "AQAAAAEAACcQAAAAELaNWxeWj9tBjiw13tQTvOVbd7nmDhof/3Wp2CXQmyBvKO0JyuZ3vBzf3QXfTzOlIA==";
usu1.SecurityStamp = "5X5F7RIXE5DHAIWEM4MCGM7QRFQOK67C";
usu1.ConcurrencyStamp = "6625979f-d1c1-46fb-aa54-4e094badd8bd";
usu1.Ativo = true;
usu1.IdPerfil = 1;
usu1.Nome = "caique";
usuarios.Add(usu1);
db.Usuarios.AddRange(usuarios);
db.SaveChanges();
#endregion
}
catch (Exception ex)
{
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string versao = fvi.FileVersion;
Log.FazLog("Criação das Tabelas/Banco", "Log", versao, ex);
}
}
public EvaluationCriteriaRepository(IdentityDataContext db) : base(db)
{
_db = db;
}
