public UnitOfWork(ApplicationDbContext db)
{
_db = db;
Category = new CategoryRepository(_db);
Company = new CompanyRepository(_db);
CoverType = new CoverTypeRepository(_db);
Product = new ProductRepository(_db);
ApplicationUser = new ApplicationUserRepository(_db);
SP_Call = new SP_Call(_db);
OrderDetails = new OrderDetailsRepository(_db);
OrderHeader = new OrderHeaderRepository(_db);
ShoppingCart = new ShoppingCartRepository(_db);
}
public IActionResult ResetPassword(ResetPasswordViewModel view)
{
ApplicationUserRepository userRepo = null;
ApplicationAuditLogRepository logRepo = null;
ApplicationUser user = null;
try
{
if (ModelState.IsValid)
{
if (view.Password == view.ConfirmPassword)
{
if (view.UserName.ToUpper() != "ADMIN" && view.UserName.ToUpper() != "ADMINISTRATOR")
{
userRepo = new ApplicationUserRepository(settings, logger, dbc);
logRepo = new ApplicationAuditLogRepository(settings, logger, dbc);
// Find user in database and validate there password
user = (userRepo.FindAll()).FirstOrDefault(u => u.NormalizedUserName == view.UserName.ToUpper());
user.PasswordHash = PasswordHash.HashPassword(view.Password);
userRepo.Update(user);
logRepo.Add(new ApplicationAuditLog()
{
CategoryId = 1, Description = $"Reset password for User ({HttpContext.User.Identity.Name})."
});
return(RedirectToAction("PasswordResetSuccess", "Account"));
}
else
{
// Can't reset Admin password
ModelState.AddModelError("UserName", "You can't reset the Admin users password!");
return(View("ResetPassword", view));
}
}
else
{
// Passwords don't match
ModelState.AddModelError("ConfirmPassword", "Confirm Password doesn't match New Password.");
return(View("ResetPassword", view));
}
}
else
{
return(View("ResetPassword", view));
}
}
catch (Exception ex)
{
logger.LogError($"Exception: {ex.Message}");
throw (Exception)Activator.CreateInstance(ex.GetType(), ex.Message + ex.StackTrace);
}
}
public ActionResult TakenedTests(int?page, Guid?swTypeGuid, Guid?testCatGuid, string searchTerm)
{
TestsRepository testsRepo = new TestsRepository();
SoftwareTypeRepository swTypeRepo = new SoftwareTypeRepository();
ViewBag.SoftTypes = swTypeRepo.GetAllValid();
TestCategoryRepository testCatRepo = new TestCategoryRepository();
ViewBag.TestCategories = testCatRepo.GetAllValid();
ApplicationUserRepository <Tester> userRepo = new ApplicationUserRepository <Tester>();
Tester tester = userRepo.GetByUserName(User.Identity.Name);
int itemsOnPage = 8;
int pg = page ?? 1;
int startIndex = (pg * itemsOnPage) - itemsOnPage;
SoftwareType swType = null;
if (swTypeGuid != null)
{
swType = swTypeRepo.GetById((Guid)swTypeGuid);
ViewBag.SoftType = swType;
}
TestCategory testCat = null;
if (testCatGuid != null)
{
testCat = testCatRepo.GetById((Guid)testCatGuid);
ViewBag.TestCategory = testCat;
}
ViewBag.CurrentSearch = searchTerm;
IList <TestsStatus> statuses = new List <TestsStatus>();
statuses.Add(TestsStatus.Takened);
IList <DataAccess.Model.Tests.Tests> tests = testsRepo.GetAvailableEntities(out var totalTests, tester, statuses, swType, testCat, startIndex, itemsOnPage, searchTerm);
ViewBag.Pages = (int)Math.Ceiling((double)totalTests / (double)itemsOnPage);
ViewBag.CurrentPage = pg;
if (Request.IsAjaxRequest())
{
return(PartialView(tests));
}
return(View(tests));
}
public async Task <ActionResult> TestDetails(Guid testGuid)
{
TestCaseRepository testCaseRepo = new TestCaseRepository();
var testCaseTask = testCaseRepo.GetByIdAsync(testGuid);
ApplicationUserRepository <Tester> userRepo = new ApplicationUserRepository <Tester>();
var testerTask = userRepo.GetByUserNameAsync(User.Identity.Name);
TestsRepository testsRepo = new TestsRepository();
ViewBag.Takened = testsRepo.GetTestStatus(await testCaseTask, await testerTask);
ViewBag.TestsGuid = testsRepo.GetByTestCaseForTester(await testerTask, await testCaseTask);
return(View(await testCaseTask));
}
public FileContentResult GetAvatar(string userId)
{
var db = new ApplicationUserRepository(new Neurocom.Models.ApplicationDbContext());
var user = db.Get(userId);
if (user != null)
{
return(File(user.ImageData, user.ImageMimeType));
}
else
{
return(null);
}
}
// GET: Public
public ActionResult Index()
{
ViewBag.Title = "TestCrowd";
ApplicationUserRepository <ApplicationUser> testCrowdUserDao = new ApplicationUserRepository <ApplicationUser>();
int count = testCrowdUserDao.GetAll().Count;
TestCaseRepository testCasesRepo = new TestCaseRepository();
int testCount = testCasesRepo.GetCount();
ViewBag.Clients = count.ToString();
ViewBag.Tests = testCount.ToString();
return(View());
}
public void Setup()
{
_transactionScope = new TransactionScope();
_manCoRepository = new ManCoRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_domicileRepository = new DomicileRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_applicationUserRepository = new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_domicile = BuildMeA.Domicile("code", "description");
_domicile2 = BuildMeA.Domicile("code2", "description2");
_manCo1 = BuildMeA.ManCo("description", "code").WithDomicile(_domicile);
_manCo2 = BuildMeA.ManCo("description2", "code2").WithDomicile(_domicile);
_manCo3 = BuildMeA.ManCo("description3", "code3").WithDomicile(_domicile);
_manCo4 = BuildMeA.ManCo("description4", "code4").WithDomicile(_domicile2);
_user = BuildMeA.ApplicationUser("warrior");
}
public async Task <ActionResult> Login(ApplicationUser user, bool?remember)
{
bool boolRemember = remember ?? false;
ModelState.Remove(nameof(user.PasswordConfirmationHash));
if (ModelState.IsValid)
{
ApplicationUserRepository <ApplicationUser> userRepository = new ApplicationUserRepository <ApplicationUser>();
var isUserExist = userRepository.IsUserExistAsync(user.UserName);
if (!await isUserExist)
{
TempData["error"] = "This Account Name do not exist!";
return(RedirectToAction("Index", "Login"));
}
var isUserWithEmailExist = userRepository.IsUserWithEmailExistAcync(user.UserName, user.Email);
if (!await isUserWithEmailExist)
{
TempData["error"] = "Incorrect Email for this account!";
return(RedirectToAction("Index", "Login"));
}
var _user = await AppUserManager.FindAsync(user.UserName, user.PasswordHash);
if (_user != null)
{
ClaimsIdentity identity = await AppUserManager.CreateIdentityAsync(_user, DefaultAuthenticationTypes.ApplicationCookie);
identity.AddClaim(new Claim(ClaimTypes.Role, _user.Role.Name));
AuthManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignIn(new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = boolRemember,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
}, identity);
return(RedirectToAction("Index", "Home", new { area = "Testing" }));
}
TempData["error"] = "Wrong Password, Try it again!";
return(RedirectToAction("Index", "Login"));
}
return(View("Index"));
}
public async Task <ActionResult> RegisterTester(Tester tester)
{
ModelState.Remove(nameof(tester.FirstName));
ModelState.Remove(nameof(tester.LastName));
if (ModelState.IsValid)
{
var userRepository = new ApplicationUserRepository <ApplicationUser>();
var roleRepository = new ApplicationRoleRepository();
var role = roleRepository.GetByNameAsync("tester");
var isUserExist = userRepository.IsUserExistAsync(tester.UserName);
if (await isUserExist)
{
TempData["error"] = "Account with this name already exist!";
return(View("Tester"));
}
Tester _tester = new Tester()
{
UserName = tester.UserName,
Email = tester.Email,
Role = await role,
PasswordHash = ApplicationPasswordHasher.HashPasword(tester.PasswordHash)
};
_tester.Address = new Address()
{
User = _tester
};
new ApplicationUserRepository <Tester>().Create(_tester);
ClaimsIdentity identity = await AppUserManager.CreateIdentityAsync(_tester, DefaultAuthenticationTypes.ApplicationCookie);
identity.AddClaim(new Claim(ClaimTypes.Role, _tester.Role.Name));
AuthManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignIn(new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = false,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
}, identity);
return(RedirectToAction("Index", "Home", new { area = "Testing" }));
}
return(View("Tester"));
}
public void Setup()
{
_transactionScope = new TransactionScope();
_passwordHistoryRepository = new PasswordHistoryRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_applicationUserRepository = new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_user = BuildMeA.ApplicationUser("user1");
_passwordHistory1 = BuildMeA.PasswordHistory(_user.Id, "password1");
_passwordHistory2 = BuildMeA.PasswordHistory(_user.Id, "password2");
_passwordHistory3 = BuildMeA.PasswordHistory(_user.Id, "password3");
_passwordHistory4 = BuildMeA.PasswordHistory(_user.Id, "password4");
_passwordHistory5 = BuildMeA.PasswordHistory(_user.Id, "password5");
_passwordHistory6 = BuildMeA.PasswordHistory(_user.Id, "password6");
_passwordHistory7 = BuildMeA.PasswordHistory(_user.Id, "password7");
_passwordHistory8 = BuildMeA.PasswordHistory(_user.Id, "password8");
}
public DatabaseStatisticController()
{
context = new ApplicationDbContext();
ApplicationUserRepository = new ApplicationUserRepository(context);
climateRepository = new ClimateRepository(context);
terrainRepository = new TerrainRepository(context);
ticketRepository = new TicketRepository(context);
flightRepository = new FlightRepository(context);
orderRepository = new OrderRepository(context);
raceRepository = new RaceRepository(context);
raceClassificationRepository = new RaceClassificationRepository(context);
starshipRepository = new StarshipRepository(context);
flightPathRepository = new FlightPathRepository(context);
planetRepository = new PlanetRepository(context);
}
public ActionResult Delete(IList <Admin> rows)
{
var adminRepo = new ApplicationUserRepository <Admin>();
var roleRepo = new ApplicationRoleRepository();
foreach (var row in rows)
{
row.Role = roleRepo.GetByName("admin");
adminRepo.Delete(row);
}
TempData["success"] = "User/s was deleted!";
return(View("Admins"));
}
public async Task <ActionResult> TesterTests(int?page, Guid?swTypeGuid, Guid?testCatGuid, string searchTerm)
{
TestCaseRepository testCaseRepo = new TestCaseRepository();
ApplicationUserRepository <Tester> userRepo = new ApplicationUserRepository <Tester>();
var testerTask = userRepo.GetByUserNameAsync(User.Identity.Name);
SoftwareTypeRepository swTypeRepo = new SoftwareTypeRepository();
ViewBag.SoftTypes = swTypeRepo.GetAllValid();
TestCategoryRepository testCatRepo = new TestCategoryRepository();
ViewBag.TestCategories = testCatRepo.GetAllValid();
int itemsOnPage = 8;
int pg = page ?? 1;
int startIndex = (pg * itemsOnPage) - itemsOnPage;
SoftwareType swType = null;
if (swTypeGuid != null)
{
swType = swTypeRepo.GetById((Guid)swTypeGuid);
ViewBag.SoftType = swType;
}
TestCategory testCat = null;
if (testCatGuid != null)
{
testCat = testCatRepo.GetById((Guid)testCatGuid);
ViewBag.TestCategory = testCat;
}
ViewBag.CurrentSearch = searchTerm;
IList <TestCase> testCases = testCaseRepo.GetAvailableEntities(out var totalTests, DateTime.Today, await testerTask, swType, testCat, startIndex, itemsOnPage, searchTerm);
ViewBag.Pages = (int)Math.Ceiling((double)totalTests / (double)itemsOnPage);
ViewBag.CurrentPage = pg;
if (Request.IsAjaxRequest())
{
return(PartialView(testCases));
}
return(View(testCases));
}
public Repository(bool isAdmin = false)
{
_context = new ApplicationDbContext();
ApplicationUserRepository = new ApplicationUserRepository(_context);
if (isAdmin)
{
StatusRepository = new StatusRepository(_context);
}
else
{
CategoryRepository = new CategoryRepository(_context);
PostRepository = new PostRepository(_context);
MessengerRepository = new MessengerRepository(_context);
}
}
public void Setup()
{
_transactionScope = new TransactionScope();
_applicationUserRepository = new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_securityAnswerRepository = new SecurityAnswerRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_securityQuestionRepository = new SecurityQuestionRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
_user = BuildMeA.ApplicationUser("user1");
_securityQuestion1 = BuildMeA.SecurityQuestion("question 1");
_securityQuestion2 = BuildMeA.SecurityQuestion("question 2");
_securityQuestion3 = BuildMeA.SecurityQuestion("question 3");
_securityQuestion4 = BuildMeA.SecurityQuestion("question 4");
_securityAnswer1 = BuildMeA.SecurityAnswer("answer 1").WithSecurityQuestionId(_securityQuestion1.Id).WithUserId(_user.Id);
_securityAnswer2 = BuildMeA.SecurityAnswer("answer 2").WithSecurityQuestionId(_securityQuestion2.Id).WithUserId(_user.Id);
_securityAnswer3 = BuildMeA.SecurityAnswer("answer 3").WithSecurityQuestionId(_securityQuestion3.Id).WithUserId(_user.Id);
_securityAnswer4 = BuildMeA.SecurityAnswer("answer 4").WithSecurityQuestionId(_securityQuestion4.Id).WithUserId(_user.Id);
}
public UnitOfWorkAuthorization(AuthorizationContext context) : base(context)
{
Claims = new ClaimRepository(context);
ClientApplications = new ClientApplicationRepository(context);
ClientApplicationUtils = new ClientApplicationUtilRepository(context);
RoleClaims = new RoleClaimRepository(context);
RoleEntityClaims = new RoleEntityClaimRepository(context);
Roles = new RoleRepository(context);
UserClaims = new UserClaimRepository(context);
UserEntityClaims = new UserEntityClaimRepository(context);
Users = new UserRepository(context);
UserRoles = new UserRoleRepository(context);
UserUtils = new UserUtilRepository(context);
Applications = new ApplicationRepository(context);
ApplicationUsers = new ApplicationUserRepository(context);
}
public ActionResult TestsResaults(int?page, Guid?testCaseGuid, Guid?statusGuid)
{
TestsRepository testsRepo = new TestsRepository();
ApplicationUserRepository <Company> userRepo = new ApplicationUserRepository <Company>();
Company company = userRepo.GetByUserName(User.Identity.Name);
TestCaseRepository testCaseRepo = new TestCaseRepository();
ViewBag.TestCases = testCaseRepo.GetAllForCompany(company);
TestStatusRepository statusRepo = new TestStatusRepository();
ViewBag.Statuses = statusRepo.GetAll();
int itemsOnPage = 20;
int pg = page ?? 1;
int startIndex = (pg * itemsOnPage) - itemsOnPage;
TestCase testCase = null;
if (testCaseGuid != null)
{
testCase = testCaseRepo.GetById((Guid)testCaseGuid);
ViewBag.TestCase = testCase;
}
TestStatus testStatus = null;
if (statusGuid != null)
{
testStatus = statusRepo.GetById((Guid)statusGuid);
ViewBag.Status = testStatus;
}
IList <DataAccess.Model.Tests.Tests> testses = testsRepo.GetTestsForCompany(company, out int totalTests, out int filteredCount, testCase, testStatus, startIndex, itemsOnPage);
ViewBag.Pages = (int)Math.Ceiling((double)totalTests / (double)itemsOnPage);
ViewBag.CurrentPage = pg;
if (Request.IsAjaxRequest())
{
return(PartialView(testses));
}
return(View(testses));
}
public async Task <ActionResult> ResolveTest(Guid testGuid)
{
TestCaseRepository testCaseRepo = new TestCaseRepository();
var testCaseTask = testCaseRepo.GetByIdAsync(testGuid);
ApplicationUserRepository <Tester> userRepo = new ApplicationUserRepository <Tester>();
var testerTask = userRepo.GetByUserNameAsync(User.Identity.Name);
TestsRepository testsRepo = new TestsRepository();
var testsTask = testsRepo.GetByTestCaseForTesterAsync(await testerTask, await testCaseTask);
TestStatusRepository testStatusRepo = new TestStatusRepository();
ViewBag.TestStatus = testStatusRepo.GetAll();
return(View(await testsTask));
}
public async Task <ActionResult> RegisterCompany(Company company)
{
ModelState.Remove(nameof(company.Rating));
ModelState.Remove(nameof(company.Reviews));
ModelState.Remove(nameof(company.CompanyName));
if (ModelState.IsValid)
{
var userRepository = new ApplicationUserRepository <ApplicationUser>();
var roleRepository = new ApplicationRoleRepository();
var role = roleRepository.GetByNameAsync("company");
var isUserExist = userRepository.IsUserExistAsync(company.UserName);
if (await isUserExist)
{
TempData["error"] = "Account with this name already exist!";
return(View("Company"));
}
Company _company = new Company()
{
UserName = company.UserName,
Email = company.Email,
Role = await role,
PasswordHash = ApplicationPasswordHasher.HashPasword(company.PasswordHash),
Address = new Address()
};
new ApplicationUserRepository <Company>().Create(_company);
ClaimsIdentity identity = await AppUserManager.CreateIdentityAsync(_company, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignIn(new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = false,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
}, identity);
return(RedirectToAction("Index", "Home", new { area = "Testing" }));
}
return(View("Company"));
}
private IUserService GetUserService()
{
var globalSettingsRepository =
new GlobalSettingRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
var applicationUserRepository =
new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
var passwordHistoryRepository =
new PasswordHistoryRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
var userManagerProvider = new UserManagerProvider(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
var authenticationManagerProvider = new AuthenticationManagerProvider(new HttpContextBaseProvider());
return(new UserService(
userManagerProvider,
passwordHistoryRepository,
applicationUserRepository,
globalSettingsRepository,
authenticationManagerProvider));
}
public async Task TakeTest(Guid testGuid)
{
TestCaseRepository testCaseRepo = new TestCaseRepository();
var testCaseTask = testCaseRepo.GetByIdAsync(testGuid);
ApplicationUserRepository <Tester> userRepo = new ApplicationUserRepository <Tester>();
var testerTask = userRepo.GetByUserNameAsync(User.Identity.Name);
DataAccess.Model.Tests.Tests tests = new DataAccess.Model.Tests.Tests();
tests.Test = await testCaseTask;
tests.Status = TestsStatus.Takened;
tests.Takened = DateTime.Now;
tests.Tester = await testerTask;
TestsRepository testsRepo = new TestsRepository();
testsRepo.Create(tests);
}
public JsonResult GetTestCases(string searchTerm)
{
ApplicationUserRepository <Company> companyRepo = new ApplicationUserRepository <Company>();
Company currentCompany = companyRepo.GetByUserName(User.Identity.Name);
TestCaseRepository testCaseRepo = new TestCaseRepository();
IList <TestCase> testCases;
testCases = !string.IsNullOrEmpty(searchTerm) ? testCaseRepo.GetFilteredForCompanyNotInGroup(currentCompany, nameof(TestCase.Name), searchTerm) : testCaseRepo.GetFilteredForCompanyNotInGroup(currentCompany);
var modifiedData = testCases.Select(x => new
{
id = x.Id,
text = x.Name + " (available to: " + x.AvailableTo.ToShortDateString() + ")"
});
return(Json(modifiedData, JsonRequestBehavior.AllowGet));
}
public ApplicationUserRepositoryFixture()
{
var options = new DbContextOptionsBuilder <FlashMEMOContext>().UseInMemoryDatabase(databaseName: "FlashMEMOTest").Options;
var context = new FlashMEMOContext(options);
var userManager = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context),
null,
new PasswordHasher <ApplicationUser>(),
null,
null,
null,
null,
null,
null);
userManager.CreateAsync(new ApplicationUser
{
Id = "858b3287-5972-4069-bf75-a650453dfef7",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
UserName = "******",
NormalizedUserName = "******"
}, "Test@123").Wait();
userManager.CreateAsync(new ApplicationUser
{
Id = "8dcbd335-0f2e-46ae-bebb-d9cdad0e7487",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
UserName = "******",
NormalizedUserName = "******"
}, "Test@123").Wait();
userManager.CreateAsync(new ApplicationUser
{
Id = "e7edd329-b0bd-4820-9df4-c13c8aab3577",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
UserName = "******",
NormalizedUserName = "******"
}, "Test@123").Wait();
_repository = new ApplicationUserRepository(context, userManager);
}
public UnitOfWork(ApplicationDbContext db)
{
_db = db;
Wehicle = new WehicleRepository(_db);
BusStop = new BusStopRepository(_db);
LineName = new LineNameRepository(_db);
BusStopList = new BusStopListRepository(_db);
Holidays = new HolidaysRepository(_db);
Messages = new MessagesRepository(_db);
OperatingDays = new OperatingDaysRepository(_db);
TicketPrice = new TicketPriceRepository(_db);
ArrivalsDepartures = new ArrivalDeparturesRepository(_db);
Timetable = new TimetableRepository(_db);
BusRoute = new BusRouteRepository(_db);
Tickets = new TicketsRepository(_db);
Payment = new PaymentRepository(_db);
ApplicationUser = new ApplicationUserRepository(_db);
ApplicationRole = new ApplicationRoleRepository(_db);
BankAccount = new BankAccountRepository(_db);
}
public void Setup()
{
this.transactionScope = new TransactionScope();
this.passwordHistoryRepository = new PasswordHistoryRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
this.applicationUserRepository = new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
this.user = BuildMeA.ApplicationUser("user1");
this.passwordHistory1 = BuildMeA.PasswordHistory(this.user.Id, "password1");
this.passwordHistory2 = BuildMeA.PasswordHistory(this.user.Id, "password2");
this.passwordHistory3 = BuildMeA.PasswordHistory(this.user.Id, "password3");
this.passwordHistory4 = BuildMeA.PasswordHistory(this.user.Id, "password4");
this.passwordHistory5 = BuildMeA.PasswordHistory(this.user.Id, "password5");
this.passwordHistory6 = BuildMeA.PasswordHistory(this.user.Id, "password6");
this.passwordHistory7 = BuildMeA.PasswordHistory(this.user.Id, "password7");
this.passwordHistory8 = BuildMeA.PasswordHistory(this.user.Id, "password8");
this.passwordHistory9 = BuildMeA.PasswordHistory(this.user.Id, "password9");
this.passwordHistory10 = BuildMeA.PasswordHistory(this.user.Id, "password10");
this.passwordHistory11 = BuildMeA.PasswordHistory(this.user.Id, "password11");
this.passwordHistory12 = BuildMeA.PasswordHistory(this.user.Id, "password12");
this.passwordHistory13 = BuildMeA.PasswordHistory(this.user.Id, "password13");
}
public UserService(IRepository <ApplicationUser> clientRepository)
{
_clientRepository = clientRepository;
ApplicationContext db = new ApplicationContext("DefaultConnection");
var provider = new DpapiDataProtectionProvider("Sample");
UserManager = new ApplicationUserRepository(new UserStore <ApplicationUser,
CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(db));
UserManager.UserTokenProvider = new DataProtectorTokenProvider <ApplicationUser, int>(provider.Create("EmailConfirmation"));
RoleManager = new ApplicationRoleRepository(new RoleStore <ApplicationRole>(db));
var currentUser = _clientRepository.Get(HttpContext.Current.User.Identity.GetUserId <int>());
if (!ReferenceEquals(currentUser, null))
{
HttpContext.Current.Session["isPerformer"] = currentUser.IsPerformer;
HttpContext.Current.Session["adminStatus"] = currentUser.AdminStatus;
}
}
public IActionResult OnPostCreate()
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
ApplicationUserRepository userRepository = new ApplicationUserRepository(context);
var user = userRepository.Get(userId);
var tournament = new Tournament
{
Status = TournamentStatus.Draft,
CreatedAt = DateTime.Now,
DueDate = DateTime.Now.AddMonths(1),
Owner = user,
Name = "Draft " + DateTime.Now.ToShortDateString()
};
repository.Add(tournament);
int tournamentId = tournament.TournamentId;
return(RedirectToPage("Edit", new { id = tournamentId }));
}
public IActionResult Index()
{
ApplicationUserRepository userRepo;
IPager <ApplicationUser> pager = null;
try
{
userRepo = new ApplicationUserRepository(settings, logger, dbc);
pager = userRepo.FindAll(new Pager <ApplicationUser>()
{
PageNbr = 0, PageSize = 20
});
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
return(View(pager));
}
public void SetUp()
{
this.transactionScope = new TransactionScope();
this.applicationUserRepository = new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
this.jobStatusRepository = new JobStatusRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
this.jobRepository = new JobRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
this.jobStatusTypeRepository = new JobStatusTypeRepository(ConfigurationManager.ConnectionStrings["BBOS"].ConnectionString);
this.user = BuildMeA.ApplicationUser("UserName");
this.applicationUserRepository.Create(user);
this.job = BuildMeA.Job(DateTime.Now, DateTime.Now, DateTime.Now, String.Empty, "dfsdfjdf");
this.job.ManCoDocID = 10;
this.job.UserID = this.user.Id;
this.jobRepository.Create(this.job);
this.jobStatusType = BuildMeA.JobStatusType("descrip");
this.jobStatusTypeRepository.Create(this.jobStatusType);
this.jobStatus = BuildMeA.JobStatus(DateTime.Now).WithJobStatusType(this.jobStatusType);
this.jobStatus.JobID = this.job.JobID;
}
private IUserService GetUserService()
{
var globalSettingsRepository = new GlobalSettingRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
var applicationUserRepository = new ApplicationUserRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
var manCoRepository = new ManCoRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
var passwordHistoryRepository = new PasswordHistoryRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
var userManagerProvider = new UserManagerProvider(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
var roleManagerProvider = new RoleManagerProvider(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
var authenticationManagerProvider = new AuthenticationManagerProvider(new HttpContextBaseProvider());
var sessionRepository = new SessionRepository(ConfigurationManager.ConnectionStrings["Unity"].ConnectionString);
return(new UserService(
userManagerProvider,
roleManagerProvider,
authenticationManagerProvider,
applicationUserRepository,
passwordHistoryRepository,
globalSettingsRepository,
manCoRepository,
sessionRepository));
}
