public async Task <IActionResult> Signup([FromBody] SignupViewModel viewModel)
{
UserSignup userSignup = new UserSignup(context, viewModel.MapToUser());
await userSignup.SignupAsync();
if (userSignup.EmailAlreadyTaken)
{
return(new ErrorsJson("E-mail já cadastrado."));
}
var viewResult = viewEngine.GetView(env.ContentRootPath,
"~/Views/Emails/SignupEmail.cshtml", false);
var htmlMessage = await new MailView(ControllerContext, viewResult)
.ToHtmlAsync(new SignupEmail(userSignup.User, userSignup.ClosureRequest));
mailer.Recipients.Add(new MailRecipient(userSignup.User.Name, userSignup.User.Email));
taskHandler.ExecuteInBackground(async() =>
{
await mailer.SendAsync("Bem vindo ao gestaoaju.com.br :)", htmlMessage);
});
await HttpContext.SignInAsync(userSignup.User);
return(new UserJson(userSignup.User));
}
public ActionResult Login(UserSignup u)
{
User login = us.GetAll().Where(x => x.Login == u.Login).FirstOrDefault();
if (login is null)
{
ModelState.AddModelError(string.Empty, "le login n'existe pas connard");
return(View(u));
}
else
{
if (login.Pwd != u.Pwd)
{
ModelState.AddModelError(string.Empty, "le password ne correspond pas connard");
return(View(u));
}
else
{
Session["Actif"] = "True";
Session["Admin"] = u.IsAdmin.ToString();
}
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Createuser(UserSignup US)
{
if (ModelState.IsValid)
{
UserManager UM = new UserManager();
if (!UM.IsLoginUsercheck(US.HrEmail))
{
string loginname = HttpContext.User.Identity.Name;
if (loginname != null)
{
UM.AddUseraccount(US, loginname);
ModelState.Clear();
TempData["msg"] = "You have Create Your Comany Hr Account! Thank you.";
TempData["msg1"] = "Password Sent to Hr Mail .";
//FormsAuthentication.SetAuthCookie(US.HrEmail, false);
//return RedirectToAction("AdminOnly", "Home");
}
else
{
ModelState.AddModelError("", "Admin login not approve");
}
}
else
{
ModelState.AddModelError("", "Login Email Alredy tekan");
}
}
return(View());
}
public UserSignup Signup(string name, string email, string password)
{
var users = _copDbContext.Users;
var userSignup = new UserSignup();
if (users.SingleOrDefault(u => u.Name == name) != null)
{
userSignup.message = "Name already exists!";
}
else if (users.SingleOrDefault(u => u.Email == email) != null)
{
userSignup.message = "Email already exists!";
}
else
{
var dbNewUser = new Entities.User()
{
Name = name,
Email = email,
Password = password
};
_copDbContext.Add(dbNewUser);
_copDbContext.SaveChanges();
userSignup.user = dbNewUser;
}
return(userSignup);
}
// The Signup function calls the `dbconnections/signup` API and attempts
// to create a new user account
public void Signup(string username, string password)
{
//var client = new RestClient("https://{YOUR-AUTH0-DOMAIN}.auth0.com");
//var request = new RestRequest("dbconnections/signup", Method.POST);
//request.AddParameter("client_id", "{YOUR-AUTH0-CLIENT-ID}");
//request.AddParameter("email", username);
//request.AddParameter("password", password);
//request.AddParameter("connection", "{YOUR-DATABASE-CONNECTION-NAME");
//IRestResponse response = client.Execute(request);
// Once the request is executed we capture the response.
// If we get a `user_id`, we know that the account has been created
// and display an appropriate message. If we do not get a `user_id`
// we know something went wrong, so we ask the user if they already have
// an account and if not to try again.
//UserSignup user = JsonConvert.DeserializeObject<UserSignup>(response.Content);
var user = new UserSignup
{
user_id = "Tony"
};
if (user.user_id != null)
{
DisplayAlert("Account Created", "Head back to the hompage and login with your new account", "Ok");
}
else
{
DisplayAlert("Oh No!", "Account could not be created. Do you already have an account? Please try again.", "Ok");
}
}
public async Task <JwtResult> Signup(UserSignup userSignup)
{
// TODO: validate signup
try
{
var passwordHash = _cryptoService.Hash(userSignup.Password);
var entityEntry =
await
_dbContext.Users.AddAsync(new UserEntity
{
Username = userSignup.Username,
PasswordHash = passwordHash
}).ConfigureAwait(false);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
var userDto = entityEntry.Entity;
// TODO: mapping
var user = new User {
Id = userDto.Id, Uid = userDto.Uid.Value, Username = userDto.Username
};
var jwt = await _jwtService.MakeJwt(user);
return(jwt);
}
catch (DbUpdateException dbUpdateException)
{
throw new ConflictException(dbUpdateException.Message, dbUpdateException);
}
}
public async Task <IActionResult> CreateUser(UserSignup signedUpUser)
{
if (ModelState.IsValid)
{
User user = new User()
{
UserName = signedUpUser.Email,
Email = signedUpUser.Email,
PhoneNumber = signedUpUser.PhoneNumber
};
try
{
var result = await _userManager.CreateAsync(user, signedUpUser.Password);
if (result.Succeeded)
{
return(Ok("User has been created Sucessfully!"));
}
else
{
return(BadRequest("Error in creating User."));
}
}
catch (Exception ex)
{
throw;
}
}
return(Ok("Model State is not valid."));
}
public UserSignup Signup(Models.User user)
{
var verifyUserEmail = _loginsValidation.verifyUserEmail(user.Email);
UserSignup userSignup = new UserSignup()
{
message = verifyUserEmail.message
};
if (!verifyUserEmail.userEmailCorrect)
{
userSignup.message = verifyUserEmail.message;
}
else
{
var dbNewUser = new Entities.User()
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Password = _cipherService.Encrypt(user.Password)
};
_ffsaDbContext.Add(dbNewUser);
_ffsaDbContext.SaveChanges();
_emailsService.SendRegistrationConfirmationEmail(user.FirstName, user.Email, user.Password);
userSignup.User = dbNewUser;
}
return(userSignup);
}
public void SwapPageContent(string name)
{
switch (name)
{
case "Home":
PageContent = new Forside();
break;
case "Profil":
PageContent = new LoginUser();
break;
case "OpretBruger":
PageContent = new UserSignup();
break;
case "Search":
PageContent = new VoulenteerSearch();
break;
default:
PageContent = new Forside();
break;
}
OnPropertyChanged("PageContent");
}
public void TestSignup()
{
var client = Startup.Client;
//bad signup attempts
var badSignup = new UserSignup()
{
UserName = "******", Password = "******", DisplayName = "Anonymous"
}; //should get 'username is already used'
var faultExc = TestUtil.ExpectClientFault(() => client.Post <UserSignup, User>(badSignup, "api/signup"));
Assert.IsTrue(faultExc.Faults[0].Message.Contains("already in use"), "Expected 'username already in use' error");
// fix user name, now should get weak password
badSignup.UserName = "******";
faultExc = TestUtil.ExpectClientFault(() => client.Post <UserSignup, User>(badSignup, "api/signup"));
Assert.IsTrue(faultExc.Faults[0].Message.Contains("strength criteria"), "Expected 'weak password' error");
// good signup
var spikeSignup = new UserSignup()
{
UserName = "******", Password = "******", DisplayName = "SpikeTheDog"
};
var spike = client.Post <UserSignup, User>(spikeSignup, "api/signup");
Assert.IsNotNull(spike, "Expected Spike user object.");
//try to login
LoginAs(spikeSignup.UserName, spikeSignup.Password);
Logout();
}
public object PostAuth(UserSignup data)
{
string userEmail = data.UserEmail;
if (userRepository.CheckIfExists(userEmail))
{
return(new
{
message = "User Exists",
success = false
});
}
string message = "User Created";
object json;
bool registered = userRepository.CreateUser(data, ref message);
json = new
{
message = message,
success = registered
};
return(json);
}
public UserSignup Signup(Entities.User user)
{
var users = _FocusDbContext.Users;
var userSignup = new UserSignup();
if (users.SingleOrDefault(u => u.Name == user.Name) != null)
{
userSignup.message = "Name already exists!";
}
else
{
var dbNewUser = new Entities.User()
{
Name = user.Name,
Password = _cipherService.Encrypt(user.Password),
Email = user.Email,
Avatar = ""
};
_FocusDbContext.Add(dbNewUser);
_FocusDbContext.SaveChanges();
userSignup.user = dbNewUser;
}
return(userSignup);
}
public ActionResult LoginSignup(User user)
{
ViewBag.Message = "Signup for Libratica";
//If form has valid input, create user.
if (ModelState.IsValid)
{
UserSignup.CreateUser(user.user_name, user.user_age, user.user_address, user.user_zipcode, user.user_mail, user.user_confirmmail, user.user_password, user.user_confirmpassword);
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult UserAdd(UserSignup u)
{
if (ModelState.IsValid)
{
us.Create(u.ToGlobal());
return(RedirectToAction("Index", "Home"));
}
else
{
return(View());
}
}
public async Task <IActionResult> Signup([FromBody] UserSignup userSignup)
{
try
{
var jwtResult = await _authService.Signup(userSignup).ConfigureAwait(false);
return(Ok(jwtResult));
}
catch (ConflictException conflictException)
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
}
public async Task <string> signUp()
{
String body;
using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
{
body = await reader.ReadToEndAsync();
}
UserSignup user = JsonConvert.DeserializeObject <UserSignup>(body);
return(user.email);
}
private void btnSignUp_Click(object sender, RoutedEventArgs e)
{
string password = PasswordBox.Password;
string repassword = RePasswordBox.Password;
if (password.Equals(repassword))
{
string user = usernameBox.Text.Trim();
if (!user.Equals(""))
{
//chưa authorized
string fullname = fullnameBox.Text;
UserSignup signup = new UserSignup()
{
FullName = fullname,
Password = password,
Username = user,
Avatar = 0
};
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(Ultis.Ultils.url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.PostAsJsonAsync("/api/Users/Register", signup).Result;
if (response.IsSuccessStatusCode)
{
LoginWindown windown = new LoginWindown();
windown.SetAccount(user, password);
windown.Show();
this.Close();
}
else
{
_404Mess mess = response.Content.ReadAsAsync <_404Mess>().Result;
ErrLable.Content = mess.Message;
}
}
}
else
{
ErrLable.Content = "Username not empty";
}
}
else
{
ErrLable.Content = "Password is not match";
}
}
/////if the hr or particulaer person register.
public void AddUseraccount(UserSignup US, string LoginName)
{
using (RecrutmentsysEntities db = new RecrutmentsysEntities())
{
COMPANY_REGISTER_REFRENCES CRF = db.COMPANY_REGISTER_REFRENCES.Where(o => o.CompanyEmailRef.Equals(LoginName)).FirstOrDefault();
COMPANY_HR_REGISTER CHR = new COMPANY_HR_REGISTER();
CHR.CompanyId = CRF.CompanyId;
CHR.HrName = US.HrName;
CHR.HrContact = US.HrContact;
CHR.HrEmail = US.HrEmail;
db.COMPANY_HR_REGISTER.Add(CHR);
db.SaveChanges();
string password = RandomString(8);
COMPANY_REGISTER_REFRENCES CRR = new COMPANY_REGISTER_REFRENCES();
CRR.CompanyId = CHR.CompanyId;
CRR.CompanyEmailRef = US.HrEmail;
CRR.CompanyPassword = password;
CRR.CompanyType = "Other";
db.COMPANY_REGISTER_REFRENCES.Add(CRR);
db.SaveChanges();
using (MailMessage mm = new MailMessage())
{
mm.To.Add(new MailAddress(US.HrEmail));
mm.From = new MailAddress("*****@*****.**");
mm.Subject = "Your Password Genrated for by Admin!";
mm.Body = "This email create is company use of term and condition <br/> Your Email:- " + US.HrEmail + " <br/> you Password:-" + password + " ";
mm.IsBodyHtml = true;
using (SmtpClient smtp = new SmtpClient())
{
smtp.Host = "smtp.gmail.com";
smtp.EnableSsl = true;
NetworkCredential networkcred = new NetworkCredential("*****@*****.**", "connectists@57confuse");
smtp.UseDefaultCredentials = true;
smtp.Credentials = networkcred;
smtp.Port = 587;
smtp.Send(mm);
}
}
}
}
public IActionResult Signup([FromBody] UserSignup signupForm)
{
if (_context.Users.Any(u => u.UserName == signupForm.UserName))
{
return(BadRequest("Username is busy"));
}
string hashedPassword = GetHash(signupForm.Password);
_context.Users.Add(new User
{
UserName = signupForm.UserName,
Name = signupForm.Name,
Password = hashedPassword,
});
_context.SaveChanges();
return(Ok());
}
private void btUpdateAvatar_Click(object sender, RoutedEventArgs e)
{
string path = ImageSupportInstance.getInstance().OpenChooseImageDialogBox();
if (!path.Equals(""))
{
Resource res = ImageSupportInstance.getInstance().UploadImage(path, 360, 360);
User currentuser = AppInstance.getInstance().GetUser();
currentuser.Avatar = res.Id;
AppInstance.getInstance().SetUser(currentuser);
UserSignup user = new UserSignup()
{
Avatar = currentuser.Avatar,
FullName = currentuser.FullName,
Password = null,
Username = null
};
using (HttpClient client = new HttpClient())
{
string url = Ultils.getUrl();
client.BaseAddress = new Uri(url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AppInstance.getInstance().GetUser().Token);
HttpResponseMessage response = client.PutAsJsonAsync("/api/Users/Owner", user).Result;
if (response.IsSuccessStatusCode)
{
UpdateIconEventhandler(this, new EventArgs());
}
else
{
_404Mess mess = response.Content.ReadAsAsync <_404Mess>().Result;
System.Windows.MessageBox.Show(mess.Message);
}
}
}
}
public async Task <IActionResult> Register(UserSignup register)
{
if (ModelState.IsValid)
{
User user = new User()
{
//UserName = register.FirstName,
Email = register.Email,
PhoneNumber = register.PhoneNumber,
};
var result = await _userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
//Add AppUser
return(Ok("User has been created Sucessfully!"));
}
else
{
return(BadRequest("Error in creating User."));
}
}
return(Ok("Model State is not valid."));
}
public ActionResult UserEdit(UserSignup u)
{
us.UpdateDroits(u.ToGlobal());
return(RedirectToAction("User"));
}
public ActionResult UserEdit(int id)
{
UserSignup u = us.GetOne(id).ToLocal();
return(View(u));
}
