public ActionResult Register()
{
//Menu.ChangeSelected(6, 2);
RegisterAdmin reg = new RegisterAdmin();
return(View(reg));
}
public void ValidatePropertiesTest()
{
LoginAdmin admin = new LoginAdmin
{
Username = "******",
Password = "******"
};
RegisterAdmin admins = new RegisterAdmin
{
Username = "******",
Password = "******"
};
UpdatePassword upt = new UpdatePassword
{
Username = "******",
NewPassword = "******",
RepeatPassword = "******"
};
admins.ValidateAllProperties();
admin.ValidateAllProperties();
upt.ValidateAllProperties();
}
public ActionResult RegisterAdmin(RegisterAdmin model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser();
user.UserName = model.AdminId;
user.Name = model.AdminIsim;
user.Surname = model.AdminSoyisim;
var result = userManager.Create(user, model.Sifre);
if (result.Succeeded)
{
userManager.AddToRole(user.Id, "Admin");
return(RedirectToAction("Index", new { id = User.Identity.Name }));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
public ActionResult RegisterAdmin(RegisterAdmin model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser();
user.UserName = model.AdminId;
user.Name = model.AdminIsim;
user.Surname = model.AdminSoyisim;
var result = userManager.Create(user, model.Sifre);
if (result.Succeeded)
{
userManager.AddToRole(user.Id, "Admin");
MessageBox.Show("Kaydınız başarılı bir şekilde gerçekleşmiştir", "Bilgilendirme");
return(RedirectToAction("RegisterAdmin", new { id = User.Identity.Name }));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
[HttpPost("Register")] //Creating a Post Api
public IActionResult RegisterAdminDetails(RegisterAdmin registration) //Here return type represents the result of an action method
{
try
{
if (ModelState.IsValid)
{
Admin result = this.adminBL.RegisterAdminDetails(registration); //getting the data from BusinessLayer
if (result != null)
{
return(this.Ok(new { Success = true, Message = "Admin details is added Successfully" })); //(smd format) //this.Ok returns the data in json format
}
else
{
return(this.BadRequest(new { Success = false, Message = "Admin details is added Unsuccessfully" }));
}
}
else
{
throw new Exception("Model is not valid");
}
}
catch (Exception e)
{
return(this.BadRequest(new { Success = false, Message = e.Message }));
}
}
public async Task <ActionResult> Register(RegisterAdmin reg)
{
reg.Email.Trim();
AbzContext db = new AbzContext();
Usr user = new Usr();
user.Email = reg.Email;
string Password = GenerateRandomPassword(6);
user.Password = Password;
user.UserId = Guid.NewGuid().ToString();
db.Users.Add(user);
db.SaveChanges();
UserInCust uc = new UserInCust();
uc.CustID = reg.CustId;
uc.UserId = user.UserId;
uc.LastDat = DateTime.Now;
uc.Email = reg.Email;
//uc.Pwd = Password;
db.UserInCusts.Add(uc);
db.SaveChanges();
await EmailSend.EMailRegAsync(reg.Email, Password);
return(RedirectToAction("Index", "Home"));
}
public ActionResult AdminLogin()
{
string email = Request["Email"];
string pass = Request["Password"];
if (Session["Email"] != null && Session["Password"] != null && Session["Email"].ToString().Equals(email) &&
Session["Password"].ToString().Equals(pass))
{
return(View("../Home/Cart"));
}
else
{
RegisterAdmin s = db.RegisterAdmins.Find(email);
if (s == null)
{
return(View("../Home/NotFound"));
}
else
{
if (s != null && s.Email.Equals(email) && s.Password.Equals(pass) && s.Status.Equals("admin"))
{
Session["Email"] = s.Email;
Session["Password"] = s.Password;
Session["Status"] = s.Status;
return(RedirectToAction("Index", "Home"));
}
}
return(View("../Home/Error"));
}
}
public async Task <ActionResult> CreateAdmin([FromServices] UserManager <ApplicationUser> userManager,
[FromServices] AccessManager accessManager,
[FromBody] RegisterAdmin registerAdmin)
{
var user = new ApplicationUser
{
UserName = registerAdmin.UserName,
Email = registerAdmin.Email,
PhoneNumber = registerAdmin.PhoneNumber,
};
var result = userManager.CreateAsync(user, registerAdmin.Password).Result;
if (result.Succeeded)
{
var usuarioSAlvo = userManager.FindByNameAsync(user.UserName).Result;
var usuarioAcesso = new User();
usuarioAcesso.UserID = usuarioSAlvo.Id;
usuarioAcesso.Password = usuarioSAlvo.PasswordHash;
usuarioAcesso.Email = usuarioSAlvo.Email;
var resultado = accessManager.GenerateTokenAdmin(usuarioAcesso);
return(Created($"registerUser/{resultado}", new { resultado }));
}
else
{
return(BadRequest("Usuário ou senha inválidos"));
}
}
public async Task <IActionResult> CreateAdmin([FromBody] RegisterAdmin model)
{
if (model == null)
{
return(BadRequest());
}
var user = _mapper.Map <AppUser>(model);
user.Roles.Add("Admin");
if (!ModelState.IsValid)
{
return(new ModelValidator.UnprocessableEntityObjectResult(ModelState));
}
if (!(_AppUserService.checkbyusername(model.UserName) ||
_AppUserService.checkbyuseremail(model.Email)))
{
var creuser = await _AppUserService.CreateAdmin(user, model.Password.ToString());
var result = _mapper.Map <UserResponse>(creuser);
return(CreatedAtRoute("GetAppUser", new { id = user.Id.ToString() }, result));
}
else
{
return(BadRequest("user name or email allready exist"));
}
}
public async Task <ActionResult> RegisterAdmin(RegisterAdmin model)
{
using (var db = new ProgressTrackerEntities())
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
Name = model.Name,
Surname = model.Surname,
Title = model.Title,
Picture = null
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
var _context = new ApplicationDbContext();
var roleStore = new RoleStore <Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(_context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var userStore = new UserStore <ApplicationUser>(_context);
var UseManage = new UserManager <ApplicationUser>(userStore);
UseManage.AddToRole(user.Id, "Admin");
var id = user.Id;
// For more information on how to enable account confirmation and password reset please visit https://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>");
Admin admin = new Admin
{
UserID = id,
};
db.Admins.Add(admin);
db.SaveChanges();
return(View("DisplayEmail"));
// return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
}
public void DuplicateUsernameTest()
{
RegisterAdmin admin = new RegisterAdmin
{
Username = "******",
Password = "******"
};
Assert.IsTrue(admin.CheckForUsernameDuplicates());
}
public async Task <IActionResult> Create(RegisterAdmin admin)
{
int N = await _context.Admins.CountAsync();
N = 0;
if (N > 0)
{
return(View("~/Views/Admins/AdminExsist.cshtml"));
}
else
{
if (ModelState.IsValid)
{
if (_userManager.Users.Any(u => u.UserName == admin.Username))
{
ModelState.AddModelError(String.Empty, "User name already taken");
ViewData["message"] = "Already Taken";
return(View(admin));
}
var user = new IdentityUser {
UserName = admin.Username, Email = admin.Email, PhoneNumber = admin.Phone
};
var result = await _userManager.CreateAsync(user, admin.Password);
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "Admin"));
Admin A = new Admin
{
Id = user.Id,
FirstName = admin.FirstName,
MiddleName = admin.MiddleName,
LastName = admin.LastName,
Mobile = admin.Mobile,
User = user
};
_context.Admins.Add(A);
_context.SaveChanges();
if (result.Succeeded)
{
return(RedirectToRoute("Admin"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(View(admin));
}
}
public Admin RegisterAdminDetails(RegisterAdmin registration)
{
try
{
return(this.adminRL.RegisterAdminDetails(registration)); //throw exceptions
}
catch (Exception e)
{
throw e;
}
}
public Admin RegisterAdminDetails(RegisterAdmin registration)
{
try
{
Admin admin = new Admin();
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (connection)
{
connection.Open();
//define the SqlCommand Object
SqlCommand cmd = new SqlCommand("RegisterAdminDetails", connection);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@AdminName", registration.AdminName);
cmd.Parameters.AddWithValue("@PhoneNumber", registration.PhoneNumber);
cmd.Parameters.AddWithValue("@Email", registration.Email);
cmd.Parameters.AddWithValue("@Password", Password.ConvertToEncrypt(registration.Password));
SqlDataReader sqlDataReader = cmd.ExecuteReader();
if (sqlDataReader.HasRows)
{
if (sqlDataReader.Read())
{
admin.AdminID = sqlDataReader.GetInt64(0);
admin.AdminName = sqlDataReader.GetString(1);
admin.PhoneNumber = sqlDataReader.GetInt64(2);
admin.Email = sqlDataReader.GetString(3);
}
}
return(admin);
//Close Data Reader
sqlDataReader.Close();
connection.Close();
}
}
}
catch (Exception e)
{
throw e;
}
}
public IActionResult RegisterAdmin(RegisterAdmin model)
{
// map model to entity
var admin = _mapper.Map <Admin>(model);
try
{
// create user
_adminService.CreateAdmin(admin, model.Password);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ActionResult> Register(RegisterAdmin reg)
{
//Отладка
//EmailSend.EMailReg("*****@*****.**", "123");
//return View("NoRegister");
AbzContext db = new AbzContext();
var user = new ApplicationUser {
UserName = reg.Email, Email = reg.Email, CustID = reg.CustId
};
string Password = GenerateRandomPassword(6);
var result = UserManager.Create(user, Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "CustManager");
SignInManager.SignIn(user, isPersistent: false, rememberBrowser: false);
UserInCust uc = new UserInCust();
uc.CustID = reg.CustId;
uc.UserId = user.Id;
uc.LastDat = DateTime.Now;
db.UserInCusts.Add(uc);
db.SaveChanges();
await EmailSend.EMailRegAsync(reg.Email, Password);
//EmailSend.EMailRegAsync(reg.Email, Password);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Отправка сообщения электронной почты с этой ссылкой
// 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, "Подтверждение учетной записи", "Подтвердите вашу учетную запись, щелкнув <a href=\"" + callbackUrl + "\">здесь</a>");
return(RedirectToAction("Index", "Home"));
}
return(View("NoRegister"));
}
public void GettersAndSettersTest()
{
LoginAdmin admin = new LoginAdmin
{
Username = "******",
Password = "******"
};
RegisterAdmin admins = new RegisterAdmin
{
Username = "******",
Password = "******"
};
UpdatePassword upt = new UpdatePassword
{
Username = "******",
NewPassword = "******",
RepeatPassword = "******"
};
}
public void GettersAndSettersWithErrorTest()
{
LoginAdmin admin = new LoginAdmin
{
Username = "******",
Password = "******"
};
RegisterAdmin admins = new RegisterAdmin
{
Username = "******",
Password = "******"
};
UpdatePassword upt = new UpdatePassword
{
Username = "******",
NewPassword = "******",
RepeatPassword = "******"
};
}
public async Task <IActionResult> RegisterAdmin(RegisterAdmin model)
{
//checking if user exists or not
var userExist = await userManager.FindByNameAsync(model.UserName);
if (userExist != null)
{
TempData["message"] = "User Already Exists";
}
//checking age valid
int age = 0;
age = DateTime.Now.Year - model.Dob.Year;
if (DateTime.Now.DayOfYear < model.Dob.DayOfYear)
{
age = age - 1;
}
if (age >= 0 && age < 18)
{
TempData["message"] = "You Are below 18 years, So Your Account Cannot be created";
return(RedirectToAction("Index"));
}
else if (age < 0 || age > 100)
{
TempData["message"] = "You have Entered false Date of birth";
return(RedirectToAction("Index"));
}
//creating user
ApplicationUser user = new ApplicationUser
{
UserName = model.UserName,
PhoneNumber = model.PhoneNumber,
FirstName = model.FirstName,
LastName = model.LastName,
Dob = model.Dob,
Gender = model.Gender,
FathersName = model.FathersName,
MothersName = model.MothersName,
Address = model.Address,
Pincode = model.Pincode,
Status = "admin",
SecurityStamp = Guid.NewGuid().ToString(),
};
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
TempData["message"] = $"{result.Errors.ToList()[0].Description}";
}
else
{
//adding role
if (!await roleManager.RoleExistsAsync(UserRoles.Admin))
{
await roleManager.CreateAsync(new IdentityRole(UserRoles.Admin));
}
if (!await roleManager.RoleExistsAsync(UserRoles.User))
{
await roleManager.CreateAsync(new IdentityRole(UserRoles.User));
}
if (await roleManager.RoleExistsAsync(UserRoles.Admin))
{
await userManager.AddToRolesAsync(user, new List <string>() { UserRoles.Admin });
}
TempData["message"] = "Admin User Registered Successfuly. You Can LogIn Into Your Account using your Email and Password";
}
return(RedirectToAction("Index"));
}
public ActionResult Register()
{
RegisterAdmin reg = new RegisterAdmin();
return(View(reg));
}
public RegisterViewModel(BaseViewModel parent)
{
Iadmin = new RegisterAdmin();
this.parent = parent;
}
