public void Initialize()
{
var registrationViewModel = new RegistrationViewModel(_petRepository, _events);
var view = new RegistrationPanel(registrationViewModel);
_regionManager.Regions["Admin"].Add(view);
_regionManager.Regions["Admin"].Activate(view);
}
public HttpResponseMessage Register(HttpRequestMessage request, RegistrationViewModel user)
{
return CreateHttpResponse(
request
, () =>
{
var response = default(HttpResponseMessage);
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
}
else
{
var newUser = membershipService.CreateUser(user.Username, user.Email, user.Password, new int[] { 1 });
if (newUser != null)
{
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { success = false });
}
}
return response;
});
}
public static User Map(RegistrationViewModel viewModel)
{
User user = new User();
user.Email = viewModel.Email;
user.FirstName = viewModel.FirstName;
user.LastName = viewModel.LastName;
user.University = viewModel.University;
user.BirthDate = DateMapper.Map(viewModel.BirthDate);
user.PhotoFileName = viewModel.PhotoFileName;
return user;
}
public bool Register(RegistrationViewModel info)
{
using (var db = new DAL.Model.MovieRentalDBEntities())
{
bool result = false;
var userEntity = new DAL.Model.User(info);
db.Users.Add(userEntity);
db.SaveChanges();
return result;
}
}
public void Handle(RegistrationStartedEvent message)
{
var vm = new RegistrationViewModel();
Mapper.Map(message, vm);
vm.CanAddCreditCardInfo = true;
vm.CanAddLogin = true;
try
{
_session.Store(vm, vm.Id);
_session.SaveChanges();
}
catch (Exception)
{
throw;
}
}
public ActionResult Register(RegistrationViewModel model)
{
if (ModelState.IsValid)
{
var accountService = new Service.Logic.Account();
accountService.Register(model);
return RedirectToAction("SuccessRegistration", new RegistrationViewModel()
{
FirstName = model.FirstName,
EmailAddress = model.EmailAddress,
LastName = model.LastName,
MiddleName = model.MiddleName
});
}
return View(model);
}
public void ShouldCopyTheDetailsButNotNameOfAnExistingPet()
{
// Given an existing pet
var model = new RegistrationViewModel(_petRepository.Object, new StubEventAggregator());
model.Name = "Nemo";
// When I copy that pet
model.CopiablePets[0].CopyCommand.Execute(_goldie);
// Then it should copy all the details
// but not the name
Assert.AreEqual("100.00", model.Price);
Assert.Contains(Rule.SELL_IN_PAIRS, model.Rules);
Assert.AreEqual(_goldie.FoodType, model.FoodType);
Assert.AreEqual(_goldie.Type, model.PetType);
Assert.AreEqual("Nemo", model.Name);
}
public HomeModule(
IMarkdownRepository markdownRepository,
IMembershipOrganisationRepository membershipOrganisationRepository,
IPaymentMethodRepository paymentMethodRepository,
RegistrationViewModel registrationViewModel,
IRootPathProvider rootPathProvider
)
{
// todo: do I really need / and /{page}?
Get["/"] = parameters =>
{
return PageView(markdownRepository.GetMarkdown("home"));
};
Get["/registration"] = parameters =>
{
var isDeveloperMachine = rootPathProvider.GetRootPath().StartsWith(@"C:\Users\Tim\Code\");
return View["registration", new { isDeveloperMachine }];
};
Post["/registration"] = parameters =>
{
this.BindTo(registrationViewModel);
var validation = this.Validate(registrationViewModel);
if (!validation.IsValid)
{
return View["registration", registrationViewModel];
}
throw new System.NotImplementedException("post valid viewmodel");
};
Get["/{page}", ctx => markdownRepository.MarkdownExists(ctx.Request.Path)] = parameters =>
{
return PageView(markdownRepository.GetMarkdown(parameters.page));
};
}
public static Registration MapViewModelToModel(this RegistrationViewModel entity)
{
return(Mapper.Map <RegistrationViewModel, Registration>(entity));
}
public RegistrationPage()
{
InitializeComponent();
BindingContext = viewModel = new RegistrationViewModel();
}
public RegistranionPage()
{
InitializeComponent();
DataContext = new RegistrationViewModel(bd, this);
}
/// <summary>
/// Конструктор для окна обновления данных пользователя в бд
/// </summary>
/// <param name="users">список пользователей для обновления на клиенте</param>
/// <param name="user">пользователь которого нужно обновить</param>
public RegistrationWindow(ObservableCollection <UserContract> users, UserContract user) : this()
{
DataContext = new RegistrationViewModel(users, user, this);
}
private void GoodRegistration(RegistrationViewModel obj)
{
DisplayAlert("Thanks for signing up!",
"We'll let you know when you're verified. Feel free to look around!", "Ok");
Application.Current.MainPage = new RootPage();
}
public RegisterUsuario(RegistrationViewModel vm)
{
viewModel = vm;
}
public ActionResult Register(RegistrationViewModel newUser)
{
if (ModelState.IsValid)
{
if (_context.Characters.Find(newUser.CharacterUrl) == null)
{
var serializer = new JsonSerializer();
HttpWebRequest characterRequest = WebRequest.CreateHttp(newUser.CharacterUrl);
characterRequest.UserAgent = "Mozilla / 5.0(Windows NT 6.1; Win64; x64; rv: 47.0) Gecko / 20100101 Firefox / 47.0";
HttpWebResponse characterResponse = (HttpWebResponse)characterRequest.GetResponse();
if (characterResponse.StatusCode == HttpStatusCode.OK)
{
using (var data = new StreamReader(characterResponse.GetResponseStream()))
using (var jsonReader = new JsonTextReader(data))
{
var fullCharacter = serializer.Deserialize <FullCharacter>(jsonReader);
_context.Characters.Add(fullCharacter.ToModel());
}
}
}
var guest = new Guest()
{
FirstName = newUser.FirstName, LastName = newUser.LastName, AttendanceDate = newUser.AttendanceDate, EmailAddress = newUser.EmailAddress, Guest1 = newUser.Guest1, Attending = (newUser.Attending == "Yes"), CharacterUrl = newUser.CharacterUrl
};
_context.Guests.Add(guest);
_context.SaveChanges();
if (newUser.Attending == "Yes")
{
var user = new IdentityUser()
{
UserName = newUser.EmailAddress
};
var identityResult = _userManager.Create(user, newUser.Password);
if (identityResult.Succeeded)
{
TempData["Guest"] = guest;
var authManager = HttpContext.GetOwinContext().Authentication;
var ident = _userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
authManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, ident);
return(RedirectToAction("Create", "Dishes"));
}
ModelState.AddModelError("", identityResult.Errors.FirstOrDefault());
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
var characters = GetCharacters(271);
ViewBag.CharacterUrl = new SelectList(characters, "Url", "Name");
ViewBag.Joke = GetChuckNorrisJoke();
return(View(newUser));
}
public async Task <ResponseBase> SignUp([FromBody] RegistrationViewModel userDetails)
{
var checkUserName = _accountRepo.checkUserName(userDetails.Email);
if (checkUserName > 0)
{
return(new ResponseBase()
{
ErrorDetails = "Email Already taken by another user", IsSuccess = false
});
}
ApplicationUser user = new ApplicationUser()
{
UserName = userDetails.Email,
Email = userDetails.Email,
PhoneNumber = userDetails.PhoneNumber,
};
User newUser = new User()
{
FirstName = userDetails.FirstName,
LastName = userDetails.LastName,
PhoneNumber = userDetails.PhoneNumber,
Sex = userDetails.Sex,
ApplicationUserId = user.Id,
IsApproved = false,
Activated = true,
Email = userDetails.Email,
};
try
{
var result = await _userManager.CreateAsync(user, userDetails.Password);
if (!result.Succeeded)
{
return(new ResponseBase()
{
ErrorDetails = "Make your password stronger and try again ", IsSuccess = false
});
}
else
{
try
{
await _userRepo.AddUser(newUser);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { UserId = user.Id, Code = code }, protocol: HttpContext.Request.Scheme);
// send email confirmation mail here
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("UserName", user.UserName));
await _signInManager.SignOutAsync();
user.LockoutEnabled = false;
user.EmailConfirmed = false;
return(new ResponseBase()
{
IsSuccess = true
});
}
catch (Exception ex)
{
await _userRepo.DeleteFailedUser(newUser, user);
return(new ResponseBase()
{
ErrorDetails = Error(), IsSuccess = false
});
}
}
}
catch (Exception ex)
{
return(new ResponseBase()
{
ErrorDetails = Error(), IsSuccess = false
});
}
}
public async Task <object> Register([FromBody] RegistrationViewModel model)
{
var errorMessage = new ErrorMessageViewModel();
var error = new { Error = errorMessage };
// Check for the role type upon registration
string[] availableRoles = { "Personal", "Business" };
if (!availableRoles.Contains(model.Role))
{
errorMessage.Message = "Invalid Role";
return(Json(error));
}
// Create variable for Application User
var user = new ApplicationUser
{
Email = model.Email,
UserName = model.Email
};
ApplicationUser appUser = db.ApplicationUser.Where(e => e.Email.Equals(user.Email, StringComparison.InvariantCultureIgnoreCase)).SingleOrDefault();
if (appUser != null)
{
errorMessage.Message = "Username is already taken.";
return(Json(error));
}
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, model.Role);
await _signInManager.SignInAsync(user, false);
// Profile Types
BusinessUsers businessUser = new BusinessUsers();
PersonalUsers personalUser = new PersonalUsers();
// Create the user profile
if (model == null)
{
errorMessage.Message = "No data was found";
return(Json(error));
}
if (model.Role == availableRoles[0])
{
// If the user role is a business user
var profile = new PersonalUsers
{
FirstName = model.FirstName,
LastName = model.LastName,
UserId = user.Id
};
// Add the user to the database
db.PersonalUsers.Add(profile);
try
{
db.SaveChanges();
}
catch (Exception exception)
{
errorMessage.Message = "Could not add personal user to the database";
return(Json(error));
}
personalUser = profile;
}
else if (model.Role == availableRoles[1])
{
// If the user role is a personal user
var profile = new BusinessUsers
{
FirstName = model.FirstName,
LastName = model.LastName,
Organization = model.Organization,
UserId = user.Id,
PhoneNumber = model.PhoneNumber
};
// Add the user to the database
db.BusinessUsers.Add(profile);
try
{
db.SaveChanges();
}
catch (Exception exception)
{
errorMessage.Message = "Could not add business user to the database";
return(Json(error));
}
businessUser = profile;
}
// Create role list to create jwt token
List <string> roleList = new List <string>()
{
model.Role
};
var jwtToken = await GenerateJwtToken(model.Email, user, roleList);
var userRoles = await _userManager.GetRolesAsync(user);
// Send the user role along with the JWT Token
if (model.Role == availableRoles[0])
{
var response = new PersonalLoginResponse
{
Token = jwtToken.ToString(),
Roles = userRoles.ToArray(),
PersonalUser = personalUser
};
return(Json(response));
}
else if (model.Role == availableRoles[1])
{
var response = new BusinessLoginResponse
{
Token = jwtToken.ToString(),
Roles = userRoles.ToArray(),
BusinessUser = businessUser
};
return(Json(response));
}
}
else if (!result.Succeeded)
{
errorMessage.Message = "Password must have 6+ characters, at least 1 uppercase character, 1 lowercase character, 1 number, and 1 non-alphanumeric character";
return(Json(error));
}
errorMessage.Message = "An error has occurred";
return(Json(error));
}
public override void Setup()
{
ApiClientResponse = true;
RegistrationViewModel = new RegistrationViewModel
{
Uln = new UlnViewModel {
Uln = "1234567890"
},
LearnersName = new LearnersNameViewModel {
Firstname = "First", Lastname = "Last"
},
DateofBirth = new DateofBirthViewModel {
Day = "01", Month = "01", Year = "2020"
},
SelectProvider = new SelectProviderViewModel {
SelectedProviderUkprn = "98765432", SelectedProviderDisplayName = "Barnsley College (98765432)"
},
SelectCore = new SelectCoreViewModel {
SelectedCoreCode = _coreCode, SelectedCoreDisplayName = $"Education ({_coreCode})", CoreSelectList = new List <SelectListItem> {
new SelectListItem {
Text = "Education", Value = _coreCode
}
}
},
SpecialismQuestion = new SpecialismQuestionViewModel {
HasLearnerDecidedSpecialism = true
},
SelectSpecialisms = new SelectSpecialismViewModel {
PathwaySpecialisms = new PathwaySpecialismsViewModel {
PathwayCode = _coreCode, PathwayName = "Education", Specialisms = new List <SpecialismDetailsViewModel> {
new SpecialismDetailsViewModel {
Code = "7654321", Name = "Test Education", DisplayName = "Test Education (7654321)", IsSelected = true
}
}
}
},
SelectAcademicYear = new SelectAcademicYearViewModel {
SelectedAcademicYear = "2020"
}
};
Logger = Substitute.For <ILogger <RegistrationLoader> >();
BlobStorageService = Substitute.For <IBlobStorageService>();
InternalApiClient = Substitute.For <IResultsAndCertificationInternalApiClient>();
InternalApiClient.AddRegistrationAsync(Arg.Any <RegistrationRequest>()).Returns(ApiClientResponse);
HttpContextAccessor = Substitute.For <IHttpContextAccessor>();
HttpContextAccessor.HttpContext.Returns(new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.GivenName, Givenname),
new Claim(ClaimTypes.Surname, Surname),
new Claim(ClaimTypes.Email, Email)
}))
});
var mapperConfig = new MapperConfiguration(c =>
{
c.AddMaps(typeof(RegistrationMapper).Assembly);
c.ConstructServicesUsing(type =>
type.Name.Contains("UserNameResolver") ?
new UserNameResolver <RegistrationViewModel, RegistrationRequest>(HttpContextAccessor) : null);
});
Mapper = new AutoMapper.Mapper(mapperConfig);
}
public ActionResult Register()
{
var model = new RegistrationViewModel();
return(View(model));
}
public RegistrationWindow(IUserSqlProvider userSqlProvider)
{
InitializeComponent();
DataContext = new RegistrationViewModel(userSqlProvider);
}
public ActionResult Register(RegistrationViewModel model)
{
if (ModelState.IsValid)
{
model.Registration.Username = model.Registration.Username.Sanitize(Utility.UserInfoWhiteList);
model.Registration.Email = model.Registration.Email.Sanitize(Utility.EmailWhiteList);
model.Registration.Password = model.Registration.Password.Sanitize(Utility.PasswordWhiteList);
model.Registration.ConfirmPassword = model.Registration.ConfirmPassword.Sanitize(Utility.PasswordWhiteList);
model.Registration.Salt = BCrypt.Net.BCrypt.GenerateSalt(saltWorkFactor);
//Hash the password
model.Registration.Password = hashString(model.Registration.Password + model.Registration.Salt);
AccountModel m = globalAccountRep.Register(model.Registration);
//--This does not return a success which is why it goes through the else--
if (m.Success)
{
Login(new LoginModel { Password = model.Registration.Password, LoginName = m.Email });
return RedirectToAction("Index","Home");
}
else
{
//input validation not successful
return View(model);
}
}
else
{
return View(model);
}
}
public IActionResult RegisterUser([FromBody] RegistrationViewModel newUser)
{
IActionResult _result = new ObjectResult(false);
GenericResult _registrationResult = null;
try
{
if (ModelState.IsValid)
{
if (newUser.RoleID != 0)
{
if (newUser.RoleID == 1 || newUser.RoleID == 2)
{
EmplonomyUser user = _empluser.RegisterManager(newUser.EmailAddress, newUser.Password, newUser.FirstName, newUser.LastName, newUser.PhoneCell, newUser.DepartmentID);
if (user != null)
{
_registrationResult = new GenericResult()
{
Succeeded = true,
Message = "Registration succeeded"
};
}
}
if (newUser.RoleID == 3)
{
EmplonomyUser user = _empluser.RegisterUser(newUser.EmailAddress, newUser.Password, newUser.FirstName, newUser.LastName, newUser.PhoneCell, newUser.DepartmentID);
if (user != null)
{
_registrationResult = new GenericResult()
{
Succeeded = true,
Message = "Registration succeeded"
};
}
}
}
}
else
{
_registrationResult = new GenericResult()
{
Succeeded = false,
Message = "Invalid fields."
};
}
}
catch (Exception ex)
{
_registrationResult = new GenericResult()
{
Succeeded = false,
Message = ex.Message
};
_loggingRepository.Add(new Error()
{
Message = ex.Message, StackTrace = ex.StackTrace, DateCreated = DateTime.Now
});
_loggingRepository.Commit();
}
_result = new ObjectResult(_registrationResult);
return(_result);
}
private void NewTest()
{
this.ViewModel = A.Dummy<RegistrationViewModel>();
}
public RegistrationPage()
{
this.DataContext = _viewModel = new RegistrationViewModel();
this.InitializeComponent();
}
public ActionResult SuccessRegistration(RegistrationViewModel model)
{
return View(model);
}
public async Task <bool> Checkout(string customerId, RegistrationViewModel viewModel)
{
var uri = $"{BasketUris.Checkout}/{customerId}";
return(await PostAsync <bool>(uri, viewModel));
}
public static BlogUser Create(RegistrationViewModel viewModel)
{
return(Mapper.Map <BlogUser>(viewModel));
}
public ActionResult Create(int id = 0, string type = null)
{
RegistrationViewModel model = new RegistrationViewModel();
if (id > 0)
{
model = registerService.GetRegisterInfoById(id);
}
else
{
model.RegistartionNo = registerService.MaxRegistartionNumber();
}
model.GenderList = new List <SJModel.SelectList>()
{
new SJModel.SelectList {
Value = "F", Text = "Female"
},
new SJModel.SelectList {
Value = "M", Text = "Male"
}
};
model.GetSourceList = registerService.GetSourceList();
if (model.CourseId == null || model.CourseId == 0)
{
model.EducationList = new List <SJModel.SelectList>()
{
new SJModel.SelectList {
Value = "10+2", Text = "10+2"
},
new SJModel.SelectList {
Value = "Graduate", Text = "Graduate"
},
new SJModel.SelectList {
Value = "Post-Graduate", Text = "Post-Graduate"
}
};
}
else if (model.CourseId == 1)
{
model.EducationList = new List <SJModel.SelectList>()
{
new SJModel.SelectList {
Value = "10+2", Text = "10+2"
},
};
}
else
{
model.EducationList = new List <SJModel.SelectList>()
{
new SJModel.SelectList {
Value = "Graduate", Text = "Graduate"
},
new SJModel.SelectList {
Value = "Post-Graduate", Text = "Post-Graduate"
}
};
}
model.CourseList = addmissionService.GetCourseList();
return(View(model));
}
public void InitializeViewModel(RegistrationViewModel viewModel)
{
}
public IActionResult Registration(RegistrationViewModel registrationViewModel)
{
_userService.Registration(registrationViewModel);
return(Ok());
}
private void BadRegistration(RegistrationViewModel obj, string message)
{
DisplayAlert("Could not register", message, "Ok");
}
public LoginViewModel(SigninViewModel login = null, RegistrationViewModel registration = null)
{
Signin = login;
Registration = registration;
}
public async Task Register(RegistrationViewModel registrationViewModel)
{
await _customHttpClient.PostJsonAsync("api/account/register", registrationViewModel
?? throw new AppException(ExceptionEvent.InvalidParameters, "Registration form can't be empty."));
}
public ActionResult Registration(RegistrationViewModel model)
{
if (ModelState.IsValid)
{
User user = new User()
{
Login = model.UserName,
Email = model.UserEmail,
CreateDate = DateTime.Now.Date,
Password = model.UserPassword,
};
repository.Add(user);
return RedirectToAction("Index", "Home");
}
return View(model);
}
// GET: Registration
public ActionResult Index()
{
RegistrationViewModel registrationViewModel = new RegistrationViewModel();
return(View(registrationViewModel));
}
public async Task <IActionResult> AddEmployee(RegistrationViewModel userRegVM)
{
try
{
//Check Email first
var emailToCheck = userRegVM.Email;
var emailVal = _unitOfWork.Employee.GetSingleOrDefault(e => e.Email == emailToCheck);
if (emailVal == null)
{
string tempPassword = DateTime.Now.ToString("ffff");
string userName = userRegVM.FirstName.Substring(0, 1).ToLower() + userRegVM.MiddleName.Substring(0, 1).ToLower() + userRegVM.LastName.Replace(" ", "").ToLower();
int iUserNameCount = _unitOfWork.Employee.Find(u => u.UserName.Contains(userName)).ToList().Count();
if (iUserNameCount > 0)
{
iUserNameCount += 1;
userName += iUserNameCount.ToString();
}
tempPassword = userName + tempPassword;
userRegVM.CustomUserName = userName;
userRegVM.Password = tempPassword;
userRegVM.PasswordRaw = tempPassword;
userRegVM.IsEnabled = true;
//Create User
userRegVM.DOB = Utilities.FormatDateTimeByZone(userRegVM.DOB.Value);
userRegVM.DOJ = Utilities.FormatDateTimeByZone(userRegVM.DOJ.Value);
var userIdentity = mapper.Map <RegistrationViewModel, AppUser>(userRegVM);
userIdentity.Id = Guid.NewGuid().ToString();
var result = await _userManager.CreateAsync(userIdentity, tempPassword);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddError(result.ToString(), ModelState)));
}
//Get user to add roles to user
var user = await _userManager.FindByIdAsync(userIdentity.Id);
//Add Roles to user
IdentityRole adminUserRole = null;
if (userRegVM.Roles.RoleName.ToLower().Equals(Permissions.Roles.USER))
{
//User: Data in Roles Table
adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.USER);
if (adminUserRole == null)
{
adminUserRole = new IdentityRole(Permissions.Roles.USER);
await _roleManager.CreateAsync(adminUserRole);
}
//Add Claims to user
for (int i = 0; i <= userRegVM.Roles.RoleClaims.Length - 1; i++)
{
string roleClaims = userRegVM.Roles.RoleClaims[i].ToString();
switch (roleClaims)
{
case Permissions.RolePermission.Add:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Add));
break;
}
case Permissions.RolePermission.Edit:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Edit));
break;
}
case Permissions.RolePermission.View:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.View));
break;
}
case Permissions.RolePermission.Delete:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Delete));
break;
}
default:
{
break;
}
}
}
}
else
{
//Admin: Data in Roles Table
adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.ADMIN);
if (adminUserRole == null)
{
adminUserRole = new IdentityRole(Permissions.Roles.ADMIN);
await _roleManager.CreateAsync(adminUserRole);
}
//Add Claims to Admin
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Admins.CRUD));
}
//Add Roles to user
if (!await _userManager.IsInRoleAsync(user, adminUserRole.Name))
{
await _userManager.AddToRoleAsync(user, adminUserRole.Name);
}
//Add Contact
ContactResourseViewModel contactVM = userRegVM.Contact;
var empContact = mapper.Map <ContactResourseViewModel, Data.ContactResourse>(contactVM);
empContact.Id = Guid.NewGuid().ToString();
empContact.RefTableId = userIdentity.Id;
_unitOfWork.ContactResource.Add(empContact);
//Add Region according to UserID and HQ
HQRegionViewModel HQRegionVM = null;
foreach (var rgn in userRegVM.Region)
{
HQRegionVM = new HQRegionViewModel
{
HQID = userRegVM.HQ,
UserID = userIdentity.Id,
RegionID = rgn
};
var empHQRegion = mapper.Map <HQRegionViewModel, Data.Hqregion>(HQRegionVM);
_unitOfWork.HQRegion.Add(empHQRegion);
}
await _unitOfWork.CompleteAsync();
}
else
{
return(BadRequest(Errors.AddError("Email Already Exists.", ModelState)));
}
}
catch (Exception Ex)
{
return(new BadRequestObjectResult(Errors.AddError(Ex, ModelState)));
}
return(new OkObjectResult(userRegVM));
}
public Registration()
{
InitializeComponent();
viewModel = (RegistrationViewModel)base.DataContext;
viewModel.View = this;
}
public async Task <IActionResult> Register(RegistrationViewModel model)
{
if (ModelState.IsValid)
{
var user = new Instruktor
{
Email = model.Email,
ImePrezime = model.ImePrezime,
Cin = model.Cin,
UserName = model.Username,
ObukaId = model.ObukaId
};
ObukeDropDownList(model.ObukaId);
CinoviDropDownList(model.Cin);
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
/*
* sve radi ok
*
* var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
* var confirmationLink = Url.Action("ConfirmEmail", "Account",
* new { userId = user.Id, token = token }, Request.Scheme);
*
* MailMessage mailMessage = new MailMessage();
* mailMessage.From = new MailAddress(configuration["Email:Email"]);
* //user.Email
* mailMessage.To.Add("*****@*****.**");
* mailMessage.Body = $"Kliknite na link kako biste aktivirali nalog {confirmationLink}";
* mailMessage.Subject = "Confirmation link";
* SmtpClient client = new SmtpClient("smtp-mail.outlook.com");
* client.Port = 587;
* client.UseDefaultCredentials = false;
* client.EnableSsl = true;
* var credential = new NetworkCredential
* {
* UserName = configuration["Email:Email"],
* Password = configuration["Email:Password"]
* };
* client.Credentials = credential;
* client.Send(mailMessage);
* logger.Log(LogLevel.Warning, confirmationLink);
* return RedirectToAction("GetAllUsers", new { message = $"Link za verifikaciju naloga korisnika {user.UserName} je poslat na email adresu {user.Email}" });
*/
try
{
var resultRole = await userManager.AddToRoleAsync(user, "Instruktor");
if (!resultRole.Succeeded)
{
ModelState.AddModelError("", "Neuspešno dodavanje uloga korisniku");
return(View(model));
}
return(RedirectToAction("GetAllUsers", new { message = $"Registracija uspešno izvršena." }));
}catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
CinoviDropDownList();
ObukeDropDownList();
return(View(model));
}
public RegistrationPanel(RegistrationViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
_viewModel = viewModel;
}
public ProfilePage(RegistrationViewModel viewModel)
{
InitializeComponent();
BindingContext = this.viewModel = viewModel;
}
public async Task<ActionResult> Registration(RegistrationViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
return RedirectToAction("Confirmation");
// var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
// switch (result)
// {
// case SignInStatus.Success:
// return RedirectToLocal(returnUrl);
// default:
// ModelState.AddModelError("", "Invalid login attempt.");
// return View(model);
// }
}
public async Task <IActionResult> Register([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <ApplicationUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(
Errors.AddErrorsToModelState(result, ModelState)));
}
else
{
// TODO: figure out how to do this from userIdentity, maybe making two trips to DB
var user = await _db.Users.FirstOrDefaultAsync(x => x.Email == model.Email);
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
await _db.SaveChangesAsync();
}
else
{
return(BadRequest(ModelState));
}
// send confirmation email
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = $@"https://daebit.com/account/confirm-email/?userId={user.Id}&code={code}";
string to = model.Email;
string subject = "Welcome to Daebit!";
string content = $@"
<h2>Hello {user.FirstName} {user.LastName} </h2>
<p>Thank you for signing up with Daebit.com. To complete your registration please click the link below: </p>
<a href=""{callbackUrl}"" target=""_blank"">{callbackUrl}</a>
";
if (EmailHelper.SendEmail(new EmailHelperModel
{
Username = _config["AwsSmtpEmail:Username"],
Password = _config["AwsSmtpEmail:Password"],
WebRootPath = _env.WebRootPath,
To = to,
Subject = subject,
Content = content
}))
{
return(BadRequest(Errors.AddErrorToModelState(
"register",
"Sorry something went wrong, please try again later",
ModelState)));
}
var token = GetJwtSecurityToken(user);
return(Ok(new { token = token }));
}
}
public async Task <IActionResult> EditEmployee(RegistrationViewModel userRegVM)
{
try
{
var origionalData = _unitOfWork.Employee.GetSingleOrDefault(e => e.Id == userRegVM.ID);
if (origionalData != null)
{
//update AspNetusers Table
origionalData.DOB = Utilities.FormatDateTimeByZone(userRegVM.DOB.Value);
origionalData.DOJ = Utilities.FormatDateTimeByZone(userRegVM.DOJ.Value);
origionalData.Department = (int)userRegVM.Department;
origionalData.Desigination = (int)userRegVM.Desigination;
origionalData.Grade = (int)userRegVM.Grade;
origionalData.HQ = (int)userRegVM.HQ;
origionalData.Pancard = userRegVM.Pancard;
_unitOfWork.Employee.Update(origionalData);
//Get user
var user = await _userManager.FindByIdAsync(userRegVM.ID);
//Get claims & Remove it
var userClaims = await _userManager.GetClaimsAsync(user);
foreach (Claim claim in userClaims)
{
await _userManager.RemoveClaimAsync(user, claim);
}
//Get Roles & Remove it
var userRole = await _userManager.GetRolesAsync(user);
foreach (var role in userRole)
{
await _userManager.RemoveFromRoleAsync(user, role);
}
//Add Roles to user
IdentityRole adminUserRole = null;
if (userRegVM.Roles.RoleName.ToLower().Equals(Permissions.Roles.USER))
{
//User: Data in Roles Table
adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.USER);
if (adminUserRole == null)
{
adminUserRole = new IdentityRole(Permissions.Roles.USER);
await _roleManager.CreateAsync(adminUserRole);
}
//Add Claims to user
for (int i = 0; i <= userRegVM.Roles.RoleClaims.Length - 1; i++)
{
string roleClaims = userRegVM.Roles.RoleClaims[i].ToString();
switch (roleClaims)
{
case Permissions.RolePermission.Add:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Add));
break;
}
case Permissions.RolePermission.Edit:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Edit));
break;
}
case Permissions.RolePermission.View:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.View));
break;
}
case Permissions.RolePermission.Delete:
{
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Delete));
break;
}
default:
{
break;
}
}
}
}
else
{
//Admin: Data in Roles Table
adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.ADMIN);
if (adminUserRole == null)
{
adminUserRole = new IdentityRole(Permissions.Roles.ADMIN);
await _roleManager.CreateAsync(adminUserRole);
}
//Add Claims to Admin
await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Admins.CRUD));
}
//Add Roles to user
if (!await _userManager.IsInRoleAsync(user, adminUserRole.Name))
{
await _userManager.AddToRoleAsync(user, adminUserRole.Name);
}
//Update Contact
var origionalContactData = _unitOfWork.ContactResource.GetSingleOrDefault(
c => c.RefTableId == userRegVM.ID &&
c.RefTableName == Constants.ReferenceTableNames.EMPLOYEE);
ContactResourseViewModel contactVM = userRegVM.Contact;
origionalContactData.RefTableId = contactVM.RefTableId;
origionalContactData.RefTableName = contactVM.RefTableName;
origionalContactData.Address = contactVM.Address;
origionalContactData.State = contactVM.State;
origionalContactData.City = contactVM.City;
origionalContactData.PinCode = contactVM.PinCode;
origionalContactData.MobileNumber = contactVM.MobileNumber;
origionalContactData.ResidenceNumber = contactVM.ResidenceNumber;
_unitOfWork.ContactResource.Update(origionalContactData);
//Delete Existing Region
var HQRegionData = _unitOfWork.HQRegion.GetAll()
.Where(r => r.Hqid == userRegVM.HQ && r.UserId == userRegVM.ID);
if (HQRegionData != null)
{
_unitOfWork.HQRegion.RemoveRange(HQRegionData);
}
// Add Region according to UserID and HQ
HQRegionViewModel HQRegionVM = null;
foreach (var rgn in userRegVM.Region)
{
HQRegionVM = new HQRegionViewModel
{
HQID = userRegVM.HQ,
UserID = userRegVM.ID,
RegionID = rgn
};
var empHQRegion = mapper.Map <HQRegionViewModel, Data.Hqregion>(HQRegionVM);
_unitOfWork.HQRegion.Add(empHQRegion);
}
await _unitOfWork.CompleteAsync();
}
}
catch (Exception Ex)
{
return(new BadRequestObjectResult(Errors.AddError(Ex, ModelState)));
}
return(Ok(userRegVM));
}
public RegistrationPage()
{
InitializeComponent();
RegistrationViewModel = new RegistrationViewModel(tbFirstname, tbLastname, tbPhoneNumber, tbMail, tbUsername, pbPassword, pbConfirm, tbVerifyCode, this);
this.DataContext = RegistrationViewModel;
}
