protected void submitButton_Click(object sender, EventArgs e)
{
using (var timer = new FunctionTimer("Registration submiteButton_Click", x => timerLabel.Text = x))
{
var msg = new RegisterUser(CombGuid.Generate(), inputName.Text, inputUsername.Text, inputPassword.Text, inputEmail.Text);
DomainContext.Publish(msg);
((TulsaTechFest) Master).SetNotice("Thanks! You should receive an email shortly.");
submitButton.Enabled = false;
}
}
/// <summary>
/// Register worlref user
/// </summary>
/// <param name="signModel"></param>
/// <returns></returns>
public string Add(SignUpWorldRefModel signModel)
{
string ReturnStatus = "Success";
string UserRole = "W";
try
{
RegisterUser register = new RegisterUser()
{
UserFirstName = signModel.Name,
Company = signModel.Name,
Type = signModel.Type,
Email = signModel.Email,
phone = signModel.ContactNumber,
Industries = signModel.Industry,
OfficialNumber=signModel.OfficialNumber,
CountryName = signModel.Country.ToString(),
BusinessInterestCountry = signModel.BusinessInterestCountry.ToString(),
ProfileAttach = signModel.ProfilePath,
PhotoAttach = signModel.ProfileFileName,
UserNo = signModel.UserName,
Password = signModel.Password,
UserRole = UserRole,
UploaderType=signModel.UploaderType,
OrganisationName=signModel.OrganisationName,
BussinessUnitName=signModel.BusinessUnitName,
MyCompany=signModel.MyCompany,
RecoveryMail=signModel.RecoveryMail,
OtherMail = signModel.OtherMail,
ProfileUrl = signModel.ProfileUrl,
ProfileLanguageID = Convert.ToInt16(signModel.Language),
Date = DateTime.Now
};
context.RegisterUsers.Add(register);
context.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
return ReturnStatus;
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session["userid"] != null)
{
Response.Redirect("Home.aspx");
}
if(IsPostBack)
lbl_message.Text = "";
rg = new RegisterUser();
}
// POST: /api/register
public HttpResponseMessage Post(RegisterUser user)
{
/* Make sure that NewUser entity has all the required DataAnnotation attributes for validation purposes. */
if (!this.ModelState.IsValid)
{
return this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, this.ModelState);
}
/* Some additional validation */
bool isUserNameUnique, isEmailUnique;
this.db.Users.CheckUniqueness(user.UserName, user.Email, out isUserNameUnique, out isEmailUnique);
if (isUserNameUnique)
{
this.ModelState.AddModelError("UserName", string.Format("A user with username '{0}' is already registered.", user.UserName));
}
if (isEmailUnique)
{
this.ModelState.AddModelError("Email", string.Format("A user with email '{0}' is already registered.", user.Email));
}
if (!this.ModelState.IsValid)
{
return this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, this.ModelState);
}
/* Validation passed. Create a new user record */
var newUser = this.db.Users.Add(user.UserName, user.Email, user.Password, user.DisplayName);
this.db.SaveChanges();
this.formsAuth.SetAuthCookie(newUser.UserName, true);
return this.Request.CreateResponse(
HttpStatusCode.Created,
new
{
UserName = newUser.UserName,
Email = newUser.Email,
EmailHash = newUser.EmailHash,
DisplayName = newUser.DisplayName
});
}
//function to check if user is valid or not
public RegisterUser IsValidUser(RegisterUser theuser)
{
using (var dataContext = new RegLoginConstring())
{
//Retrieving the user details from db based on username and password enetered by the user
RegisterUser user = dataContext.RegisterUsers.Where(query => query.Email.Equals(theuser.Email) && query.Password.Equals(theuser.Password)).SingleOrDefault();
//if user is present, then true is returned.
if (user == null)
{
return(null);
}
//if user is not present false is returned.
else
{
return(user);
}
}
}
public static async Task <bool> RegisterPostRequest(string email, string password)
{
RegisterUser registerUser = new RegisterUser {
Email = email, Password = password
};
// TODO: extract this logic
string json = JsonSerializer.Serialize(registerUser);
var data = new StringContent(json, Encoding.UTF8, Instance.MediaType);
var response = await Client.GetInstance().PostAsync(Instance.Register, data);
if (!response.IsSuccessStatusCode)
{
return(false);
}
return(await LoginPostRequest());
}
public IActionResult RegisterCustomer(RegisterUser user)
{
Customer cust = new Customer();
cust.Name = user.Name;
cust.Address = user.Address;
cust.PostalCode = user.PostalCode;
cust.Phone = user.Phone;
cust.City = user.City;
cust.Username = user.Username;
cust.Email = user.Email;
cust.Points = 0;
cust.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
_context.Customer.Add(cust);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// A method that should be overridden to actually add data to the context for seeding.
/// The default implementation does nothing.
/// </summary>
/// <param name="context">The context to seed.</param>
protected override void Seed(LibraryContext context)
{
RegisterUser testUser = new RegisterUser("TestUser", "filler_password", "filler_salt");
SudokuPuzzle testPuzzle = new SudokuPuzzle();
testPuzzle.CompletedPuzzle(true);
context.RegisterUsers.Add(testUser);
context.SudokuPuzzles.Add(testPuzzle);
RegisterUser testUser2 = new RegisterUser("TestUser2", "filler_password", "filler_salt");
SudokuPuzzle testPuzzle2 = new SudokuPuzzle(true);
context.RegisterUsers.Add(testUser2);
context.SudokuPuzzles.Add(testPuzzle2);
base.Seed(context);
}
public IActionResult Email(int RecipeId)
{
RegisterUser fromLogin = HttpContext.Session.GetObjectFromJson <RegisterUser>("LoggedInUser");
Recipe Recipe = dbContext.Recipes.FirstOrDefault(r => r.RecipeId == RecipeId);
try
{
MailMessage mail = new MailMessage();
SmtpClient SmtpServer = new SmtpClient("smtp.gmail.com");
mail.From = new MailAddress("*****@*****.**");
mail.To.Add($"{fromLogin.Email}");
mail.Subject = $"Your Recipe for {Recipe.RecipeName}!";
mail.Body = "<h1>The Recipe You Requested:<h1>" +
$"<h2>{Recipe.RecipeName}</h2>" +
"<br>" +
// $"<img style=\"width: 200px; height: 200px;\" src=\"{Recipe.RecipeImage}\"/>"+
$"<img style=\"width: 200px; height: 200px;\" src=\"{Recipe.RecipeImage}\"/>" +
"<br>" +
$"<h5>This Recipe takes {Recipe.RecipeDuration} Minutes</h5>" +
"<br>" +
$"<h5>View More Details on this Recipe: <a href=\"http://*****:*****@gmail.com", "password@123!");
SmtpServer.EnableSsl = true;
SmtpServer.Send(mail);
return(RedirectToAction("Main"));
}
catch (Exception)
{
return(RedirectToAction("Main"));
}
}
public int Insert(RegisterUser model)
{
// return to later if I have time to check for already registered emails
//LoginUser loginModel = GetSalt(userModel.Email);
//if (loginModel == null)
int userId = 0;
string salt;
string passwordHash;
string password = model.BasicPass;
salt = cryptsvc.GenerateRandomString(RAND_LENGTH);
passwordHash = cryptsvc.Hash(password, salt, HASH_ITERATION_COUNT);
model.Salt = salt;
model.EncryptedPass = passwordHash;
//DB provider call to create user and get us a user id
//be sure to store both salt and passwordHash
//DO NOT STORE the original password value that the user passed us
using (SqlConnection conn = new SqlConnection(sqlConnectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand("Users_Insert", conn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Email", model.Email);
cmd.Parameters.AddWithValue("@Salt", model.Salt);
cmd.Parameters.AddWithValue("@HashPass", model.EncryptedPass);
SqlParameter parm = new SqlParameter("@Id", SqlDbType.Int);
parm.Direction = ParameterDirection.Output;
cmd.Parameters.Add(parm);
cmd.ExecuteNonQuery();
userId = (int)cmd.Parameters["@Id"].Value;
}
conn.Close();
}
return(userId);
}
public IActionResult CreateRecipe(AddWrapper fromForm)
{
RegisterUser fromLogin = HttpContext.Session.GetObjectFromJson <RegisterUser>("LoggedInUser");
if (ModelState.IsValid)
{
dbContext.Add(fromForm.Recipe);
dbContext.SaveChanges();
// Recipe Recipe = dbContext.Recipes
// .Include(r => r.IngredientList)
// .Include(r => r.StepList)
// .Last();
//TODO: make .Last() work in previous version *****************************************
List <Recipe> RecipeList = dbContext.Recipes
.Include(r => r.IngredientList)
.Include(r => r.StepList)
.ToList();
Recipe Recipe = null;
foreach (var r in RecipeList)
{
if (r.RecipeId == fromForm.Recipe.RecipeId)
{
Recipe = r;
}
}
;
EditWrapper EditWrapper = new EditWrapper();
EditWrapper.RegisterUser = fromLogin;
EditWrapper.Recipe = Recipe;
return(View("EditRecipe", EditWrapper));
}
else
{
AddWrapper AddWrapper = new AddWrapper();
AddWrapper.RegisterUser = fromLogin;
return(View("AddRecipe", AddWrapper));
}
}
//function to check if User is valid or not
public RegisterUser IsValidUser(LoginViewModel model)
{
//using (var dataContext = new LoginRegistrationInMVCEntities())
using (DBModel db = new DBModel())
{
//Retireving the user details from DB based on username and password enetered by user.
//RegisterUser user = db.RegisterUsers.Where(query => query.Email.Equals(model.Email) && query.Password.Equals(model.Password)).SingleOrDefault();
RegisterUser user = db.RegisterUsers.Where(query => query.Email.Equals(model.Email) && query.Password.Equals(model.Password)).FirstOrDefault();
//If user is present, then true is returned.
if (user == null)
{
return(null);
}
//If user is not present false is returned.
else
{
return(user);
}
}
}
public async Task <IActionResult> Register(RegisterUser user)
{
var userIdentity = new ApplicationUser {
UserName = user.Username
};
var result = await _userManager.CreateAsync(userIdentity, user.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(userIdentity, isPersistent : false);
return(RedirectToAction("RegisterCustomer", "Home", user));
}
var model = new RegisterUser();
model.ErrorMessage = "The password must be at least 8 characters and include a capital letter, a number and a special character.";
return(View("Register", model));
}
protected void Page_Load(object sender, EventArgs e)
{
//if (!User.IsInRole("SysAdmin"))
//{
// Response.Redirect("~/AccessDenied.aspx", true);
//}
if (!Page.IsPostBack)
{
// Reference the SpecifyRolesStep WizardStep
WizardStep SpecifyRolesStep = RegisterUser.FindControl("SpecifyRolesStep") as WizardStep;
// Reference the RoleList CheckBoxList
CheckBoxList RoleList = SpecifyRolesStep.FindControl("RoleList") as CheckBoxList;
// Bind the set of roles to RoleList
RoleList.DataSource = Roles.GetAllRoles();
RoleList.DataBind();
}
}
public IActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
RegisterUser NewUser = new RegisterUser
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Password = model.Password
};
RegisterUser(NewUser);
return(RedirectToAction("Dashboard"));
}
else
{
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Registers the user.
/// </summary>
/// <param name="user">The user.</param>
/// <returns></returns>
public async Task <bool> RegisterUserAsync(RegisterUser user)
{
StringContent content = await JsonSerializeAsync(user);
if (content == null)
{
return(false);
}
HttpResponse response = await PostRequestAsync($"api/RegisterUsers/{user.UserId}", content);
if (response.StatusCode == 201)
{
return(true);
}
else
{
return(false);
}
}
public async Task <IActionResult> Register(RegisterUser user)
{
user.Username = user.Username.ToLower();
if (await repository.UserExists(user.Username))
{
return(BadRequest("A user with the same username already exists"));
}
var toRegister = new User {
Firstname = user.Firstname,
Lastname = user.Lastname,
EmailAddress = user.EmailAddress,
Username = user.Username
};
await repository.Register(toRegister, user.Password);
return(Ok(string.Format("Successfully registered {0}", user.Username)));
}
public async Task <RegisterResult> RegisterAsync(RegisterUser model)
{
if (model == null)
{
}
if (!model.CheckValidate())
{
}
var user = CheckUser(model.UserName);
if (user != null)
{
throw new CoreException("User not found", 0);
}
user = (TUser)Activator.CreateInstance(typeof(TUser));
user.Create <string>(model);
await RegisterAsync(user);
return(RegisterResult.Create(user));
}
public async Task <IActionResult> AddUserAsync(RegisterUser registerUser)
{
var user = new User
{
UserName = registerUser.UserName,
Email = registerUser.Email,
BirthDate = registerUser.BirthDate
};
IdentityResult result = await _userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
return(Ok());
}
else
{
ModelState.AddModelError(string.Empty, result.Errors.FirstOrDefault()?.Description);
return(BadRequest(ModelState));
}
}
//function to check if User is valid or not
public RegisterUser IsValidUser(Login model)
{
using (var dataContext = new CAFEEntities2())
{
//Retireving the user details from DB based on username and password enetered by user.
RegisterUser user = dataContext.RegisterUsers.Where(query => query.Email.Equals(model.Email) && query.Password.Equals(model.Password)).SingleOrDefault();
//If user not present
if (user == null)
{
return(null);
}
//If user is present
else
{
user.IsActive = true;
dataContext.SaveChanges();
return(user);
}
}
}
public void Create(RegisterUser u)
{
using (SqlConnection connec = new SqlConnection(StringConnec))
{
//Add user in DB
using (SqlCommand cmd = new SqlCommand("AddUser", connec))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("mail", u.Mail);
cmd.Parameters.AddWithValue("login", u.Login);
cmd.Parameters.AddWithValue("password", u.Password);
cmd.Parameters.AddWithValue("birthDate", u.BirthDate);
cmd.Parameters.AddWithValue("country", u.Country);
connec.Open();
cmd.ExecuteNonQuery();
}
}
}
public async Task <IHttpActionResult> Register([FromBody] RegisterUser model)
{
var sb = new StringBuilder(Request.RequestUri.GetLeftPart(UriPartial.Authority));
sb.Append("/api/user/{0}/confirmemail/{1}");
//throws 400
var validator = new RegisterUserValidator();
validator.ValidateAndThrow(model);
var(id, token) = await _service.RegisterAsync(model.Email, model.UserName, model.Password);
if (id is null && token is null)
{
// throws 409 conflict
throw new OperationCanceledException("Please provide unique UserName and Email.");
}
return(Ok(id));
}
public ActionResult Edit1([Bind(Include = "Id,FirstName,LastName,Email,Password,MobileNo,AadharNo")] RegisterUser Registers, HttpPostedFileBase image)
{
Database1Entities1 dc = new Database1Entities1();
// RegisterUser reglog = new RegisterUser();
if (image != null)
{
Registers.ProfileImage = new byte[image.ContentLength];
image.InputStream.Read(Registers.ProfileImage, 0, image.ContentLength);
}
if (ModelState.IsValid)
{
dc.Entry(Registers).State = EntityState.Modified;
dc.SaveChanges();
return(RedirectToAction("UserData1"));
}
return(View(Registers));
}
public IActionResult Registration(RegisterUser heyThere)
{
if (ModelState.IsValid)
{//this is where you create your sessions
string registerLoginJSon = HttpContext.Session.GetString("ListOfPeople");
if (registerLoginJSon != null)
{
registerstuff = JsonConvert.DeserializeObject <List <RegisterUser> >(registerLoginJSon);
}
registerstuff.Add(heyThere);
HttpContext.Session.SetString("ListOfPeople", JsonConvert.SerializeObject(registerstuff));
return(RedirectToAction("Summary", heyThere)); //makes validation work
}
else
{
return(View(heyThere));
}
}
public HttpResponseMessage Register(RegisterUser model)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
model.ModifiedBy = "admin";
RegisterUserService svc = new RegisterUserService();
int id = svc.Insert(model);
ItemResponse <int> resp = new ItemResponse <int>();
resp.Item = id;
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <IActionResult> Register([FromBody] RegisterUser request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new RegistrationResult {
Success = false,
Messages = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var newUser = new User
{
Email = request.Email,
Password = request.Password
};
var registerResponse = await _identityService.RegisterAsync(newUser);
return(Ok(registerResponse));
}
protected void CreateInMemoryUser(string userId)
{
var commandBus = AppHost.Container.Resolve<CommandBus>();
var command = new RegisterUser
{
AggregateId = userId,
FirstName = "Tolik",
LastName = "Anabolik",
AccessToken = "Fake_token_1",
ThirdPartyId = "Third_party_id",
PhotoSmallUri = "http://code9.biz/img/small_test.jpg",
PhotoBigUri = "http://code9.biz/img/big_test.jpg",
LoginType = UserLoginType.Vk
};
commandBus.Send(command, userId);
}
/// <summary>
/// Gets the register user by identifier.
/// </summary>
/// <returns>register id</returns>
public async Task <RegisterUser> GetRegisterUserById()
{
try
{
var userid = DependencyService.Get <IDatabaseInterface>().GetId();
if (userid != null)
{
RegisterUser user = await this.firebase.Child("Users").Child(userid).Child("User Information").OnceSingleAsync <RegisterUser>();
return(user);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(null);
}
public IActionResult Account(int userId)
{
if (HttpContext.Session.GetInt32("CurrentUser") == null) //if the user is not logged in
{
return(RedirectToAction("Index"));
}
else
{
// //if the user is in session, show their transaction history
// int CurrentUser = (int)HttpContext.Session.GetInt32("CurrentUser");
// if(userId != CurrentUser){
// return Redirect($"/account/{CurrentUser}");
// }
RegisterUser user = dbContext.RegisterUser.Include(u => u.Transactions).
FirstOrDefault(u => u.UserId == userId);
user.Transactions.Reverse();
ViewBag.CurrentUser = user;
return(View("Transaction"));
}
}
public async Task <IActionResult> Register([FromBody] RegisterUser newUser)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
try
{
var userToRegister = new User(newUser.Username, null);
int userId = await _userRepository.InsertAsync(userToRegister);
return(Ok());
}
catch (Exception e)
{
//log error
return(StatusCode(StatusCodes.Status500InternalServerError));;
}
}
public async Task <IActionResult> Register([FromBody] RegisterUser model)
{
//TODO: Validate request model
var user = new User()
{
Email = model.Email, UserName = model.Email
};
user.Claims.Add(new IdentityUserClaim <string>()
{
ClaimType = JwtClaimTypes.GivenName,
ClaimValue = model.Firstname
});
user.Claims.Add(new IdentityUserClaim <string>()
{
ClaimType = JwtClaimTypes.FamilyName,
ClaimValue = model.Lastname
});
user.Claims.Add(new IdentityUserClaim <string>()
{
ClaimType = JwtClaimTypes.Gender,
ClaimValue = model.Gender.ToString()
});
user.Claims.Add(new IdentityUserClaim <string>()
{
ClaimType = JwtClaimTypes.BirthDate,
ClaimValue = model.BirthDate.ToString("yyyy-MM-dd")
});
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Ok());
}
else
{
//TODO: Handle failed request like: Duplicate Username, Email,...
return(BadRequest());
}
}
public ActionResult Register(RegisterUser model)
{
//if (ModelState.IsValid)
//{
// User user = null;
// Result result = UserManager.CheckValidationUser(model.Name, model.Password);
// if (!result.Success)
// {
// ModelState.AddModelError("", result.Message);
// return View(model);
// }
// user = result.ResultObject as User;
// if (user == null)
// {
// // создаем нового пользователя
// UserManager.GetManager().Update(model);
// Result result1 = UserManager.CheckValidationUser(model.Name, model.Password);
// if (!result.Success)
// {
// ModelState.AddModelError("", result1.Message);
// return View(model);
// }
// user = result1.ResultObject as User;
// // если пользователь удачно добавлен в бд
// if (user != null)
// {
// FormsAuthentication.SetAuthCookie(user.Login, true);
// return RedirectToAction("Index", "Home");
// }
// }
// else
// {
// ModelState.AddModelError("", "Пользователь с таким логином уже существует");
// }
//}
return(View(model));
}
public ActionResult Login(RegisterUser RegisterUser)
{
try
{
if (string.IsNullOrEmpty(RegisterUser.Username) && (string.IsNullOrEmpty(RegisterUser.Password)))
{
ModelState.AddModelError("", "Enter Username and Password");
}
else if (string.IsNullOrEmpty(RegisterUser.Username))
{
ModelState.AddModelError("", "Enter Username");
}
else if (string.IsNullOrEmpty(RegisterUser.Password))
{
ModelState.AddModelError("", "Enter Password");
}
else
{
RegisterUser.Password = EncryptionLibrary.EncryptText(RegisterUser.Password);
if (_IRegisterUser.ValidateRegisteredUser(RegisterUser))
{
var UserID = _IRegisterUser.GetLoggedUserID(RegisterUser);
HttpContext.Session.SetString("UserID", Convert.ToString(UserID));
return(RedirectToAction("Dashboard", "Dashboard"));
}
else
{
ModelState.AddModelError("", "User is Already Registered");
return(View("Login", RegisterUser));
}
}
return(View("Login", RegisterUser));
}
catch (Exception)
{
return(View());
}
}
public int Insert(RegisterUser model)
{
RegisterUser Model = SelectByEmail(model.Email);
if (Model.Id == 0)
{
int Id = 0;
string salt;
string hashPass;
string password;
password = model.Password;
salt = svc.GenerateRandomString(RAND_LENGTH);
hashPass = svc.Hash(password, salt, HASH_ITERATION_COUNT);
model.Salt = salt;
model.HashPassword = hashPass;
this.DataProvider.ExecuteNonQuery(
"RegisterUsers_Insert",
inputParamMapper : delegate(SqlParameterCollection paramCol)
{
paramCol.AddWithValue("@Id", model.Id);
paramCol.AddWithValue("@UserName", model.UserName);
paramCol.AddWithValue("@Email", model.Email);
paramCol.AddWithValue("@Salt", model.Salt);
paramCol.AddWithValue("@HashPassword", model.HashPassword);
paramCol.AddWithValue("@ModifiedBy", model.ModifiedBy);
},
returnParameters : delegate(SqlParameterCollection paramCol)
{
Id = (int)paramCol["@Id"].Value;
}
);
return(Id);
}
else
{
Model.Id = -1;
return(Model.Id);
}
}
public async Task <UserManagerResponse> RegisterUserAsync(RegisterUser registerUser)
{
if (registerUser == null)
{
throw new NullReferenceException("Register user is null");
}
if (registerUser.Password != registerUser.ConfirmPassword)
{
return new UserManagerResponse
{
Message = "Confirm password wrong",
IsSuccess = false,
}
}
;
var IdentityUser = new IdentityUser
{
Email = registerUser.Email,
UserName = registerUser.Email,
};
var result = await _userManager.CreateAsync(IdentityUser, registerUser.Password);
if (result.Succeeded)
{
return(new UserManagerResponse
{
Message = "User created successfully",
IsSuccess = true,
});
}
return(new UserManagerResponse
{
Message = "User did not create",
IsSuccess = false,
Errors = result.Errors.Select(e => e.Description)
});
}
private void SaveOrUpdateRegistration(UserLoginType loginType, IServiceBase resolver, IOAuthTokens authToken, Dictionary<string, string> authInfo)
{
ViewContext context = resolver.ResolveService<ViewContext>();
CommandBus commandBus = resolver.ResolveService<CommandBus>();
IEntityIdGenerator entityIdGenerator = resolver.ResolveService<IEntityIdGenerator>();
Logger.Debug("Login type: {0}", loginType);
UserDocument existingUser = context.Users
.AsQueryable()
.FirstOrDefault(user => user.ThirdPartyId == authToken.UserId &&
user.LoginType == loginType);
if (existingUser != null)
{
UpdateUserRegistration command = new UpdateUserRegistration()
{
AggregateId = existingUser.Id,
FirstName = authInfo["first_name"],
LastName = authInfo["last_name"],
AccessToken = authToken.AccessToken,
PhotoSmallUri = authInfo["photo"],
PhotoBigUri = authInfo["photo_big"],
};
Logger.Info("Existing user: {0}", command.Dump());
UserId = existingUser.Id;
commandBus.Send(command, UserId);
}
else
{
RegisterUser command = new RegisterUser
{
AggregateId = entityIdGenerator.Generate(),
FirstName = authInfo["first_name"],
LastName = authInfo["last_name"],
LoginType = loginType,
ThirdPartyId = authToken.UserId,
AccessToken = authToken.AccessToken,
PhotoSmallUri = authInfo["photo"],
PhotoBigUri = authInfo["photo_big"]
};
Logger.Info("New user: {0}", command.Dump());
UserId = command.AggregateId;
commandBus.Send(command, UserId);
}
ICacheClient cacheClient = resolver.ResolveService<ICacheClient>();
UpdateSession(cacheClient);
}
public bool Handle(RegisterUser cmd)
{
return true;
}
public ActionResult Create(RegisterUser user)
{
if (ModelState.IsValid)
{
UserData.Create(user);
return RedirectToAction("Index");
}
return View(user);
}
