public async Task SignupUserLogicMissingEntry()
{
var data = new LoginDataHandler();
var logic = new CoreApiLogicHandler();
var cloud = new FakeCloudHandler();
var viewModel = LoginData.GetSignup();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(null);
var command = new SignupUser
{
DataHandler = data,
CloudHandler = cloud,
LogicHandler = logic,
Input = viewModel,
Result = ActionConfirm.CreateFailure("Failed")
};
await command.Execute();
command.Result.Success.Should().BeFalse();
logic.HasExecuted.Should().BeFalse();
logic.Result.Verify(s => s.Execute(It.IsAny <SimpleNotify>()), Times.Never());
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Once());
data.Result.Verify(s => s.Execute(It.IsAny <UserSave>()), Times.Never());
}
public static SignupUser GetSignupUser(SignupUser user)
{
using (SqlConnection sqlCon = con)
{
sqlCon.Open();
SqlCommand cmd = new SqlCommand("GetSignupUser", sqlCon);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Username", user.Username);
cmd.Parameters.AddWithValue("@Password", SharedSupport.MD5Encrypt(user.Password));
SqlDataReader dr = cmd.ExecuteReader();
if (dr.HasRows)
{
dr.Read();
return(new SignupUser
{
Id = Convert.ToInt32(dr[1]),
Username = dr[2].ToString(),
Gender = dr[4].ToString(),
Age = Convert.ToInt32(dr[5]),
});
}
}
return(null);
}
public ActionResult Register(SignupUser objUser)
{
if (ModelState.IsValid)
{
var salt = SaltHelper.GetSalt();
User addObj = new User();
addObj.EmailAddress = objUser.EmailId;
var hashPassword = SaltHelper.GenerateHash(objUser.Password, salt);
addObj.Password = hashPassword;
addObj.Salt = salt;
//REGISTER PROCESS
var conn_str = ConfigurationManager.AppSettings["connectionString"];
DBHelper dbObj = new DBHelper(conn_str);
var is_present = dbObj.GetUser(objUser.EmailId);
if (is_present == null)
{
dbObj.AddUser(addObj);
return(RedirectToAction("Login", "Authenticate"));
}
}
ModelState.AddModelError("", "User is already present");
return(View("Signup", objUser));
}
// Methods
internal static SignupUser FilterSignupUser(SignupUser user)
{
string username = user.Username.Trim();
username = username[0].ToString().ToUpper() + username.Substring(1);
if (!IsUsernameValid(username))
{
return(null);
}
int id = new Random().Next(9999, 99999);
while (DBSupport.IsSignupIdExist(id))
{
id = new Random().Next(9999, 99999);
}
return(new SignupUser
{
Id = id,
Username = username,
Password = user.Password,
Gender = !string.IsNullOrEmpty(user.Gender) ? user.Gender : string.Empty,
Age = user.Age,
});
}
public async Task <IActionResult> Post([FromBody] SignupViewModel viewModel)
{
var query = new UserByEmail {
Email = viewModel.Email
};
await DataHandler.Execute(query);
if (query.Result == null)
{
var signup = new SignupUser()
{
DataHandler = DataHandler,
Input = viewModel,
LogicHandler = LogicHandler,
CloudHandler = CloudHandler
};
await LogicHandler.Execute(signup);
return(Ok(signup.ResultAuth));
}
return(Ok(new FailViewModel {
Message = "Email already in use"
}));
}
public async Task SignupUserLogic()
{
var data = new SignupDataHandler();
var logic = new CoreApiLogicHandler();
var cloud = new FakeCloudHandler();
var tenant = TenantData.GetFirst();
var viewModel = LoginData.GetSignup();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(tenant);
data.Result.Setup(m => m.Execute(It.IsAny <UserSave>())).Returns(StandardUser);
logic.Result.Setup(m => m.Execute(It.IsAny <SimpleNotify>())).Returns(ActionConfirm.CreateSuccess("Worked"));
var command = new SignupUser
{
DataHandler = data,
CloudHandler = cloud,
LogicHandler = logic,
Input = viewModel
};
await command.Execute();
logic.HasExecuted.Should().BeTrue();
logic.Result.Verify(s => s.Execute(It.IsAny <SimpleNotify>()), Times.Once());
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Once());
data.Result.Verify(s => s.Execute(It.IsAny <UserSave>()), Times.AtLeastOnce());
}
public async Task <IdentityResult> CreateNewUser(SignupUser newUser)
{
//userManager.PasswordHasher = new PasswordHasher();
AppUser user = new AppUser
{
UserName = newUser.UserName.Trim(),
Email = newUser.Email.Trim(),
PhoneNumber = newUser.PhoneNumber.Trim(),
/*FirstName = newUser.FirstName.Trim(),
* LastName = newUser.LastName.Trim(),
* DoB = newUser.DoB,
* Sex = newUser.Sex.ToUpper().Trim(),
* DateCreated = DateTime.Now*/
};
IdentityResult identityResult = await userManager.CreateAsync(user, newUser.Password);
if (identityResult.Succeeded)
{
var signupuser = new User(newUser.FirstName.Trim(), newUser.LastName.Trim(), newUser.UserName.Trim(), newUser.DoB, newUser.Sex.ToUpper().Trim(), user.Id);
_appDbContext.Users.Add(signupuser);
await _appDbContext.SaveChangesAsync();
}
return(identityResult);
}
public static bool IsSignupUserExist(SignupUser user)
{
using (SqlConnection sqlCon = con)
{
sqlCon.Open();
SqlCommand cmd = new SqlCommand("IsSignupUserExist", sqlCon);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Username", user.Username);
return(Convert.ToInt32(cmd.ExecuteScalar()) == 0 ? false : true);
}
}
public async Task <ActionResult> Signup([FromBody] SignupUser newUser)
{
_logger.LogInfo($"User signup initiated. Username: {newUser.UserName}");
if (!ModelState.IsValid)
{
_logger.LogInfo("User signup. ModelState invalid. A validation condition is not met.");
return(BadRequest(ModelState));
}
if (!newUser.Sex.Trim().ToUpper().Equals("M") && !newUser.Sex.ToUpper().Trim().Equals("F"))
{
// return BadRequest(new { error = "Sex must be M or F." });
_logger.LogInfo("Sex must be M or F.");
return(BadRequest(new {
errors = new {
sex = new string[] { "Sex must be M or F." }
}
}));
}
try
{
IdentityResult identityResult = await userStore.CreateNewUser(newUser);
if (identityResult.Succeeded)
{
_logger.LogInfo($"User created. Username: {newUser.UserName}. User: {newUser}");
return(Ok(new
{
status = StatusCodes.Status200OK,
message = "User successfully created."
}));
}
else
{
IEnumerable <IdentityError> errs = identityResult.Errors;
_logger.LogInfo($"{@errs}");
return(BadRequest(errs));
}
}
catch (Exception ex)
{
/* return BadRequest(new {
* statusCode = StatusCodes.Status500InternalServerError,
* errorMessage = ex.Message
* });*/
_logger.LogError($"Error: {ex.Message}");
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public ActionResult SignUp(SignupUser user)
{
if (!ModelState.IsValid)
{
return(View());
}
if (_userMgr.SignUp(user))
{
Session["user"] = user.UserName;
return(View("Welcome"));
}
ModelState.AddModelError("unavailable", "The user name or email address has already existed!");
return(View());
}
public string UserSignup(SignupUser data)
{
SignupUser filteredSignupUser = SharedSupport.FilterSignupUser(data);
if (DBSupport.IsSignupUserExist(filteredSignupUser))
{
return(usernameExists.Replace("username", data.Username));
}
else if (DBSupport.SignupNewUser(filteredSignupUser))
{
return("True");
}
return("False");
}
public string UserForm(SignupUser data)
{
SignupUser user = DBSupport.GetSignupUser(data);
if (user == null)
{
return(invalidUsername);
}
else
{
ChatUser chatUser = new ChatUser {
Id = user.Id, IsMod = 0, Username = user.Username, Gender = user.Gender, Age = user.Age
};
return(JsonConvert.SerializeObject(chatUser));
}
}
//MARK:Action
private void submitButton_Click(object sender, EventArgs e)
{
Boolean isSuccessValidate;
newUser = new User(usernameTextbox.Text, codeTextbox.Text);
//check whether the input info is legal
if (newUser.username == "")
{
MessageBox.Show("用户名不得为空！");
return;
}
if (newUser.password == "")
{
MessageBox.Show("密码不得为空！");
return;
}
if (userPicturebytes == null)
{
MessageBox.Show("请选择您的头像");
return;
}
if (isChangeUserInfo || isRegister)
{
//register user
if (isChangeUserInfo)
{
newUser.cmd = "3";
}
//isSuccessValidate = client.register(newUser);
newUser.saveUserInfo(rememberCodeCheckBox.Checked, autoSignCheckBox.Checked);
}
else //when user choose to sign up
{
SignupUser user = new SignupUser(uid, codeTextbox.Text);
//isSuccessValidate = client.register(user);
//if (isSuccessValidate)
{
newUser.saveUserInfo(rememberCodeCheckBox.Checked, autoSignCheckBox.Checked);
}
}
//if (isSuccessValidate)
{
mainForm mf = new mainForm();
mf.Show();
this.Hide();
}
}
public static bool SignupNewUser(SignupUser user)
{
using (SqlConnection sqlCon = con)
{
sqlCon.Open();
SqlCommand cmd = new SqlCommand("SignupNewUser", sqlCon);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@ID", user.Id);
cmd.Parameters.AddWithValue("@Username", user.Username);
cmd.Parameters.AddWithValue("@Password", SharedSupport.MD5Encrypt(user.Password));
cmd.Parameters.AddWithValue("@Gender", user.Gender);
cmd.Parameters.AddWithValue("@Age", user.Age);
return(Convert.ToInt32(cmd.ExecuteScalar()) == 1 ? true : false);
}
}
public bool SignUp(SignupUser user)
{
if (UserNameExists(user.UserName) || EmailExists(user.Email))
{
return(false);
}
try
{
_ctx.KhachHangs.Add(new KhachHang
{
UserName = user.UserName,
Password = Utility.GetMd5Hash(user.Password),
Email = user.Email,
SDT = user.PhoneNumber,
});
_ctx.SaveChanges();
}
catch
{
return(false);
}
return(true);
}
public SignUpData(SignupUser user)
{
this.user = user;
}
public async Task <ActionResult <UserLogin> > SignupUser([FromBody] SignupUser user)
{
UserLogin newUser = new UserLogin();
using (var trans = _context.Database.BeginTransaction())
{
try
{
if (user.IsClient)
{
if (!_context.ClientMasters.Any(d => d.ClientName == user.Username))
{
ClientMaster cl = new ClientMaster();
//cl.ClientName = user.Username;
cl.ClientName = user.Firstname + " " + user.Lastname;
cl.Email = user.Email;
cl.ClientNumber = user.Number;
cl.CreatedDateTime = DateTime.Now;
_context.ClientMasters.Add(cl);
await _context.SaveChangesAsync();
//ClientMaster newClient = CreatedAtAction("GetClient", new { ClientID = client.clientMaster }, client);
if (!_context.UserLogins.Any(d => d.Username == user.Username))
{
newUser.Username = user.Username;
newUser.Password = user.Password;
newUser.UserType = 2;
newUser.ClientID = cl.ClientID;
newUser.Active = user.IsActive;
newUser.CreatedDateTime = DateTime.Now;
_context.UserLogins.Add(newUser);
await _context.SaveChangesAsync();
}
}
}
else
{
if (!_context.Members.Any(d => d.MemberName == user.Username))
{
MemberMaster me = new MemberMaster();
me.MemberName = user.Firstname + " " + user.Lastname;
me.Email = user.Email;
me.Number = user.Number;
me.CreatedDateTime = DateTime.Now;
_context.Members.Add(me);
await _context.SaveChangesAsync();
//ClientMaster newClient = CreatedAtAction("GetClient", new { ClientID = client.clientMaster }, client);
if (!_context.UserLogins.Any(d => d.Username == user.Username))
{
newUser.Username = user.Username;
newUser.Password = user.Password;
newUser.UserType = 4;
newUser.MemberID = me.MemberID;
newUser.CreatedDateTime = DateTime.Now;
_context.UserLogins.Add(newUser);
await _context.SaveChangesAsync();
}
}
}
trans.Commit();
}
catch (Exception err)
{
trans.Rollback();
}
}
return(newUser);
}
private SignUp CreateSignupEvent(RegisterViewModel model)
{
var signupAddress = new AddressDetails
{
FirstName = model.User.FirstName,
LastName = model.User.LastName,
PhoneNumber = model.User.Phone,
Street1 = model.Address.Address1,
Street2 = model.Address.Address2,
City = model.Address.City,
State = model.Address.State,
ZipCode = model.Address.ZipCode,
Country = model.Address.CountryRegion
};
var signupUser = new SignupUser
{
CreationDate = DateTimeOffset.Now,
UpdateDate = DateTimeOffset.Now,
FirstName = model.User.FirstName,
LastName = model.User.LastName,
Country = model.Address.CountryRegion,
ZipCode = model.Address.ZipCode,
TimeZone = new TimeSpan(0, 0, -model.DeviceFingerPrinting.ClientTimeZone, 0).ToString(),
Language = "EN-US",
PhoneNumber = model.User.Phone,
Email = model.User.Email,
ProfileType = UserProfileType.Consumer.ToString(),
Address = signupAddress
};
var deviceContext = new DeviceContext
{
DeviceContextId = _contextAccessor.GetSessionId(),
IPAddress = _contextAccessor.HttpContext.Connection.RemoteIpAddress.ToString(),
Provider = DeviceContextProvider.DFPFingerPrinting.ToString(),
};
var marketingContext = new MarketingContext
{
Type = MarketingType.Direct.ToString(),
IncentiveType = MarketingIncentiveType.None.ToString(),
IncentiveOffer = "Integrate with Fraud Protection"
};
var storefrontContext = new StoreFrontContext
{
StoreName = "Fraud Protection Sample Site",
Type = StorefrontType.Web.ToString(),
Market = "US"
};
var signupEvent = new SignUp
{
SignUpId = Guid.NewGuid().ToString(),
AssessmentType = AssessmentType.Protect.ToString(),
User = signupUser,
MerchantLocalDate = DateTimeOffset.Now,
CustomerLocalDate = model.DeviceFingerPrinting.ClientDate,
MarketingContext = marketingContext,
StoreFrontContext = storefrontContext,
DeviceContext = deviceContext,
};
return(signupEvent);
}
public IHttpActionResult /*HttpResponseMessage*/ Post(SignupBindingModel model)
{
bool isValid = true;
ErrorsSignupBindingModel errors = new ErrorsSignupBindingModel();
if (string.IsNullOrEmpty(model.UserName))
{
errors.username = "******";
isValid = false;
}
if (string.IsNullOrEmpty(model.Email))
{
errors.email = "This field is required";
isValid = false;
}
try
{
MailAddress emailAddress = new MailAddress(model.Email);
}
catch
{
errors.email = "Email is invalid";
isValid = false;
}
if (string.IsNullOrEmpty(model.Password))
{
errors.password = "******";
isValid = false;
}
if (!model.Password.Equals(model.PasswordConfirmation))
{
errors.passwordConfirmation = "Passwords must match";
isValid = false;
}
if (string.IsNullOrEmpty(model.Timezone))
{
errors.timezone = "This field is required";
isValid = false;
}
SignupResultModel result = new SignupResultModel
{
errors = errors,
isValid = isValid
};
if (!isValid)
{
return(Content(HttpStatusCode.BadRequest, result));
}
//return Request.CreateResponse(HttpStatusCode.BadRequest, result);
HttpClient client = new HttpClient();
string jsonObject = JsonConvert.SerializeObject(new
{
Email = model.Email,
Password = model.Password,
ConfirmPassword = model.Password
});
var request = HttpContext.Current.Request;
var url = request.Url.GetLeftPart(UriPartial.Authority) +
request.ApplicationPath + "/api/Account/Register";
var content = new StringContent(jsonObject, Encoding.UTF8, "application/json");
var response = client.PostAsync(url, content).Result;
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(Content(HttpStatusCode.BadRequest, result));
}
ICryptoService cryptoService = new PBKDF2();
//save this salt to the database
string salt = cryptoService.GenerateSalt();
//save this hash to the database
string hashedPassword = cryptoService.Compute(model.Password);
SignupUser signup = new SignupUser
{
Email = model.Email,
Password = hashedPassword,
PasswordSalt = salt,
Timezone = model.Timezone,
UserName = model.UserName
};
try
{
using (ApplicationDbContext context = new ApplicationDbContext())
{
context.SignupUser.Add(signup);
context.SaveChanges();
return(Content(HttpStatusCode.OK, new { success = true }));
}
}
catch (Exception ex)
{
return(Content(HttpStatusCode.InternalServerError, new { error = ex }));
}
//return Request.CreateResponse(HttpStatusCode.OK, new { success=true });
}
public SignUpData(string email, string password)
{
this.user = new SignupUser(email, password);
}
public SignupViewModel()
{
signupUser = new SignupUser();
}
