public async Task <IActionResult> RegisterAdmin(AdminRegisterModel adminRegisterModel)
{
if (ModelState.IsValid)
{
AppUser appUser = await _userManager.FindByEmailAsync(adminRegisterModel.Email);
if (appUser != null)
{
ModelState.AddModelError("", "This user already exists");
}
else
{
appUser = adminRegisterModel;
#region User and it's role creation witrh transaction
if (await this.RegisterUserAsync(adminRegisterModel, appUser))
{
return(RedirectToAction(nameof(AdminHomeController.AdminIndex), "AdminHome"));
}
#endregion
}
return(View());
}
return(View());
}
//Register
public async Task <TranStatus> AdminRegister(AdminRegisterModel model)
{
using (var connection = new SqlConnection(ConnectionString))
{
await connection.OpenAsync();
TranStatus transaction = new TranStatus();
DynamicParameters parameter = new DynamicParameters();
parameter.Add("@Username", model.Username);
parameter.Add("@Gender", model.Gender);
parameter.Add("@Email", model.Email);
parameter.Add("@Mobile", model.Mobile);
parameter.Add("@Password", model.Password);
parameter.Add("@Cpassword", model.Cpassword);
parameter.Add("@Createdby", model.Createdby);
parameter.Add("@Message", dbType: DbType.String, direction: ParameterDirection.Output, size: 500);
parameter.Add("@Code", dbType: DbType.Int32, direction: ParameterDirection.Output);
await connection.QueryAsync("AdminRegister", parameter, commandType : CommandType.StoredProcedure);
transaction.returnMessage = parameter.Get <string>("@Message");
transaction.code = parameter.Get <int>("@Code");
return(transaction);
}
}
public async Task <IActionResult> Register([FromBody] AdminRegisterModel model)
{
//Todo: move stuff to userService
IdentityResult result = new IdentityResult();
if (ModelState.IsValid)
{
IdentityUser user = new IdentityUser
{
UserName = model.Username, Email = model.Email
};
//result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//await SignInManager.SignInAsync(user, isPersistent: false);
//return RedirectToAction("index", "home");
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(Json(result));
}
public async Task <AdminModel> RegisterPartnerAdminAsync([FromBody] AdminRegisterModel model)
{
try
{
var(error, admin) = await _adminsService.RegisterPartnerAdminAsync(model);
if (error == AdminServiceCreateResponseError.None)
{
model.Password = null;
model.Email = model.Email.SanitizeEmail();
await _auditLogPublisher.PublishAuditLogAsync(admin.Id, model.ToJson(), ActionType.PartnerAdminCreate);
return(_mapper.Map <AdminModel>(admin));
}
switch (error)
{
case AdminServiceCreateResponseError.AlreadyRegistered:
throw LykkeApiErrorException.BadRequest(ApiErrorCodes.Service.AdminAlreadyRegistered);
case AdminServiceCreateResponseError.InvalidEmailOrPasswordFormat:
throw LykkeApiErrorException.BadRequest(ApiErrorCodes.Service.InvalidEmailOrPasswordFormat);
default:
throw LykkeApiErrorException.BadRequest(new LykkeApiErrorCode(error.ToString()));
}
}
catch (ClientApiException exception)
{
throw new ValidationApiException(exception.ErrorResponse);
}
}
public Task <TranStatus> AdminRegister(AdminRegisterModel model)
{
using (adminRepository = new AdminRepository())
{
return(adminRepository.AdminRegister(model));
}
}
public JsonResult AdminRegistration(AdminRegisterModel registerModel)
{
var result = "";
if (ModelState.IsValid)
{
var isExist = IsEmailExist(registerModel.Email);
if (isExist == false)
{
ModelState.AddModelError("EmailExist", "Email already exist");
result = "Admin Already Registered ! Please choose another user name";
return(Json(new { result = result }, JsonRequestBehavior.AllowGet));
}
else if (isExist == true)
{
int UserId = repositories.AdminReg(registerModel);
if (UserId > 0)
{
ModelState.Clear();
//ViewBag.Issuccess = "Registration Successful";
result = "Registration Successful";
}
}
}
return(Json(new { result = result }, JsonRequestBehavior.AllowGet));
}
public async Task <AdminModel> RegisterPartnerAdminAsync([FromBody] AdminRegisterModel model)
{
try
{
var(error, admin) = await _adminsService.RegisterPartnerAdminAsync(model);
switch (error)
{
case AdminServiceCreateResponseError.None:
return(_mapper.Map <AdminModel>(admin));
case AdminServiceCreateResponseError.AlreadyRegistered:
throw LykkeApiErrorException.BadRequest(ApiErrorCodes.Service.AdminAlreadyRegistered);
case AdminServiceCreateResponseError.InvalidEmailOrPasswordFormat:
throw LykkeApiErrorException.BadRequest(ApiErrorCodes.Service.InvalidEmailOrPasswordFormat);
default:
throw LykkeApiErrorException.BadRequest(new LykkeApiErrorCode(error.ToString()));
}
}
catch (ClientApiException exception)
{
throw new ValidationApiException(exception.ErrorResponse);
}
}
//[Route("Admin")]
public async Task <IActionResult> RegisterAdmin([FromBody] AdminRegisterModel adminRegisterModel)
{
try
{
//Throws Custom Exception When Fields are Null.
if (adminRegisterModel.Name == null || adminRegisterModel.Password == null || adminRegisterModel.EmailId == null || adminRegisterModel.Gender == null)
{
throw new Exception(AdminExceptions.ExceptionType.NULL_EXCEPTION.ToString());
}
//Throws Custom Exception When Fields are Empty Strings.
if (adminRegisterModel.Name == "" || adminRegisterModel.Password == "" || adminRegisterModel.EmailId == "" || adminRegisterModel.Gender == "")
{
throw new Exception(AdminExceptions.ExceptionType.EMPTY_EXCEPTION.ToString());
}
var data = await adminBL.RegisterAdmin(adminRegisterModel);
if (data != null)
{
return(Ok(new { status = "True", message = "Register Successfully", data }));
}
else
{
return(Conflict(new { status = "False", message = "Email Already Present" }));
}
}
catch (Exception exception)
{
bool Success = false;
return(BadRequest(new { Success, Message = exception.Message }));
}
}
private void RaiseAdminCreatedEvent(AdminRegisterModel admin)
{
var handler = AdminCreated;
if (handler != null)
{
AdminEventArgs e = new AdminEventArgs(admin);
handler(this, e);
}
}
/// <summary>
/// Function For Register User.
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public async Task <RAdminRegisterModel> RegisterAdmin(AdminRegisterModel user)
{
try
{
return(await this.adminRL.RegisterAdmin(user));
}
catch (Exception exception)
{
throw exception;
}
}
public HttpResponseMessage RegisterAdmin(AdminRegisterModel AdminInfo)
{
var registerHttpClient = new RegisterHttpClient();
var response = registerHttpClient.RegisterAdmin(AdminInfo);
if (response.IsSuccessStatusCode)
{
return(response);
}
return(null);
}
public int AdminReg(AdminRegisterModel registrationModel)
{
using (var context = new INVENTORYEntities())
{
AdminRegister adminRegister = new AdminRegister();
adminRegister.UserName = registrationModel.UserName;
adminRegister.Email = registrationModel.Email;
adminRegister.Password = registrationModel.Password;
adminRegister.RetypePassword = registrationModel.RetypePassword;
context.AdminRegister.Add(adminRegister);
context.SaveChanges();
return(adminRegister.UserId);
}
}
public HttpResponseMessage RegisterAdmin(AdminRegisterModel AdminInfo)
{
using (ServiceClient)
{
var resource = string.Format("api/register");
var response = ServiceClient.PostAsJsonAsync(resource, AdminInfo).Result;
if (response.IsSuccessStatusCode)
{
return(response);
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public async Task <IActionResult> RegisterAdmin([FromBody] AdminRegisterModel registerModel)
{
if (registerModel.Key != adminKey)
{
Console.WriteLine(adminKey);
return(Unauthorized(new Response("Error", "Invalid key")));
}
ApplicationUser userByName = await this.userManager.FindByNameAsync(registerModel.Username);
ApplicationUser userByEmail = await this.userManager.FindByEmailAsync(registerModel.Email);
if (userByName != default)
{
return(BadRequest("Username is taken"));
}
if (userByEmail != default)
{
return(BadRequest("Email is taken"));
}
if (await this.roleManager.RoleExistsAsync("admin") == false)
{
await this.roleManager.CreateAsync(new IdentityRole("admin"));
}
ApplicationUser newApplicationUser = new ApplicationUser()
{
UserName = registerModel.Username,
Email = registerModel.Email
};
IdentityResult identityResult = await this.userManager.CreateAsync(newApplicationUser, registerModel.Password);
if (identityResult.Succeeded)
{
await this.CreateCharacter(newApplicationUser);
await userManager.AddToRoleAsync(newApplicationUser, "admin");
adminKey = GenerateAdminKey();
return(Ok(registerModel));
}
else
{
return(Ok(new Response("Error", "User creation failed, try again later.")));
}
}
public async Task <IActionResult> CreateAdmin(AdminRegisterModel registerModel)
{
//reqem,boyuk kicik herf,minimum 8 uzunluq,3 defe sehv yigma
if (!ModelState.IsValid)
{
return(View());
}
AppUser existUser = await _userManager.FindByNameAsync(registerModel.UserName);
if (existUser != null)
{
ModelState.AddModelError("UserName", "UserName already taken");
return(View());
}
AppUser newUser = new AppUser()
{
FullName = registerModel.FullName,
UserName = registerModel.UserName,
IsAdmin = true,
};
var result = await _userManager.CreateAsync(newUser, registerModel.Password);
if (!result.Succeeded)
{
foreach (var item in result.Errors)
{
if (item.Code == "PasswordTooShort")
{
item.Description = "Passwordun uzunlugu 8-den kicik ola bilmez";
}
else if (item.Description == "ConfirmedPassword and Password do not match.")
{
item.Description = "Alinmadi";
}
ModelState.AddModelError("", item.Description);
}
return(View());
}
newUser.IsAdmin = true;
await _userManager.AddToRoleAsync(newUser, "Admin");
return(RedirectToAction("getadmins"));
}
public ActionResult Register(AdminRegisterModel Admin)
{
if (ModelState.IsValid)
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:2017/api/AdminRegisterApi"); //this one
var InserRecord = client.PostAsJsonAsync("AdminRegisterApi", Admin); //this one
InserRecord.Wait();
var SaveRecord = InserRecord.Result;
if (SaveRecord.IsSuccessStatusCode)
{
ModelState.Clear();
ViewBag.Message = "<script>alert('successfully Register')</script>";
}
}
return(View());
}
public async Task <IActionResult> AdminRegister([FromBody] AdminRegisterModel model)
{
Dictionary <String, Object> dctData = new Dictionary <string, object>();
HttpStatusCode statusCode = HttpStatusCode.OK;
TranStatus transaction = new TranStatus();
try
{
transaction = await iadmin.AdminRegister(model);
}
catch (Exception ex)
{
transaction = CommonHelper.TransactionErrorHandler(ex);
statusCode = HttpStatusCode.BadRequest;
}
dctData.Add("Status", transaction);
return(this.StatusCode(Convert.ToInt32(statusCode), dctData));
}
private async Task <bool> RegisterUserAsync(AdminRegisterModel adminRegisterModel, AppUser appUser)
{
bool isRegisteredAdmin = false;
using (IDbContextTransaction dbContextTransaction = _jobstoreDbContext.Database.BeginTransaction())
{
try
{
IdentityResult identityResult = await _userManager.CreateAsync(appUser, adminRegisterModel.Password);
if (identityResult.Succeeded)
{
IdentityResult identityRoleResult = await _userManager.AddToRoleAsync(appUser, RoleType.admin.ToString());
if (identityRoleResult.Succeeded)
{
dbContextTransaction.Commit();
isRegisteredAdmin = true;
}
else
{
dbContextTransaction.Rollback();
this.AddToModelErrors(identityResult.Errors);
}
}
else
{
this.AddToModelErrors(identityResult.Errors);
dbContextTransaction.Rollback();
}
}
catch (Exception exp)
{
dbContextTransaction.Rollback();
ModelState.AddModelError("", exp.Message);
}
}
return(isRegisteredAdmin);
}
public async Task <IActionResult> Login(Models.ViewModels.LoginModel loginModel)
{
if (ModelState.IsValid)
{
//get current user by email
AppUser currentUser = await _userManager.FindByEmailAsync(loginModel.Email);
Microsoft.AspNetCore.Identity.SignInResult signInResult = await _signInManager.PasswordSignInAsync(currentUser, loginModel.Password, loginModel.RememberMe, true);
if (signInResult.Succeeded)
{
var user = User;
AdminRegisterModel adminRegisterModel = new AdminRegisterModel();
RegisterModel_a registerModel_A = new RegisterModel_a();
RegisterModel_s registerModel_S = new RegisterModel_s();
if (currentUser.Email == adminRegisterModel.Email)
{
return(RedirectToAction("AdminIndex", "AdminHome", new { area = "Admin" }));
}
else if (currentUser.Email == registerModel_A.Email || currentUser.Email == registerModel_S.Email)
{
return(RedirectToAction("Index", "Home"));
}
//go to user defined role panel
}
else
if (signInResult.IsLockedOut)
{
ModelState.AddModelError("", "This use is already locked out!!");
}
else
if (signInResult.IsNotAllowed)
{
ModelState.AddModelError("", "Your have no access");
}
}
return(RedirectToAction(nameof(Login)));
}
public AdminEventArgs(AdminRegisterModel admin)
{
this.Admin = admin;
}
public async Task <(AdminServiceCreateResponseError, AdminModel)> RegisterPartnerAdminAsync(AdminRegisterModel model)
{
#region Create Admin
var createAdminResponse = await _adminManagementServiceClient.AdminsApi.RegisterAsync(
new RegistrationRequestModel
{
Email = model.Email,
Password = model.Password,
Company = model.CompanyName,
Localization = _mapper.Map <Localization>(model.Localization),
Department = DefaultStringValue,
FirstName = DefaultStringValue,
JobTitle = DefaultStringValue,
LastName = DefaultStringValue,
PhoneNumber = DefaultStringValue,
Permissions = new List <AdminPermission>
{
new AdminPermission
{
Type = PermissionType.Dashboard.ToString(),
Level = AdminPermissionLevel.PartnerEdit
},
new AdminPermission
{
Type = PermissionType.VoucherManager.ToString(),
Level = AdminPermissionLevel.PartnerEdit
},
new AdminPermission
{
Type = PermissionType.ProgramPartners.ToString(),
Level = AdminPermissionLevel.PartnerEdit
},
new AdminPermission
{
Type = PermissionType.Reports.ToString(),
Level = AdminPermissionLevel.PartnerEdit
},
new AdminPermission
{
Type = PermissionType.AdminUsers.ToString(),
Level = AdminPermissionLevel.PartnerEdit
},
}
});
if (createAdminResponse.Error != AdminManagementError.None)
{
switch (createAdminResponse.Error)
{
case AdminManagementError.AlreadyRegistered:
return(AdminServiceCreateResponseError.AlreadyRegistered, null);
case AdminManagementError.InvalidEmailOrPasswordFormat:
return(AdminServiceCreateResponseError.InvalidEmailOrPasswordFormat, null);
default:
throw new ArgumentOutOfRangeException(nameof(createAdminResponse.Error), createAdminResponse.Error.ToString());
}
}
#endregion
#region Create Partner
var partnerRequest = new PartnerCreateModel
{
Name = model.CompanyName,
UseGlobalCurrencyRate = true,
BusinessVertical = Vertical.Retail,
ClientId = await _partnerManagementClient.Auth.GenerateClientId(),
ClientSecret = await _partnerManagementClient.Auth.GenerateClientSecret(),
CreatedBy = Guid.Parse(createAdminResponse.Admin.AdminUserId)
};
var response = await _partnerManagementClient.Partners.CreateAsync(partnerRequest);
if (response.ErrorCode != PartnerManagementError.None)
{
throw LykkeApiErrorException.BadRequest(new LykkeApiErrorCode(response.ErrorCode.ToString(), response.ErrorMessage));
}
#endregion
return(AdminServiceCreateResponseError.None, _mapper.Map <AdminModel>(createAdminResponse.Admin));
}
/// <summary>
/// Admin signup method
/// </summary>
/// <param name="adminRegisterModel"></param>
/// <returns></returns>
public async Task <RAdminRegisterModel> RegisterAdmin(AdminRegisterModel adminRegisterModel)
{
try
{
var identityUser = new IdentityUser
{
Email = adminRegisterModel.EmailId,
UserName = adminRegisterModel.Name,
};
IdentityRole identityRole = new IdentityRole
{
Name = adminRegisterModel.Role
};
var result = await roleManager.CreateAsync(identityRole);
var RoleId = roleManager.GetRoleIdAsync(identityRole);
if (!result.Succeeded)
{
throw new Exception(AdminExceptions.ExceptionType.INVALID_ROLE_EXCEPTION.ToString());
}
var model = new AdminRegisterModel
{
Name = adminRegisterModel.Name,
EmailId = adminRegisterModel.EmailId,
Password = adminRegisterModel.Password,
Gender = adminRegisterModel.Gender,
CreatedDate = DateTime.Now.ToString(),
Role = adminRegisterModel.Role,
};
/*var results = _adminmanager.Add(model);
*
* if (results==null)
* {
* throw new Exception(AdminExceptions.ExceptionType.INVALID_ROLE_EXCEPTION.ToString());
* }*/
string Password = adminRegisterModel.Password;
DatabaseConnection databaseConnection = new DatabaseConnection(this.configuration);
SqlConnection sqlConnection = databaseConnection.GetConnection();
adminRegisterModel.Password = Encrypt(adminRegisterModel.Password).ToString();
SqlCommand sqlCommand = databaseConnection.GetCommand("spAdminRegistration", sqlConnection);
sqlCommand.Parameters.AddWithValue("@Name", adminRegisterModel.Name);
sqlCommand.Parameters.AddWithValue("@EmailId", adminRegisterModel.EmailId);
sqlCommand.Parameters.AddWithValue("@Password", adminRegisterModel.Password);
sqlCommand.Parameters.AddWithValue("@Gender", adminRegisterModel.Gender);
sqlCommand.Parameters.AddWithValue("@CreatedDate", DateTime.Now.ToString());
sqlCommand.Parameters.AddWithValue("@Role", adminRegisterModel.Role);
sqlCommand.Parameters.AddWithValue("@RoleId", RoleId.Id);
sqlConnection.Open();
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
var userData = new RAdminRegisterModel();
while (sqlDataReader.Read())
{
//userData = new RAdminLoginModel();
int status = sqlDataReader.GetInt32(0);
if (status == 0)
{
return(null);
}
result = await _userManger.CreateAsync(identityUser, adminRegisterModel.Password);
if (result.Succeeded)
{
userData.AdminId = (int)sqlDataReader["ID"];
userData.AdminName = sqlDataReader["Name"].ToString();
userData.AdminEmailId = sqlDataReader["EmailId"].ToString();
userData.Role = sqlDataReader["Role"].ToString();
userData.RoleID = sqlDataReader["RoleId"].ToString();
userData.Gender = sqlDataReader["Gender"].ToString();
userData.CreatedDate = sqlDataReader["ModificateDate"].ToString();
//return new RAdminRegisterModel();
}
}
if (userData.AdminEmailId != null)
{
return(userData);
}
else
{
return(null);
}
//return null;
}
catch (Exception exception)
{
throw exception;
}
}
public AdminRegisterViewModel(AdminRegisterModel model)
: base(model)
{
admin = model;
CreateAdminCommand = new DelegateCommand(() => RaiseAdminCreatedEvent(admin), CanCreateAdmin);
}
