public MainForm()
{
InitializeComponent();
outputView = new OutputView(this);
registersView = new RegisterView(this);
displayView = new DisplayView(this);
controlView = new ControlView(this);
callStackView = new CallStackView(this);
stackFrameView = new StackFrameView(this);
statusView = new StatusView(this);
symbolView = new SymbolView(this);
watchView = new WatchView(this);
breakPointView = new BreakpointView(this);
instructionView = new InstructionView(this);
methodView = new MethodView(this);
//scriptView = new ScriptView(this);
sourceView = new SourceView(this);
sourceDataView = new SourceDataView(this);
AppLocations.FindApplications();
LauncherOptions.EnableQemuGDB = true;
}
public async Task <IActionResult> Register(RegisterView model)
{
if (ModelState.IsValid)
{
User user = new User {
Email = model.Email, UserName = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await signInManager.SignInAsync(user, false);
return(RedirectToAction("Main", "Home"));
}
else
{
foreach (var a in result.Errors)
{
ModelState.AddModelError(string.Empty, a.Description);
}
}
}
return(PartialView("_Register"));
}
public ActionResult Register(RegisterView model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (!IsUsername(model.Login))
{
ModelState.AddModelError(string.Empty, "Login can only contains ENG/RUS characters, '_' symbol and digits.");
return(View(model));
}
if (db.User.Any(x => x.login == model.Login))
{
ModelState.AddModelError(string.Empty, "User with this login already exists. Please choose another login.");
return(View(model));
}
var salt = PasswordGenerator.GenerateSalt(16);
var pass = PasswordGenerator.GenerateHash(model.Password, salt, 1000, 20);
User user = new User
{
login = model.Login,
PasswordSalt = salt,
PasswordHash = pass,
Iterations = 1000
};
db.User.Add(user);
db.SaveChanges();
FormsAuthentication.RedirectFromLoginPage(model.Login, true);
return(View(model));
}
public async Task <IActionResult> Register(RegisterView result)
{
if (ModelState.IsValid)
{
var user = new User()
{
Email = result.Email, UserName = result.Login
};
var register = await _userManager.CreateAsync(user, result.Password);
if (register.Succeeded)
{
// rejestracja nowego użytkownika
// await _signInManager.SignInAsync(user, false);
// nadanie mu roli "user"
// await _userManager.AddToRoleAsync(user, "user");
return(RedirectToAction("List", "Account", new { Area = "Admin" }));
}
foreach (var error in register.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(result));
}
private void NewRegisterView(object sender, EventArgs e)
{
var t = new RegisterView("RegisterView");
t.Show(dockPanel1, WeifenLuo.WinFormsUI.Docking.DockState.Float);
myDocks.Add(t);
}
private void Registration_Click(object sender, EventArgs e)
{
var Register = new RegisterView();
this.Hide();
Register.Show();
}
public ReturnState Register(RegisterView model)
{
ReturnState outResult;
accountClient.Register(model, out outResult, out specify);
return(outResult);
}
private void RegisterButtonClick(object sender, RoutedEventArgs e)
{
RegisterView registerView = new RegisterView();
registerView.Show();
Close();
}
public IActionResult Register(RegisterAdd model)
{
if (ModelState.IsValid)
{
var staff = new Staff()
{
Address = model.Address,
DistrictId = model.DistrictId,
Email = model.Email,
Fullname = model.Fullname,
Password = model.Password,
PhoneNumber = model.PhoneNumber,
ProvinceId = model.ProvinceId,
WardId = model.WardId
};
if (staffService.CreateStaff(staff) > 0)
{
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "System error, please try again later!");
}
var registerView = new RegisterView();
return(View(registerView));
}
public async Task <IActionResult> Register(RegisterView model)
{
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser
{
Email = model.Email,
UserName = model.Email,
CreateDate = DateTime.Now,
UpdateTime = DateTime.Now
};
Customer customer = new Customer
{
FirstName = model.FirstName,
SecondName = model.SecondName,
Phone = model.Phone,
Email = model.Email
};
if (userManager.Users.Where(u => u.Email == model.Email).Count() > 0)
{
var configuration = new ConfigurationManager();
var section = configuration.Configuration.GetSection("ErrorMessages");
ViewBag.Message = section["EmailExistAlready"];
return(View("ErrorPage"));
}
var addResult = await userManager.CreateAsync(user, model.Password);
if (addResult.Succeeded)
{
if (await roleManager.FindByNameAsync("customer") == null)
{
await roleManager.CreateAsync(new IdentityRole("customer"));
}
await userManager.AddToRoleAsync(user, "customer");
await signInManager.SignInAsync(user, false);
await unitOfWork.Customers.Create(customer);
await unitOfWork.SaveAsync();
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in addResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
private void register_btn_Click(object sender, RoutedEventArgs e)
{
RegisterView registerView = new RegisterView();
registerView.Show();
this.Close();
}
public RegisterViewModel(RegisterView registerView)
{
view = registerView;
service = new ServiceClass();
User = new tblUser();
}
public ActionResult Register(RegisterView RegisterUser, HttpPostedFileBase file)
{
if (file != null)
{
User newUser = Mapper.Map <User>(RegisterUser);
var fileName = Path.GetFileNameWithoutExtension(file.FileName);
var type = Path.GetExtension(file.FileName);
var size = file.ContentLength;
//將檔案存入資料庫
var pathName = newUser.Account + type;
var path = Path.Combine(Server.MapPath("~/FileUpload"), pathName);
UserHabit newHabit = Mapper.Map <UserHabit>(RegisterUser);
_userservices.Register(newUser, fileName, type, path, size, newHabit);
//將檔案存放至實體路徑
file.SaveAs(path);
}
else
{
var fileName = "";
var path = "";
var type = "";
int size = 0;
User newUser = Mapper.Map <User>(RegisterUser);
UserHabit newHabit = Mapper.Map <UserHabit>(RegisterUser);
_userservices.Register(newUser, fileName, type, path, size, newHabit);
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> PostRegister([FromBody] RegisterView model)
{
if (ModelState.IsValid)
{
User user = new User {
Email = model.Email, UserName = model.Email
};
// добавляем пользователя
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Ok(/*new { Token = TokenHelper.GenerateToken(user) }*/));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
var errors = ModelState.Values.Select(t => t.Errors.Select(p => p.ErrorMessage));
return(BadRequest(errors));
}
public async Task <IActionResult> Register(RegisterView result)
{
// Sprawdzamy czy walidacja na modelu jest pozytywna
if (ModelState.IsValid)
{
// Tworzymy użytkownika na podstawie przesłanych danych
var user = new User()
{
UserName = result.Login, Email = result.Email
};
var callback = await _userManager.CreateAsync(user, result.Password);
if (callback.Succeeded)
{
// Logujemy użytkownika z ustawieniem aby nie był zapamiętany za pierwszym razem
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in callback.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(result));
}
public async Task <IActionResult> Register(RegisterView model)
{
if (ModelState.IsValid)
{
var user = new StoreUser {
UserName = model.email, Email = model.email, FirstName = model.firstName, LastName = model.lastName
};
var result = await userManager.CreateAsync(user, model.password);
if (result.Succeeded)
{
logger.LogInformation("User create a new account.");
if (Request.Query.Keys.Contains("ReturnUrl"))
{
return(Redirect(Request.Query["ReturnUrl"].First()));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
}
ModelState.AddModelError("", "Rejestracja nieudana!");
return(View());
}
public ActionResult Register(RegisterView model)
{
var errors = ModelState.Values.SelectMany(v => v.Errors);
var isInvited = AccountService.AuthInvitationCode(model.InvitationCode);
if (ModelState.IsValid && Session["VerificationCode"].ToString() == model.VerificationCode.ToUpper() && isInvited)
{
try
{
var userId = AccountService.CreateUser(model);
if (userId > 0)
{
AccountService.ExpireInvitationCode(model.InvitationCode);
}
var ret = AccountService.Login(model.Name, model.Password);
if (ret)
{
return(RedirectToAction("Manage", "Account", new { userName = model.Name }));
}
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
return(View(model));
}
public async Task <IActionResult> Register(RegisterView model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public MainForm()
{
InitializeComponent();
outputView = new OutputView(this);
registersView = new RegisterView(this);
displayView = new DisplayView(this);
controlView = new ControlView(this);
callStackView = new CallStackView(this);
stackFrameView = new StackFrameView(this);
//stackView = new StackView(this);
//flagView = new FlagView(this);
statusView = new StatusView(this);
symbolView = new SymbolView(this);
watchView = new WatchView(this);
breakPointView = new BreakPointView(this);
instructionView = new InstructionView(this);
methodView = new MethodView(this);
//scriptView = new ScriptView(this);
AppLocations.FindApplications();
}
public void Register(RegisterView registerUser)
{
User newUser = Mapper.Map <User>(registerUser);
DateTime today = DateTime.Today;
int age = today.Year - newUser.Birth.Year;
if (newUser.Birth > today.AddYears(-age))
{
age--;
}
Double BMI = newUser.Weight / ((newUser.Height / 100) * (newUser.Height / 100));
//HashPassword
newUser.Password = _userservice.HashPassword(newUser.Password);
newUser.Age = age;
if (newUser.Sex == "男")
{
newUser.BMR = newUser.Weight * 13.7 + newUser.Height * 5.0 - (6.8 * age) + 66;
newUser.Bodyfat = (1.2 * BMI) + (0.23 * age) - 5.4 - (10.8 * 1);
}
else if (newUser.Sex == "女")
{
newUser.BMR = newUser.Weight * 9.6 + newUser.Height * 1.8 - (4.7 * age) + 655;
newUser.Bodyfat = (1.2 * BMI) + (0.23 * age) - 5.4 - (10.8 * 0);
}
UserHabit newHabit = Mapper.Map <UserHabit>(registerUser);
_repository.Create(newUser);
newHabit.CreateTime = DateTime.Now;
_userHabitrepository.Create(newHabit);
_db.Save();
//_userservice.Register(newUser, null, null, null, 0, newHabit);, fileName, type, path, size, newHabit);
}
public ActionResult Index([Bind(Include = "Utilizador, Morada")] RegisterView registerView)
{
if (registerView != null)
{
registerView.Morada.Utilizador_email = registerView.Utilizador.email;
registerView.Utilizador.SetUser();
if (ModelState.IsValid)
{
Utilizador user = db.Utilizadors.FirstOrDefault(x => x.email == registerView.Utilizador.email);
if (user == null)
{
db.Utilizadors.Add(registerView.Utilizador);
db.Moradas.Add(registerView.Morada);
db.SaveChanges();
return(RedirectToAction("Index", "Produtoes"));
}
else
{
ModelState.AddModelError("registerView.Utilizador.email", "Email address already exists.Please enter a different email address.");
}
}
else
{
return(View(registerView));
}
}
return(RedirectToAction("Index"));
}
public void OnUserInformationReceived(OAuthLoginResponse loginResponse)
{
if (loginResponse.LoginID != authentificationToken)
{
return;
}
if (loginResponse.IsLoggedIn)
{
IsLoading = false;
AppContextSingleton.Instance.AppContext.CurrentConnectedUser = loginResponse.User;
GoToHome();
}
else
{
App.Current.Dispatcher.BeginInvoke((Action) delegate
{
var registerView = new RegisterView();
var dataContext = registerView.DataContext as RegisterViewModel;
if (dataContext != null)
{
dataContext.RegisterRequestModel.FirstName = loginResponse.User.FirstName;
dataContext.RegisterRequestModel.LastName = loginResponse.User.LastName;
dataContext.RegisterRequestModel.Email = loginResponse.User.Email;
dataContext.RegisterRequestModel.ProfileImgUrl = loginResponse.User.ProfileImgURL;
MainTransitions.TransitionPageControl.ShowPage(registerView);
}
});
}
}
public RegisterView getHabit([FromBody] PostId data)
{
UserHabit userHabit = _userservice.GetUserHabit(data.account);
RegisterView nowUser = Mapper.Map <RegisterView>(userHabit);
return(nowUser);
}
public ActionResult Register(RegisterView view)
{
if (ModelState.IsValid && repositoryAuth.getUserFromEmail(view.email) == null)
{
Users user = new Users(view.Gender)
{
Name = view.UserName,
Email = view.email,
Id = repositoryAuth.Count <Users>(),
UserPassword = view.password,
AddedDate = DateTime.Now,
LastVisitDate = DateTime.Now,
Country = view.Country,
City = view.City,
};
(repositoryAuth as IAuthecantionRepository).RegisterUser(user, "Authorized");
var User = auth.Login(view.email, view.password, false);
if (User != null)
{
return(RedirectToAction("Index", "Home"));
}
}
return(View(view));
}
public ActionResult Register(RegisterView model, string returnUrl)
{
if (Session["UserId"] != null)
{
return(RedirectToAction("Index", "Home"));
}
var emailExist = (from user in db.Users
where user.Email == model.Email.ToLower()
select user).FirstOrDefault();
if (emailExist != null)
{
ModelState.AddModelError("Email", "Email address already exists.");
}
else if (ModelState.IsValid)
{
User user = new User {
Email = model.Email.ToLower(),
UserTypeId = UserType.USER,
Password = HashFacade.Hash(model.Password)
};
db.Users.Add(user);
db.SaveChanges();
Session["UserId"] = user.Id;
Session["UserTypeId"] = UserType.USER;
return(RedirectToAction("Index", "Home"));
}
return(View("Index", model));
}
public async Task <ActionResult> Register(RegisterView model)
{
if (ModelState.IsValid)
{
var user = new User {
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));
}
private void registerButton_Click(object sender, EventArgs e)
{
RegisterView view = new RegisterView();
view.Show();
Hide();
}
public IActionResult Register(RegisterView regView)
{
if (ModelState.IsValid)
{
User user = new User();
user.UserName = regView.UserName;
user.FullName = regView.FullName;
IdentityResult result = _userManager.CreateAsync(user, regView.Password).Result;
if (result.Succeeded)
{
if (!_roleManager.RoleExistsAsync("NormalUser").Result)
{
UserRole role = new UserRole();
role.Name = "NormalUser";
role.Description = "Perform normal operations.";
IdentityResult roleResult = _roleManager.
CreateAsync(role).Result;
if (!roleResult.Succeeded)
{
ModelState.AddModelError("",
"Error while creating role!");
return(View(regView));
}
}
_userManager.AddToRoleAsync(user,
"NormalUser").Wait();
return(RedirectToAction("Login", "Account"));
}
}
return(View(regView));
}
public ActionResult Register(RegisterView view)
{
if (ModelState.IsValid)
{
try
{
_customerCreationService.Register(view);
return RedirectToAction("Confirmation");
}
catch (InvalidDomainModelException ex)
{
FillModelStateErrors(ex);
}
catch (UserAlreadyExistException)
{
ModelState.AddModelError("UserName", "El usuario ya existe.");
}
catch (EmailAlreadyExistException)
{
ModelState.AddModelError("EmailAddress", "El e-mail ya existe.");
}
catch (PasswordNotMatchException)
{
ModelState.AddModelError("Password", "Las contraseñas no son iguales.");
}
}
// Simply return our view
List<SelectListItem> lst = _internetActivityService.InternetActivityList();
ViewData["InternetActivity"] = lst;
return View(view);
}
public async Task <IActionResult> Register([FromBody] RegisterView registerView)
{
//Error list relating to User Registration
List <string> errorList = new List <string>();
//creating a new user
var user = new IdentityUser
{
Email = registerView.Email,
UserName = registerView.Username,
SecurityStamp = Guid.NewGuid().ToString()
};
var results = await _userManager.CreateAsync(user, registerView.Password);
if (results.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Customer");
//Send a confirmation email
return(Ok(new { username = user.UserName, email = user.Email, status = 1, message = "Registration is Successful" }));
}
else
{
foreach (var error in results.Errors)
{
ModelState.AddModelError("", error.Description);
errorList.Add(error.Description);
}
}
return(BadRequest(new JsonResult(errorList)));
}
public string OnRegister(string email, string user, string pass)
{
RegisterView view = new RegisterView();
Validator validator = new Validator();
// Validate the user input here.
if (!validator.Make(new string[] { email, user, pass },
new string[] { "email", "minLength:1", "minLength:8" },
new string[] { "email", "username", "password" }))
{
return view.Error(validator.GetDetail());
}
UserRepository userRepo = new UserRepository();
int result = userRepo.Register(email, user, pass, 0);
return view.Show(result);
}
public string Store(string email, string user, string pass, int mode)
{
RegisterView view = new RegisterView();
Validator validator = new Validator();
// Validate the user input here.
if (!validator.Make(new string[] { email, user, pass, mode + "" },
new string[] { "email", "required", "required", "required" },
new string[] { "email", "username", "password", "mode" }))
{
return view.Error(validator.GetDetail());
}
int result = userRepo.Register(email, user, pass, mode);
return view.Show(result);
}
private void RegisterButtonClick(object sender, RoutedEventArgs e)
{
RegisterView registerView = new RegisterView();
registerView.Show();
Close();
}
