public async Task <IHttpActionResult> SignUp(EmployerViewModel employerVM)
{
if (!ModelState.IsValid)
{
return(Ok(new { Error = "Invalid data submitted!" }));
}
var user = new ApplicationUser {
UserName = employerVM.Email, Email = employerVM.Email, IsEmployer = true
};
try
{
var result = await UserManager.CreateAsync(user, employerVM.Password);
employerVM.AuthID = user.Id;
await employerService.CreateEmployerAsync(employerVM);
}
catch (Exception)
{
return(Ok(new { Error = "Someting went wrong while creating user profile!" }));
}
return(Ok(new { Success = "User account created successfully!" }));
}
//Edit Profile
public async Task <IActionResult> EditProfile(int?id)
{
if (id == null)
{
return(NotFound());
}
var model = await _context.Employer.FindAsync(id);
if (model == null)
{
return(NotFound());
}
EmployerViewModel vm = new EmployerViewModel
{
Id = model.Id,
Name = model.Name,
Description = model.Description,
CEOName = model.CEOName,
Location = model.Location,
PhoneNumber = model.PhoneNumber,
Mail = model.Mail,
Password = model.Password,
};
return(View(vm));
}
public async Task <ActionResult> Register(EmployerViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> CreateEmployer(EmployerViewModel viewModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(viewModel));
}
var user = new ApplicationUser
{
UserName = viewModel.Email,
Email = viewModel.Email,
Employer = new Employer
{
Eik = viewModel.Eik,
Name = viewModel.EmployerName,
City = viewModel.City,
Country = viewModel.Country,
ImageUrl = GlobalConstants.DefaultEmployerImage,
},
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
PhoneNumber = viewModel.PhoneNumber,
};
IdentityResult result = await this.userManager.CreateAsync(user, viewModel.Password);
if (result.Succeeded)
{
await this.userManager.AddToRoleAsync(user, GlobalConstants.EmployerRoleName);
this.TempData["InfoMessage"] = "Employer created successfully!";
}
return(this.Redirect("/Administration/Dashboard/Users/"));
}
public ActionResult RegisterEmployer()
{
var model = new EmployerViewModel();
model.Role = "Employer";
return(View(model));
}
public EmployerViewModel SaveEmployer(EmployerViewModel viewModel)
{
var employer = Mapper.Map <EmployerViewModel, Employer>(viewModel);
employer = _employerService.SaveEmployer(employer);
return(Mapper.Map <Employer, EmployerViewModel>(employer));
}
public MainWindow(EmployerContext context)
{
InitializeComponent();
this.db = context;
StartData.Initialize(db);
DataContext = new EmployerViewModel(db);
}
public async Task <Employer> CreateEmployerFromViewModel(EmployerViewModel employerModel)
{
return(await _employerRepository.AddAsync(new Employer()
{
Address = employerModel.Address,
PhoneNumber = employerModel.PhoneNumber,
Name = employerModel.Name
}));
}
private void SetFilteredOrganisationsForPage(int page, EmployerViewModel vm, List <OrganisationViewModel> filteredLegalEntities)
{
var skip = (page - 1) * MaxLegalEntitiesPerPage;
vm.Organisations = filteredLegalEntities
.Skip(skip)
.Take(MaxLegalEntitiesPerPage)
.ToList();
}
private static void Main(string[] args)
{
// do this with Ninject
var employerViewModel = new EmployerViewModel(new EventAggregator(), new MyRepository());
// this selection should actually be user input
employerViewModel.SelectedEmployer = employerViewModel.Employers.First();
// select another one
employerViewModel.SelectedEmployer = employerViewModel.Employers.Last();
}
public static EmployerViewModel MapDbModelToViewModel(Database.Employer dbModel)
{
var viewModel = new EmployerViewModel();
viewModel.Id = dbModel.Id;
viewModel.Name = dbModel.Name;
viewModel.UserId = dbModel.UserId;
return(viewModel);
}
public async Task UpdateEmployerFromViewModel(EmployerViewModel employerModel)
{
await _employerRepository.UpdateAsync(new Employer()
{
Id = employerModel.Id,
Address = employerModel.Address,
PhoneNumber = employerModel.PhoneNumber,
Name = employerModel.Name
});
}
public ActionResult Create(int bureauId)
{
var userId = User.Identity.GetUserId();
var bureau = _payrollBureauBusinessService.RetrieveBureau(bureauId);
var model = new EmployerViewModel {
BureauId = bureau.BureauId, BureauName = bureau.Name
};
return(View(model));
}
public async Task <ActionResult> EditEmployer(EmployerViewModel model, string Id)
{
if (ModelState.IsValid)
{
var user = await employerManager.GetBaseUserByGuid(Id);
var employer = await employerManager.Get(user.UserId);
user.Email = model.EmailAdress;
employer.Adress = model.Adress;
employer.City = model.City;
employer.CompanyName = model.CompanyName;
employer.FirstName = model.FirstName;
employer.LastName = model.LastName;
employer.PostalCode = model.PostalCode;
employer.Prefix = model.Prefix;
employer.TelephoneNumber = model.TelephoneNumber;
model.EmployerId = employer.EmployerId;
await employerManager.Update(employer);
model.Employees = employer.Employees;
var modUser = await adminManager.GetBaseUserByName(User.Identity.Name);
var alert = new Alert();
{
alert.AlertId = Guid.NewGuid();
alert.EmployerId = employer.EmployerId;
alert.AlertType = AlertType.Employer_Update;
alert.AlertIsDeleted = false;
alert.AlertCreateTS = DateTime.Now;
alert.AlertUpdateTS = DateTime.Now;
alert.UserId = modUser.UserId;
};
await alertManager.CreateAsync(alert);
var messageInfo = new AdminEditEmployerMessageBuilder(
user.UserName,
employer.CompanyName,
employer.FirstName,
employer.Prefix,
employer.LastName,
employer.TelephoneNumber,
employer.PostalCode,
employer.Adress,
employer.City);
await mailingService.SendMailAsync(messageInfo.Body, messageInfo.Subject, user.Email);
return(View("EmployerProfile", model));
}
return(View(model));
}
public static Database.Employer MapInsertModelToDbModel(EmployerViewModel model, Database.Employer newDomainModel = null)
{
if (newDomainModel == null)
{
newDomainModel = new Database.Employer();
newDomainModel.Id = Guid.NewGuid();
}
newDomainModel.Name = model.Name;
newDomainModel.UserId = model.UserId;
return(newDomainModel);
}
public ActionResult Create(EmployerViewModel viewModel)
{
try
{
var validationResult = _PayrollBureauBusinessService.EmployerAlreadyExists(viewModel.Employer.Name, viewModel.Email, null);
if (!validationResult.Succeeded)
{
foreach (var error in validationResult.Errors)
{
ModelState.AddModelError("", error);
}
return(View(viewModel));
}
//create employeruser and role
var user = new ApplicationUser
{
UserName = viewModel.Email,
Email = viewModel.Email,
};
var roleId = RoleManager.Roles.FirstOrDefault(r => r.Name == "Employer").Id;
user.Roles.Add(new IdentityUserRole {
UserId = user.Id, RoleId = roleId
});
var result = UserManager.Create(user, "Inland12!");
if (!validationResult.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
//create employer
var userId = User.Identity.GetUserId();
viewModel.Employer.BureauId = viewModel.BureauId;
viewModel.Employer.AspnetUserId = user.Id;
viewModel.Employer.CreatedDateUtc = DateTime.UtcNow;
viewModel.Employer.CreatedBy = userId;
var employer = _payrollBureauBusinessService.CreateEmployer(viewModel.Employer);
if (employer.Succeeded)
{
return(RedirectToAction("Index", "Employer"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex);
}
return(RedirectToAction("Index", "Employer"));
}
public ActionResult Edit(EmployerViewModel model)
{
var result = _payrollBureauBusinessService.UpdateEmployer(model.Employer);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Employer"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
public static EmployerViewModel Convert(this Employer employer)
{
var viewModel = new EmployerViewModel
{
EmployerId = employer.EmployerId,
EdsUrn = employer.EdsUrn,
FullName = employer.FullName,
TradingName = employer.TradingName,
Address = employer.Address.Convert(),
Status = employer.EmployerStatus
};
return(viewModel);
}
/// <summary>
///
/// </summary>
/// <param name="employerVM"></param>
/// <returns></returns>
public async Task <EmployerViewModel> UpdateEmployer(EmployerViewModel employerVM)
{
var id = new ObjectId(employerVM._id);
var filter = Builders <Employers> .Filter.Eq("_id", id);
var update = Builders <Employers> .Update
.Set("CompanyName", employerVM.CompanyName)
.Set("Email", employerVM.Email)
.Set("Location", employerVM.Location)
.Set("MobileNo", employerVM.MobileNo);
var result = await _db.Employers.UpdateOneAsync(filter, update);
return(GetEmployerByID(employerVM._id.ToString()));
}
public async Task <IActionResult> MyAccount(EmployerViewModel employer)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
Employer newEmployer = _employerService.GetAll().Where(e => e.UserId == user.Id).First();
newEmployer.JobConditions = employer.JobConditions;
_employerService.UpdateItem(newEmployer);
user.Email = employer.Email;
user.UserName = employer.Nickname;
user.Description = employer.Description;
await _userManager.UpdateAsync(user);
return(RedirectToAction("Index", "Home"));
}
// GET: Employer/Create
public ActionResult Create()
{
//var person = new Person();
//person.StateList = new SelectList(Helper.State);
//return View(person);
var viewModel = new EmployerViewModel()
{
Employer = new Employer(),
Person = new Person(),
Register = new RegisterViewModel()
};
return(View(viewModel));
}
public MediatorResponse <EmployerViewModel> SaveEmployer(EmployerViewModel viewModel)
{
try
{
viewModel = _employerProvider.SaveEmployer(viewModel);
return(GetMediatorResponse(AdminMediatorCodes.SaveEmployer.Ok, viewModel, EmployerViewModelMessages.EmployerSavedSuccessfully, UserMessageLevel.Info));
}
catch (Exception ex)
{
_logService.Error($"Failed to save employer with id={viewModel.EmployerId}", ex);
viewModel = _employerProvider.GetEmployer(viewModel.EmployerId);
return(GetMediatorResponse(AdminMediatorCodes.SaveEmployer.Error, viewModel, EmployerViewModelMessages.EmployerSaveError, UserMessageLevel.Error));
}
}
private void SetPager(string searchTerm, int page, EmployerViewModel vm, int filteredLegalEntitiesTotal)
{
var pager = new PagerViewModel(
filteredLegalEntitiesTotal,
MaxLegalEntitiesPerPage,
page,
"Showing {0} to {1} of {2} organisations",
RouteNames.Employer_Get,
new Dictionary <string, string>
{
{ nameof(searchTerm), searchTerm }
});
vm.Pager = pager;
}
public string UploadedFileProfile(EmployerViewModel model)
{
string uniqueFileName = null;
if (model.ProfileImage != null)
{
string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + Path.GetFileName(model.ProfileImage.FileName);
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.ProfileImage.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public async Task <IActionResult> MyAccount()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
Employer employer = _employerService.GetAll().Where(e => e.UserId == user.Id).First();
EmployerViewModel model = new EmployerViewModel()
{
Nickname = user.UserName,
Description = user.Description,
Email = user.Email,
JobConditions = employer.JobConditions,
Id = user.Id
};
return(View(model));
}
public ActionResult Edit(int id)
{
var employer = _payrollBureauBusinessService.RetrieveEmployer(id);
if (employer == null)
{
return(RedirectToAction("NotFound", "Error"));
}
var bureau = _payrollBureauBusinessService.RetrieveBureau(employer.BureauId);
var model = new EmployerViewModel {
BureauId = bureau.BureauId, BureauName = bureau.Name, Employer = employer
};
return(View(model));
}
public async Task <IActionResult> EditProfile(int id, EmployerViewModel model)
{
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
string uniqueFileName = UploadedFileProfile(model);
Employer employer = new Employer
{
Id = model.Id,
Name = model.Name,
ProfilePicture = uniqueFileName,
Description = model.Description,
CEOName = model.CEOName,
Location = model.Location,
PhoneNumber = model.PhoneNumber,
Mail = model.Mail,
Password = model.Password,
};
_context.Update(employer);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployerExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
AppUser user = await userManager.GetUserAsync(User);
if (model.Id != user.EmployerId)
{
return(RedirectToAction("AccessDenied", "Account", null));
}
return(RedirectToPage(""));
}
public ActionResult Create(EmployerViewModel viewModel)
{
try
{
//create Bureau
var userId = User.Identity.GetUserId();
viewModel.Employer.BureauId = viewModel.BureauId;
viewModel.Employer.CreatedBy = userId;
var employer = _payrollBureauBusinessService.CreateEmployer(viewModel.Employer);
if (!employer.Succeeded)
{
foreach (var error in employer.Errors)
{
ModelState.AddModelError("", error);
}
return(View(viewModel));
}
//create employeruser and role
var user = new ApplicationUser
{
UserName = viewModel.Email,
Email = viewModel.Email,
};
var roleId = RoleManager.Roles.FirstOrDefault(r => r.Name == "Employer").Id;
user.Roles.Add(new IdentityUserRole {
UserId = user.Id, RoleId = roleId
});
var result = UserManager.Create(user, "Inland12!");
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
//create AspNetUser Employer
_payrollBureauBusinessService.CreateAspNetUserEmployer(employer.Entity.EmployerId, user.Id);
}
catch (Exception ex)
{
ModelState.AddModelError("", ex);
}
return(RedirectToAction("Index", "Employer", new { bureauId = viewModel.BureauId }));
}
public async Task <IHttpActionResult> CreateEmployerAsync(EmployerViewModel employerVM)
{
if (ModelState.IsValid)
{
try
{
var employer = await employerService.CreateEmployerAsync(employerVM);
return(Ok(new { Success = employer }));
}
catch (Exception ex)
{
return(Ok(new { Error = "" + ex.Message }));
}
}
return(Ok(new { Error = "Could Not Saved Data!" }));
}
public async Task <IHttpActionResult> UpdateEmployer(EmployerViewModel employerVM)
{
if (!ModelState.IsValid)
{
return(Ok(new { Error = "ModelState Invalid!" }));
}
try
{
var employer = await employerService.UpdateEmployer(employerVM);
return(Ok(new { Success = employer }));
}
catch (Exception ex)
{
return(Ok(new { Error = ex.Message }));
}
}
