public async Task <ActionResult> RegisterEmployer(EmployerCreateDto employerCreateDto)
{
if (ModelState.IsValid)
{
try
{
await EmployerFacade.Register(employerCreateDto);
var authTicket = new FormsAuthenticationTicket(1, employerCreateDto.Email, DateTime.Now,
DateTime.Now.AddMinutes(30), false, "Employer");
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
HttpContext.Response.Cookies.Add(authCookie);
return(RedirectToAction("Index", "Home"));
}
catch (ArgumentException)
{
ModelState.AddModelError("Username", "Account with that username already exists!");
return(View());
}
}
return(View(employerCreateDto));
}
public ActionResult Login(LoginModel model, string returnUrl)
{
(bool successUser, string rolesUser) = UserFacade.Login(model.Email, model.Password);
(bool successEmployer, string rolesEmployer) = EmployerFacade.Login(model.Email, model.Password);
if (successUser || successEmployer)
{
//FormsAuthentication.SetAuthCookie(model.Username, false);
var authTicket = new FormsAuthenticationTicket(1, model.Email, DateTime.Now,
DateTime.Now.AddMinutes(30), false, successUser ? rolesUser : rolesEmployer);
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
HttpContext.Response.Cookies.Add(authCookie);
var decodedUrl = "";
if (!string.IsNullOrEmpty(returnUrl))
{
decodedUrl = Server.UrlDecode(returnUrl);
}
if (Url.IsLocalUrl(decodedUrl))
{
return(Redirect(decodedUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Wrong username or password!");
return(View());
}
public EmployerItemViewModel(Employer employer, EmployerFacade employerFacade, IEmployerViewModelsFactory employerVMFactory)
{
_employerVMFactory = employerVMFactory;
_employerFacade = employerFacade;
CanBeRemoved = false;
_employerDetailViewModel = (EmployerDetailViewModel)_employerVMFactory.Create(employer, EmployerViewModel.DETAIL);
_employerDetailViewModel.OnDeletionClicked += (object sender, EventArgs e) =>
{
if (_employerDeletionViewModel == null)
{
_employerDeletionViewModel = (EmployerDeletionViewModel)_employerVMFactory.Create(employer, EmployerViewModel.DELETION);
_employerDeletionViewModel.OnReturnBackClicked += (object s, EventArgs ea) =>
{
ActivateItem(_employerDetailViewModel);
};
_employerDeletionViewModel.OnDeletedEmployer += (object s, EventArgs ea) =>
{
CanBeRemoved = true;
ActivateItem(_employerDetailViewModel);
};
}
ActivateItem(_employerDeletionViewModel);
};
ActivateItem(_employerDetailViewModel);
}
public EmployerDetailViewModel(EmployerFacade employerFacade, Employer employer)
{
_employer = employer;
Name = employer.Name;
_employerFacade = employerFacade;
}
public EmployerViewModelsFactory(
IViewModelResolver viewModelResolver,
EmployerFacade employerFacade
)
{
_viewModelResolver = viewModelResolver;
_employerFacade = employerFacade;
}
public async Task <ActionResult> OffersOfCurrentEmployer()
{
var employer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name);
var offers = await JobOfferFacade.GetAllOffersOfEmployer(employer.Id);
return(View("Index", offers));
}
public EmployersViewModel(EmployerFacade employerFacade)
{
_employerFacade = employerFacade;
BaseWindowTitle = "Správa zaměstnavatelů";
_employers = new ObservableCollection <EmployerItemViewModel>();
}
public ListingEditingViewModel(ListingFacade listingFacade, EmployerFacade employerFacade)
{
BaseWindowTitle = "Úprava výčetky";
_listingFacade = listingFacade;
_employerFacade = employerFacade;
_selectedEmployer = _promptEmployer;
}
public ListingViewModel(
ListingFacade listingFacade,
EmployerFacade employerFacade,
IListingFactory listingFactory
)
{
_listingFacade = listingFacade;
_employerFacade = employerFacade;
_listingFactory = listingFactory;
}
public async Task <ActionResult> Create()
{
var model = new JobOfferCreateViewModel
{
AllSkills = await SkillSelectListHelper.Get(),
Employer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name),
NumberOfQuestions = 1
};
return(View(model));
}
public ListingViewModel(ListingFacade listingFacade, EmployerFacade employerFacade)
{
_listingFacade = listingFacade;
_employerFacade = employerFacade;
BaseWindowTitle = "Nová výčetka";
SelectedYear = DateTime.Now.Year;
SelectedMonth = DateTime.Now.Month;
Reset();
}
private static EmployerFacade CreateFacade(
Mock <QueryObjectBase <EmployerDto, Employer, EmployerFilterDto, IQuery <Employer> > > employerQueryMock,
Mock <IEmployerRepository> employerRepositoryMock)
{
var mockManager = new FacadeMockManager();
var uowMock = FacadeMockManager.ConfigureUowMock();
var mapper = FacadeMockManager.ConfigureRealMapper();
var service = new EmployerService(mapper, employerRepositoryMock.Object, employerQueryMock.Object, new AuthenticationService());
var facade = new EmployerFacade(uowMock.Object, service);
return(facade);
}
public async Task <ActionResult> Delete(int id)
{
var offer = await JobOfferFacade.GetOffer(id);
var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name);
if (currentEmployer.Id != offer.EmployerId)
{
throw new ArgumentException();
}
return(View(offer));
}
private static EmployerFacade CreateFacade(QueryResultDto <EmployerDto, EmployerFilterDto> expectedQueryResult)
{
var mockManager = new FacadeMockManager();
var uowMock = FacadeMockManager.ConfigureUowMock();
var mapper = FacadeMockManager.ConfigureRealMapper();
var repositoryMock = new Mock <IEmployerRepository>(MockBehavior.Loose);
var queryMock =
mockManager.ConfigureQueryObjectMock <EmployerDto, Employer, EmployerFilterDto>(expectedQueryResult);
var customerService = new EmployerService(mapper, repositoryMock.Object, queryMock.Object, new AuthenticationService());
var customerFacade = new EmployerFacade(uowMock.Object, customerService);
return(customerFacade);
}
public async Task <ActionResult> Delete(int id, FormCollection collection)
{
var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name);
try
{
await JobOfferFacade.DeleteJobOffer(id, currentEmployer);
return(RedirectToAction("OffersOfCurrentEmployer"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Edit(int id, JobOfferCreateViewModel model)
{
var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name);
if (ModelState.IsValid)
{
model.JobOfferCreateDto.EmployerId = currentEmployer.Id;
await JobOfferFacade.EditJobOffer(model.JobOfferCreateDto, currentEmployer);
return(RedirectToAction("OffersOfCurrentEmployer"));
}
model.AllSkills = await SkillSelectListHelper.Get();
model.Employer = currentEmployer;
return(View(model));
}
public async Task <ActionResult> Edit(int id)
{
var jobOfferCreateDto = new JobOfferCreateDto(await JobOfferFacade.GetOffer(id));
var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name);
if (currentEmployer.Id != jobOfferCreateDto.EmployerId)
{
throw new ArgumentException();
}
var model = new JobOfferCreateViewModel
{
AllSkills = await SkillSelectListHelper.Get(),
Employer = currentEmployer,
JobOfferCreateDto = jobOfferCreateDto
};
return(View(model));
}
private static async Task TestRegister(Mapper mapper)
{
EmployerFacade employerFacade = new EmployerFacade(Provider,
new EmployerService(mapper, new EmployerRepository(Provider),
new EmployerQueryObject(mapper, new EntityFrameworkQuery <Employer>(Provider))));
await employerFacade.Register(new EmployerCreateDto
{
Name = "Employer1",
Password = "******",
Address = "Brno",
Email = "*****@*****.**",
PhoneNumber = "+421902333666"
}
);
var results = await employerFacade.GetAllEmployersAsync();
foreach (var resultsItem in results.Items)
{
Console.WriteLine(resultsItem.Name, resultsItem.Id);
}
}
public EmployerItemViewModel(EmployerFacade employerFacade, Employer employer)
{
_employer = employer;
_employerFacade = employerFacade;
ChangeView(nameof(EmployerDetailViewModel));
}
public ListingEditingViewModel(ListingFacade listingFacade, EmployerFacade employerFacade)
{
_listingFacade = listingFacade;
_employerFacade = employerFacade;
}
public EmployerDeletionViewModel(Employer employer, EmployerFacade employerFacade)
{
_employer = employer;
_employerFacade = employerFacade;
}
