public async Task <IActionResult> Registration(RegistrationVM model)
{
if (ModelState.IsValid)
{
var user = new IdentityUser()
{
UserName = model.Email,
Email = model.Email
};
var result = await manager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("login"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError("", item.Description);
}
return(View(model));
}
}
else
{
return(View(model));
}
}
public IActionResult MakeOrder(RegistrationVM model)
{
string productsId = HttpContext.Session.GetString("OrderProduct");
string quantities = HttpContext.Session.GetString("ProductQuantity");
string userID = HttpContext.Session.GetString("User_ID");
string[] keyProduct = productsId.Split(",");
string[] keyQuantity = quantities.Split(",");
User user = new User();
UserServise _user = new UserServise();
if (userID != null)
{
EncriptServises _encript = new EncriptServises();
for (int i = 0; i < keyProduct.Length - 1; i++)
{
Order entity = new Order();
entity.SubjectID = int.Parse(keyProduct[i]);
entity.Quantity = int.Parse(keyQuantity[i]);
entity.OrderNumber = HttpContext.Session.GetString("OrderNumber");
entity.Date = DateTime.Today.ToString("dd/MM/yyyy");
entity.Status = Status.Supplier;
Product element = _product.GetByID(entity.SubjectID);
entity.Total = (entity.Quantity * element.Price);
_order.Save(entity);
entity.UserID = int.Parse(userID);
_order.Save(entity);
ChangewquantityOfPRoduct(element, entity.Quantity);
}
}
else
{
user = AddUserInDB(user, model);
_user.Save(user);
user = new User();
for (int i = 0; i < keyProduct.Length - 1; i++)
{
Order entity = new Order();
entity.SubjectID = int.Parse(keyProduct[i]);
entity.Quantity = int.Parse(keyQuantity[i]);
entity.OrderNumber = HttpContext.Session.GetString("OrderNumber");
entity.Date = DateTime.Today.ToString("dd/MM/yyyy");
entity.Status = Status.Supplier;
user = _user.GetLastElement();
entity.UserID = user.ID;
Product element = _product.GetByID(entity.SubjectID);
entity.Total = (entity.Quantity * element.Price);
_order.Save(entity);
ChangewquantityOfPRoduct(element, entity.Quantity);
}
}
DeleteSession();
return(RedirectToAction("CungratOrder"));
}
public ActionResult Registration(RegistrationVM reg)
{
if (ModelState.IsValid)
{
if (CheckForExitedUserInDB(reg))
{
ModelState.AddModelError(string.Empty, "Email already exist in site. Please enter anoither emeil");
return(View(reg));
}
else
{
string error = EnterLoginInformation(reg);
if (error != "OK")
{
ModelState.AddModelError(string.Empty, error);
return(View(reg));
}
else
{
AddUSerINformation(reg);
}
}
}
return(RedirectToAction("Confirm"));
}
public async Task <IActionResult> Post([FromBody] RegistrationVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <User>(model);
try
{
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new OkObjectResult("User Creation Failed"));
}
await _appDbContext.BookSeekers.AddAsync(new BookSeeker { IdentityId = userIdentity.Id, Location = model.Location });
await _appDbContext.SaveChangesAsync();
}
catch (Exception ex)
{
return(new OkObjectResult("User Creation Failed"));
}
return(new OkObjectResult("Account created"));
}
public ActionResult Create([Bind(Exclude = "SysteemRollen")] RegistrationVM registrationVM)
{
if (ModelState.IsValid)
{
using (var context = new UserContext())
{
String hashedPassword = GetSwcSH1(registrationVM.Wachtwoord);
var resultlist = context.spRegisterUser(registrationVM.UserNaam, hashedPassword, registrationVM.SelectedSysteemRol, registrationVM.Email, registrationVM.Naam);
var list = new List <int?>();
list = (from element in resultlist select element).ToList();
var result = list.SingleOrDefault();
if (result == -1)
{
ViewBag.UsernameError = "User Name already in use, please choose another user name";
}
else
{
return(Json(new { success = true }));
}
}
}
registrationVM.SysteemRollen = _systeemRolRepository.GetAll();
return(PartialView("~/Views/Admin/Users/_Add.cshtml", registrationVM));
}
public static List <SelectListItem> GetCountriesList(
this RegistrationVM registrationVM)
{
var result = new List <SelectListItem>();
var countries = registrationVM.Countries;
var checkd = false;
foreach (var country in countries)
{
if (registrationVM.CountryID != 0)
{
if (country.Country_ID == registrationVM.CountryID)
{
checkd = true;
}
}
else
{
if (country.CountryName == "Российская Федерация")
{
checkd = true;
}
}
result.Add(new SelectListItem {
Selected = checkd, Text = country.CountryName, Value = country.Country_ID.ToString()
});
checkd = false;
}
return(result);
}
public ActionResult RestorePassword(string id)
{
userID = int.Parse(_encript.DencryptData(id));
RegistrationVM model = new RegistrationVM();
return(View(model));
}
public UserServiceMock()
{
User = new User
{
Id = "johnDoe1",
UserName = "******",
Email = "*****@*****.**"
};
RegistrationVM = new RegistrationVM
{
UserName = "******",
Password = "******",
ConfirmPassword = "******",
Email = "*****@*****.**"
};
LoginVM = new LoginVM
{
UserName = "******",
Password = "******",
RememberMe = true
};
EmailConfirmationToken = "emailConfirmationToken";
PasswordResetToken = "passwordResetToken";
Configurable = new Mock <IUserService>();
}
public HttpResponseMessage Register(HttpRequestMessage request, RegistrationVM user)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
}
else
{
var _user = _membershipService.CreateUser(user.Username, user.Email, user.Password, new int[] { ConfigurationReader.Membership });
if (_user != null && _user.Item1 != null)
{
response = request.CreateResponse(HttpStatusCode.OK, new
{
message = _user.Item2,
success = true,
role = _user.Item1.UserRoles.FirstOrDefault().Role.Name,
email = _user.Item1.Email
});
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { message = _user.Item2, success = false });
}
}
return response;
}));
}
public async Task <HidrogenianVM> InsertNewHidrogenian(RegistrationVM registration)
{
_logger.LogInformation("HidrogenianService.InserNewHidrogenian - Service starts.");
var dbHidrogenian = new Hidrogenian {
Email = registration.Email,
UserName = registration.UserName,
PasswordHash = registration.Password,
PasswordSalt = registration.PasswordConfirm
};
_dbContext.Hidrogenian.Add(dbHidrogenian);
try {
await _dbContext.SaveChangesAsync();
} catch (Exception e) {
_logger.LogError("HidrogenianService.InserNewHidrogenian - Error: " + e);
return(null);
}
HidrogenianVM hidrogenian = dbHidrogenian;
hidrogenian.FamilyName = registration.FamilyName;
hidrogenian.GivenName = registration.GivenName;
return(hidrogenian);
}
private void PrepareStep4View(ref Models.RegistrationVM step4RegistrationVM, RegistrationVM session)
{
step4RegistrationVM.ActivatedCustomer = new Customer()
{
FirstName = session.ActivatedCustomer.FirstName,
LastName = session.ActivatedCustomer.LastName,
PrimaryEmail = session.ActivatedCustomer.PrimaryEmail,
PrimaryPhone = session.ActivatedCustomer.PrimaryPhone
};
step4RegistrationVM.ActivatedCustomer.InvoicePreview = new InvoicePreview
{
Subtotal = session.ActivatedCustomer.InvoicePreview.Subtotal,
TotalTaxes = session.ActivatedCustomer.InvoicePreview.TotalTaxes,
Total = session.ActivatedCustomer.InvoicePreview.Total
};
step4RegistrationVM.BillingAddress = new Address
{
Line1 = session.BillingAddress.Line1,
Line2 = session.BillingAddress.Line2,
PostalZip = session.BillingAddress.PostalZip,
City = session.BillingAddress.City,
Country = session.SelectedCountryName,
State = session.SelectedStateName
};
}
public ActionResult Step3GetCustomerInformation(RegistrationVM registration)
{
var session = (RegistrationVM)Session[RegistrationKey];
// If we came from Step2, we will store the values of the Quantity and IsIncluded properties from the VM into our Session
if (registration.Step == (int)FromStep.Step2)
{
for (int i = 0; i < registration.AvailableProducts.Count; i++)
{
session.AvailableProducts[i].Quantity = registration.AvailableProducts[i].Quantity;
session.AvailableProducts[i].IsIncluded = registration.AvailableProducts[i].IsIncluded;
}
}
registration.BillingAddress = session.BillingAddress;
registration.CustomerInformation = session.CustomerInformation;
registration.SelectedPlanId = session.SelectedPlanId;
registration.SelectedPlanFrequencyID = session.SelectedPlanFrequencyID;
registration.AvailableProducts = session.AvailableProducts;
registration.SelectedCountryName = session.SelectedCountryName;
registration.SelectedStateName = session.SelectedStateName;
//Add a list of country for the dropdown menu in Step3's view
PopulateCountryDropdown(ref registration);
Session[RegistrationKey] = registration;
RegistrationVM registrationVM = registration;
return(View(registrationVM));
}
public async Task <IdentityResult> Register(RegistrationVM model)
{
var identityUser = new IdentityUser
{
Email = model.Email,
UserName = model.Email
};
var user = new User
{
FirstName = model.FirstName,
Lastname = model.LastName,
UserId = identityUser.Id
};
var result = await userManager.CreateAsync(identityUser, model.Password);
if (result.Succeeded)
{
orcaQuizContext.Users.Add(user);
await orcaQuizContext.SaveChangesAsync();
await signInManager.SignInAsync(identityUser, isPersistent : false);
}
return(result);
}
public HttpResponseMessage Delete(HttpRequestMessage request, RegistrationVM userVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var _user = _membershipService.DeleteUser(userVM.Username, userVM.Email);
if (_user != null && _user.Item1 != null)
{
response = request.CreateResponse(HttpStatusCode.OK,
new
{
message = _user.Item2,
success = true,
role = _user.Item1.UserRoles.FirstOrDefault().Role.Name,
email = _user.Item1.Email
});
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { message = _user.Item2, success = false });
}
return response;
}));
}
public static Account ToAccount(this RegistrationVM registration)
{
return(new Account
{
Login = registration.Login
});
}
public IHttpActionResult PostUser(RegistrationVM obj)
{
Users newUser = new Users()
{
Active = true,
BirthDate = obj.birthDate,
CountryID = obj.countryID,
Email = obj.email,
Password = obj.password,
Nickname = obj.nickname,
Username = obj.username
};
db.Users.Add(newUser);
db.SaveChanges();
UsersFollowing firstFollowing = new UsersFollowing()
{
DateModified = DateTime.Now,
FollowerID = newUser.UserID,
FollowingID = newUser.UserID
};
db.UsersFollowing.Add(firstFollowing);
db.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Register([FromBody] RegistrationVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorDto {
Data = string.Join(", ", ModelState.Values), ErrorCode = 400
}));
}
var user = _mapper.Map <AppUser>(model);
try
{
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(Ok(_mapper.Map <AppUserDto>(await _userManager.FindByEmailAsync(model.Email))));
}
return(StatusCode(401, new ErrorDto {
Data = string.Join(", ", result.Errors.Select(error => error.Description)), ErrorCode = 401
}));
}
catch (System.Exception ex)
{
_logger.LogError(ex, "Registration failed");
}
return(StatusCode(401, new ErrorDto {
Data = "Could not register", ErrorCode = 401
}));
}
public HttpResponseMessage Update(HttpRequestMessage request, RegistrationVM userVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
}
else
{
var _user = _membershipService.UpdateUser(userVM.Username, userVM.Email, userVM.Password);
if (_user != null && _user.Item1 != null)
{
response = request.CreateResponse(HttpStatusCode.OK,
new
{
message = _user.Item2,
success = true,
role = _user.Item1.UserRoles.FirstOrDefault().Role.Name,
email = _user.Item1.Email
});
}
else
{
response = request.CreateResponse(HttpStatusCode.OK, new { message = _user.Item2, success = false });
}
}
return response;
}));
}
public ActionResult Register(RegistrationVM user)
{
if (ModelState.IsValid)
{
using (var context = new QuoteContext())
{
//check database for existing username
if (context.ClientLogins.Any(x => x.Username == user.Username))
{
ModelState.AddModelError(string.Empty, "Username already exists");
return(View(user));
}
else
{
var newLogin = new ClientLogin();
newLogin.Username = user.Username;
newLogin.Password = user.Password;
var newClient = new Client();
newClient.ClientLogin = newLogin;
context.Clients.Add(newClient);
context.ClientLogins.Add(newLogin);
context.SaveChanges();
return(Redirect("/Account/Login"));
}
}
}
//Redirect to Login Page if model state valid
return(View());
}
public async Task <IActionResult> Registration(RegistrationVM model)
{
if (!ModelState.IsValid)
{
var response = await _eventiApi.GetCountryAsync();
model.Countries = response.Content.Data
.Select(i => new SelectListItem(i.Name, i.ID.ToString()))
.ToList();
return(View("Registration", model));
}
var registration = new ClientRegistrationRequest()
{
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.LastName,
CreditCardNumber = model.CreditCardNumber,
Email = model.Email,
Password = model.Password,
PhoneNumber = model.PhoneNumber,
Username = model.Username
};
await _authApi.ClientRegisterAsync(registration);
return(Redirect("/Login/Index"));
}
public async Task <IActionResult> Register(RegistrationVM registrationVM)
{
if (!ModelState.IsValid)
{
return(this.View(registrationVM));
}
var user = await this._userService.Register(registrationVM);
ThrowIfNull(user);
var confirmationToken = await this._userService.GetEmailConfirmationToken(user);
string confirmationLink = Url.Action(
"EmailValidation",
"User",
new { userId = user.Id, token = confirmationToken },
protocol: HttpContext.Request.Scheme);
var message = Regex.Replace(
registrationVM.ActivationEmailBody,
@"https:\/\/localhost:5001\/Identity\/User\/EmailValidation",
confirmationLink);
await this._emailSender.SendEmailAsync(user.Email, registrationVM.ActivationEmailSubjec, message);
return(this.RedirectToAction("RegistrationSuccess", new { userEmail = user.Email })
.WithSuccess("Регистрацията е създадена.", "Моля потвърдете имейла си преди за да се активира регистрацията."));
}
private void userName_Validate(object sender, ValidationEventArgs e)
{
e.IsValid = false;
registrationValid.userName = false;
if (string.IsNullOrEmpty(e.Value as string))
{
e.ErrorType = DevExpress.XtraEditors.DXErrorProvider.ErrorType.Information;
e.ErrorContent = "A felhasználónevet nem lehet üresen hagyni";
}
else
{
e.ErrorType = DevExpress.XtraEditors.DXErrorProvider.ErrorType.Critical;
if (e.Value.ToString().Length < 6)
{
e.ErrorContent = "A felhasználónévnek legalább 6 karaktert kell tartalmaznia";
}
else if (RegistrationVM.UserCheck(e.Value.ToString()))
{
e.ErrorContent = "A felhasználónévnek egyedinek kell lennie";
}
else
{
e.SetError("A mező tartalma megfelelő", DevExpress.XtraEditors.DXErrorProvider.ErrorType.User1);
registrationValid.userName = true;
}
}
pass.DoValidate();
ForceBinding(sender, e);
}
public ActionResult Step4GetInvoice(RegistrationVM registration)
{
var session = (RegistrationVM)Session[RegistrationKey];
if (registration.Step == (int)FromStep.Step3)
{
session.CustomerInformation = new Customer();
session.CustomerInformation = registration.CustomerInformation;
session.BillingAddress = new Address();
session.BillingAddress = registration.BillingAddress;
CreateCustomer(ref session);
CreateBillingAddress(session);
var returnedSubscription = CreateSubscription(session);
PutSubscription(returnedSubscription, session);
#region Find customer's country and state name
//We determine the name of the user's selected state and country based on the ID of the selected state and country, which are shown
//in Step4's view and Step5's view if "creditCardSameAsBilling" has been checked.
registration.ListOfCountriesCountry = new List <Country>();
registration.ListOfCountriesCountry = ApiClient.GetCountries();
//We post the customer's activation, which requireds the customerId, which has been stored in our Session
PostCustomerActivation(preview: true, session: ref session);
session.SelectedCountryName = (from country in registration.ListOfCountriesCountry
where country.Id == registration.BillingAddress.CountryId
select country.Name).First();
if (registration.BillingAddress.StateId != null)
{
session.SelectedStateName = (from country in registration.ListOfCountriesCountry
where country.Id == registration.BillingAddress.CountryId
from state in country.States
where state.Id == registration.BillingAddress.StateId
select state.Name).First();
}
#endregion
}
registration.BillingAddress = session.BillingAddress;
registration.CustomerInformation = session.CustomerInformation;
registration.SelectedPlanId = session.SelectedPlanId;
registration.SelectedPlanFrequencyID = session.SelectedPlanFrequencyID;
registration.AvailableProducts = session.AvailableProducts;
registration.SelectedCountryName = session.SelectedCountryName;
registration.SelectedStateName = session.SelectedStateName;
registration.ReturnedCustomer = session.ReturnedCustomer;
registration.ActivatedCustomer = session.ActivatedCustomer;
//We set the properties that will be displayed in Step4's view with the appropriate properties from the Session.
PrepareStep4View(ref registration, session);
Session[RegistrationKey] = session;
RegistrationVM registrationVM = registration;
return(View(registrationVM));
}
public async Task <object> Registration([FromBody] RegistrationVM model)
{
if (ModelState.IsValid)
{
try
{
if (!createdb(model.CompanyName))
{
return(Ok(new
{
success = false,
errorMessage = "Company Name is already exists!!!"
}));
}
var user = new Member
{
Name = model.Name,
Age = model.Age,
Phone = model.Phone,
Password = model.Password,
CompanyName = model.CompanyName
};
// CREATE USER
db.MemberTable.InsertOnSubmit(user);
db.SubmitChanges();
//if (result.Succeeded)
{
var c = db.MemberTable.FirstOrDefault();
return(Ok(new
{
success = true,
errorMessage = "Registration Succeeded"
}));
}
//else
//{
// return Ok(new
// {
// success = false,
// errorMessage = result.Errors
// });
//}
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
// If we got this far, something failed, redisplay form
var response = new
{
success = false,
errorMessage = "Registration failed"
};
return(Ok(response));
}
public bool CheckForExitedUserInDB(RegistrationVM model)
{
if (_aut.AuthenticateUser(model.Email, model.Password, 2, 2) != 0)
{
return(true);
}
return(false);
}
public async Task <IActionResult> Registration(RegistrationVM model)
{
IDTOModel userDTO = new DTOUser(model.NameOfUser, model.EmailOfuser);
await new FullDBManager().AddEntityToDb(userDTO);
return(RedirectToHomePage());
}
public async Task <IActionResult> Registration(RegistrationVM model)
{
bool isEmailExist = await _userManager.FindByEmailAsync(model.Email) == null;
//bool isEmailCorrect = model.Email != null && Regex.IsMatch(model.Email, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z", RegexOptions.IgnoreCase);
if (!isEmailExist)
{
ModelState.AddModelError("Email", "Така пошта уже є. Думай ...");
}
if (!isEmailExist)
{
return(View(model));
}
if (ModelState.IsValid)
{
string base64 = model.PhotoBase64;
if (base64.Contains(","))
{
base64 = base64.Split(',')[1];
}
var bmp = base64.FromBase64StringToImage();
var serverPath = _env.ContentRootPath; //Directory.GetCurrentDirectory(); //_env.WebRootPath;
var folerName = "Uploaded";
var path = Path.Combine(serverPath, folerName); //
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string ext = ".jpg";
string fileName = Path.GetRandomFileName() + ext;
string filePathSave = Path.Combine(path, fileName);
bmp.Save(filePathSave, ImageFormat.Jpeg);
var user = new DbUser
{
Email = model.Email,
UserName = model.Email,
PhoneNumber = model.PhoneNumber
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "User");
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Щось пішло не так.");
}
}
return(View(model));
}
public void LoadView(ViewTypeBegin typeViewBegin)
{
switch (typeViewBegin)
{
case ViewTypeBegin.Autorisation:
//загружаем вьюшку, ее вьюмодель
Autorisation autorisationView = new Autorisation();
autorisationVM = new AutorisationVM(this);
autorisationView.DataContext = autorisationVM;
//отображаем
this.ContentAutorisationRegistration.Content = autorisationView;
break;
case ViewTypeBegin.Registration:
//загружаем вьюшку, ее вьюмодель
Registration registrationViev = new Registration();
registrationVM = new RegistrationVM(this);
registrationViev.DataContext = registrationVM;
//отображаем
this.ContentAutorisationRegistration.Content = registrationViev;
break;
case ViewTypeBegin.MainWindow:
//загружаем вьюшку, ее вьюмодель
MainWindowVM mainWindowVM = null;
if (autorisationVM.IdUser != 0)
{
registrationVM = new RegistrationVM(this);
registrationVM.IdUser = 0;
mainWindowVM = new MainWindowVM(autorisationVM.IdUser);
}
if (registrationVM.IdUser != 0)
{
mainWindowVM = new MainWindowVM(registrationVM.IdUser);
}
MainWindow mainWindow = new MainWindow();
mainWindowVM.CodeBehind = mainWindow;
mainWindow.DataContext = mainWindowVM;
//отображаем
//mainWindow.ContentPresenterOutput.Content = mainWindow;
//this.ContentAutorisationRegistration.Content = autorisationView;
this.Close();
mainWindow.Show();
break;
}
/* private void OpenMainWindow()
* {
* MainWindow sellerWin = new MainWindow();
* SellerWindowVM vm = new SellerWindowVM(((dynamic)DataContext).LoginText);
* vm.CodeBehind = sellerWin;
* sellerWin.DataContext = vm;
* sellerWin.Show();
* Close();
* }*/
}
public ActionResult Create()
{
RegistrationVM registrationVM = new RegistrationVM();
registrationVM.SysteemRollen = _systeemRolRepository.GetAll();
return(PartialView("~/Views/Admin/Users/_Add.cshtml", registrationVM));
}
public async Task <IActionResult> RegisterAsync(RegistrationVM userModel)
{
const string userRoleName = "user";
if (ModelState.IsValid)
{
if (userModel == null)
{
return(BadRequest($"{nameof(userModel)} cannot be null"));
}
ApplicationUser appUser = _mapper.Map <ApplicationUser>(userModel);
appUser.UserName = userModel.Email;
appUser.UserProfile = new UserProfile
{
FullName = userModel.FullName,
IDNo = userModel.IDNo,
Gender = userModel.Gender,
ParentPhone = userModel.ParentPhone
};
string strURL = GetPaymentURL(PaymentProviders.PayTabs, userModel.FullName, userModel.Email);
//string strURL = GetPaymentURL(PaymentProviders.TelrPay, userModel.FullName, userModel.Email);
if (strURL != "")
{
return(Redirect(strURL));
return(RedirectToAction("ProcessPayment", new { strRefrence = strURL }));
}
//return Redirect(strURL);
{
var result = await _accountManager.CreateUserAsync(appUser, (new string[] { userRoleName }).Distinct(), userModel.Password);
if (result.Succeeded)
{
//string strURL = ProcessPayment(userModel.FullName, userModel.Email);
//if (strURL != "")
// return Redirect(strURL);
//return Content("<script>window.top.location.href = '" + strURL + "'; </script>");
//return RedirectToAction("Index", "Home");
//UserViewModel userVM = await GetUserViewModelHelper(appUser.Id);
//return CreatedAtAction(GetUserByIdActionName, new { id = userVM.Id }, userVM);
}
else
{
AddError(result.Errors);
return(View(userModel));
}
}
}
return(BadRequest(ModelState));
//return View(userModel);
}
public void Ack(string trainingMatchcode, string name, string email)
{
var vm = new RegistrationVM { TrainingMatchcode = trainingMatchcode, Name = name, Email = email };
_portal.SharedResponse = _portal.View["Registration.Ack.html", vm];
}
public void Show(string trainingMatchcode)
{
var vm = new RegistrationVM {TrainingMatchcode = trainingMatchcode};
Render(vm);
}
public void Retry(string trainingMatchcode, string name, string email, string error)
{
var vm = new RegistrationVM { TrainingMatchcode = trainingMatchcode, Name = name, Email = email, Error = error};
Render(vm);
}
private void Render(RegistrationVM vm)
{
_portal.SharedResponse = _portal.View["Registration.Main.html", vm];
}
