public string Post([FromBody] RegisterParams register)
{
string username = register.Username;
string password = register.Password;
string email = register.Email;
using (UserProfileServiceReference.UserProfileManagementServiceClient client = new UserProfileServiceReference.UserProfileManagementServiceClient())
{
string status_msg = null;
bool username_taken = client.IsUsernameTaken(username);
bool email_exists = client.UserWithEmailIdExists(email);
if (username_taken)
{
status_msg = "This username is unavailable :/. ";
throw new HttpResponseException(SetHttpErrorMsg(status_msg, HttpStatusCode.BadRequest));
}
if (email_exists)
{
status_msg = "An account with this email already exists -.- ";
throw new HttpResponseException(SetHttpErrorMsg(status_msg, HttpStatusCode.BadRequest));
}
UserProfileServiceReference.User user = new UserProfileServiceReference.User();
user.Username = username;
user.Password = password;
user.EmailID = email;
client.RegisterUser(user);
status_msg = "Registration Successful!";
return(status_msg);
}
}
public async Task <IActionResult> Register([FromBody] RegisterParams model)
{
try
{
var existingUser = await userManager.FindByEmailAsync(model.Email);
if (existingUser != null)
{
return(BadRequest(Response <string> .GetError(null, "User already exist")));
}
var result = accountService.CreateUser(model);
if (result.Succeeded)
{
var registerResponse = accountService.GetRegisterResponseObject(model);
return(Created("", Response <RegisterResponse> .GetSuccess(registerResponse)));
}
else
{
return(new BadRequestObjectResult(Response <Dictionary <string, string> >
.GetError(null, "There is one or more register error", accountService.GetIdentityErrorObject(result.Errors))));
}
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(StatusCode(500, Response <string> .GetError(null, "An error occured")));
}
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto register,
[FromQuery] RegisterParams registerParams)
{
if (await _authRepo.UserExist(register.Username))
{
ModelState.AddModelError("Username", "Username Already Exist");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User newUser = new User
{
Username = register.Username,
FirstName = register.FirstName,
LastName = register.LastName,
Phone = register.Phone,
Email = register.Email
};
User createdUser = await _authRepo.Register(newUser, register.Password);
return(StatusCode(201));
}
public async Task Register(RegisterParams param)
{
var user = mapper.Map <RegisterParams, UserAccount>(param);
await userSession.AddAsync(user);
await uow.CommitAsync();
}
public IdentityResult CreateUser(RegisterParams model)
{
User user = new User
{
UserName = model.UserName,
Email = model.Email
};
return(userManager.CreateAsync(user, model.Password).Result);
}
/// <summary>
/// Иницциирование одностадийной оплаты заказа
/// </summary>
public RegisterResponse Register(RegisterParams registerParams)
{
var url = _settings.BaseUrl + "/register.do";
RegisterRequest request = new RegisterRequest(registerParams)
{
userName = _settings.Username,
password = _settings.Password
};
var result = _networkClient.PostObjectViaUrlParams <RegisterResponse>(url, request);
return(result);
}
public RegisterRequest(RegisterParams registerParams)
{
this.orderNumber = registerParams.orderNumber;
this.amount = registerParams.amount;
this.currency = registerParams.currency;
this.returnUrl = registerParams.returnUrl;
this.failUrl = registerParams.failUrl;
this.description = registerParams.description;
this.language = registerParams.language;
this.pageView = registerParams.pageView;
this.clientId = registerParams.clientId;
this.merchantLogin = registerParams.merchantLogin;
this.jsonParams = registerParams.jsonParams;
this.sessionTimeoutSecs = registerParams.sessionTimeoutSecs;
this.expirationDate = registerParams.expirationDate;
this.bindingId = registerParams.bindingId;
this.features = registerParams.features;
}
public IHttpActionResult Post([FromBody] RegisterParams Param)
{
User Result = new User();
UserResultParams U = new UserResultParams();
if (Param == null)
{
return(new RawJsonActionResult(Newtonsoft.Json.JsonConvert.SerializeObject(Result)));
}
if (Param.ServiceKey != BaseObjects.SERVICE_PASS)
{
return(new RawJsonActionResult(Newtonsoft.Json.JsonConvert.SerializeObject(Result)));
}
U = Result.register(Param.Mobile, Param.Password, Param.Name, Param.SecurityQuestionID, Param.SecurityQuestionAnswer);
return(new RawJsonActionResult(Newtonsoft.Json.JsonConvert.SerializeObject(U)));
}
public void PaymentOrderBinding_Ok_Test()
{
var client = new SbrfApiClient(_settings);
var orders = client.GetLastOrdersForMerchants(new GetLastOrdersForMerchantsParams
{
from = "20180101010101",
transactionStates = "DEPOSITED",
to = "20191231010101",
size = 100,
merchants = "orientirum",
});
var orderWithBinding = orders.orderStatuses.FirstOrDefault(o => o.bindingInfo != null);
Assert.IsNotNull(orderWithBinding);
// создаём новый заказ с заданным bindingId. Типа заказ предполагает,
// что его будут оплачивать по связкам
var registerParams = new RegisterParams
{
amount = 123,
pageView = "DESKTOP",
currency = 643,
failUrl = "http://33kita.ru",
returnUrl = "http://33kita.ru",
orderNumber = Guid.NewGuid().ToString().Replace("-", ""),
bindingId = orderWithBinding.bindingInfo.bindingId,
features = "AUTO_PAYMENT"
};
// регистрируем новый заказ
var registerResult = client.Register(registerParams);
// проводим только что созданны заказ с bindingId одного из предыдущих заказов
var bindingPaymentResult = client.PaymentOrderBinding(new PaymentOrderBindingParams
{
mdOrder = registerResult.OrderId, //orderWithBinding.merchantOrderParams.First(p => p.name == "mdOrder").value,
bindingId = orderWithBinding.bindingInfo.bindingId,
ip = "192.168.0.1"
});
Assert.IsTrue(bindingPaymentResult.errorCode == 0);
}
public void Register(string email, string username, string password, Action <FormValidation> callback)
{
var param = new RegisterParams
{
email = email,
username = username,
password = password
};
FormatResult(Call("api/register", Method.POST, param)).Then(result =>
{
if (result.success)
{
callback(null);
}
else
{
callback(result.data.ToObject <FormValidation>());
}
});
}
protected void Register_Click(object sender, EventArgs e)
{
RegisterParams register = new RegisterParams();
register.Username = Username.Text;
register.Email = EmailID.Text;
register.Password = Password.Text;
try
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(WebConfigurationManager.AppSettings.Get("api-base-url"));
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
Task <HttpResponseMessage> task = client.PostAsJsonAsync("register", register);
HttpResponseMessage response = task.Result;
if (response.IsSuccessStatusCode)
{
Task <string> token_task = response.Content.ReadAsStringAsync();;
string token = token_task.Result;
StatusMsg.ForeColor = System.Drawing.Color.Green;
StatusMsg.Text = "Registration Successful! Redirecting you to Login page ...";
Response.AddHeader("REFRESH", "3;URL=Login.aspx");
}
else
{
Task <string> error_task = response.Content.ReadAsStringAsync();;
string error = error_task.Result;
StatusMsg.ForeColor = System.Drawing.Color.Red;
StatusMsg.Text = error;
}
}
catch (Exception ex)
{
StatusMsg.ForeColor = System.Drawing.Color.Red;
StatusMsg.Text = ex.Message + " " + ex.GetBaseException() + " " + ex.ToString();
}
}
public IActionResult Register([FromBody] RegisterParams par)
{
NEEOEnvironment.Logger.LogInformation($"Register {par.Name} - {par.BaseUrl}");
Task.Run(async() => await ReadDevice(par.BaseUrl));
return(Ok());
}
public IActionResult UnRegister([FromBody] RegisterParams par)
{
return(Ok());
}
public RegisterResponse GetRegisterResponseObject(RegisterParams model)
{
return(mapper.Map <RegisterResponse>(model));
}
