public async Task <IActionResult> CreateClient([FromBody] RegisterEntity model)
{
if (model == null)
{
return(BadRequest("Some User Info are missing or not as requested"));
}
var user = _mapper.Map <AppUser>(model);
user.Roles.Add("Client");
if (!ModelState.IsValid)
{
return(new ModelValidator.UnprocessableEntityObjectResult(ModelState));
}
if ((_AppUserService.checkbyusername(model.UserName)))
{
return(BadRequest("user name allready used"));
}
else if (_AppUserService.checkbyuseremail(model.Email))
{
return(BadRequest("E-mail allready used"));
}
else
{
var creuser = await _AppUserService.CreateClient(user, model.Password.ToString());
var result = _mapper.Map <UserResponse>(creuser);
return(CreatedAtRoute("GetAppUser", new { id = user.Id.ToString() }, result));
}
}
public JsonResult Register(UserIdentityCreateModel identityCreateModel)
{
identityCreateModel.PhoneId = "+919667286111";
identityCreateModel.IsTwoFactorAuthenticationEnabled = true;
identityCreateModel.Password = "******";
identityCreateModel.UserName = "******";
foreach (var item in identityCreateModel.Email)
{
var Type = item.Type;
var Value = item.Value;
}
SottDetails _SottDetails = new SottDetails();
_SottDetails.Sott = new Sott();
//_SottDetails.Sott.StartTime = DateTime.UtcNow.ToString();
//_SottDetails.Sott.EndTime = DateTime.UtcNow.AddMinutes(10).ToString();
_SottDetails.Sott.StartTime = null;
_SottDetails.Sott.EndTime = null;
_SottDetails.Sott.TimeDifference = "10";
var apiResponse = new RegisterEntity().RegisterCustomer(identityCreateModel, _apiOptionalParams, _SottDetails);
_apiOptionalParams.VerificationUrl = "VerificationUrl";
return(Json(apiResponse, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 添加注册的日志
/// </summary>
/// <param name="accesstoken">当前注册用户的Accesstoken</param>
/// <param name="registerMode">注册的模式</param>
public void AppendRegister(int registerMode, string accesstoken)
{
//获取应用的AccessToken
if (!HttpContext.Current.IsAvailable())
{
return;
}
if (String.IsNullOrEmpty(accesstoken))
{
return;
}
RegisterEntity entry = new RegisterEntity();
entry.AccessToken = accesstoken;
entry.RegisterMode = registerMode;
if (isDebug)
{
GathererLogger.Instance.Write(String.Format("Token:{0},RegisterMode:{1}",
accesstoken, registerMode));
}
LogSender.Append(entry);
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
Name = model.Name,
LastName = model.LastName,
City = model.City,
UserName = model.Email,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = BuildToken(user);
var rootData = new SignUpResponse(token, user.UserName, user.Email);
return(Created("api/v1/user/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = new UserModel {
FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = AuthenticationHelper.GenerateJwtToken(model.Email, user, _config);
var rootData = new SignUpResponse(token, user.UserName, user.Email);
db.InsertRecord(tableName, user);
return(Created("api/contacts/register", rootData));
}
//db.InsertRecord(tableName, user);
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
private RegisterEntity GetUsuarioMock()
{
var telefones = new List <EntityPhone>
{
new EntityPhone()
{
Number = 18235186,
AreaCode = 213,
CountryCode = "+55"
},
new EntityPhone()
{
Number = 789856756,
AreaCode = 213,
CountryCode = "+55"
}
};
var novoUsuario = new RegisterEntity()
{
Name = "joao",
LastName = "neves",
Email = "*****@*****.**",
Password = "******",
Phones = telefones
};
return(novoUsuario);
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (!ModelState.IsValid)
{
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signInManager.SignInAsync(user, false);
var token = AuthenticationHelper.GenerateJwtToken(user, _configuration);
var rootData = new SignUpResponse(token, user.UserName, user.Email, user.Id);
return(Ok(rootData));
}
public RegisterModel UserAuth(LoginModel lm)
{
RegisterEntity re = ((RegisterRepository)_registerRepo).GetFromLogin(lm.Login, lm.Password);
if (re == null)
{
return(null);
}
if (re != null)
{
PaysListModel plm = new PaysListModel();
return(new RegisterModel()
{
Nom = re.Nom,
Prenom = re.Prenom,
Login = re.Login,
Email = re.Email,
Telephone = re.Telephone,
Pays = re.Libelle,
IdMembre = re.IdMembre,
Photo = re.Photo
});
}
else
{
return(null);
}
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = new Director {
Name = model.Name, LastName = model.LastName, City = model.City, UserName = model.Email, Email = model.Email, PhoneNumber = model.PhoneNumber
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Director");
await _userManager.UpdateSecurityStampAsync(user);
await _signInManager.SignInAsync(user, false);
var token = AuthenticationHelper.GenerateJwtToken(model.Email, user, "Director", _configuration);
var rootData = new SignUpResponse(token, user.UserName, user.Email);
return(Created("api/director/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var userRole = await _roleManager.FindByNameAsync("User");
if (userRole == null)
{
userRole = new ApplicationRole("User");
await _roleManager.CreateAsync(userRole);
}
var user = new ApplicationUser {
Name = model.Name, LastName = model.LastName, City = model.City, UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
await _userManager.AddToRoleAsync(user, userRole.Name);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = await AuthenticationHelper.GenerateJwtToken(model.Email, user, _configuration, _userManager);
var rootData = new SignUpResponse(token, user.UserName, user.Email);
return(Created("api/authentication/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
public static List <RegisterEntity> GetRegister(RegisterEntity registerEntity)
{
List <RegisterEntity> registersEntity = new List <RegisterEntity>();
try
{
using (SqlCommand command = new SqlCommand())
{
command.CommandText = "RegisterMasterSel";
command.CommandType = CommandType.StoredProcedure;
SqlParameter param1 = new SqlParameter("@RegisterName", registerEntity.Name);
command.Parameters.Add(param1);
using (DataTable dt = DataAccess.GetData(command))
{
foreach (DataRow dr in dt.Rows)
{
registersEntity.Add(GetRow(dr));
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(registersEntity);
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
Name = model.Name, LastName = model.Name, UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = await this.GenerateJSONWebToken(model.Email, user);
DateTime expirationDate = this.GetExpirationDate();
var rootData = new UserDataResponse(token, user.UserName, user.Email, expirationDate);
return(Created("api/v1/authentication/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
Log.Warning(errorMessage ?? "Bad Request");
return(BadRequest(errorMessage ?? "Bad Request"));
}
public static RegisterEntity GetRegByEmail(RegisterEntity entity)
{
RegisterEntity registerEntity = new RegisterEntity();
try
{
using (SqlCommand command = new SqlCommand())
{
command.CommandText = "RegisterMasterSel";
command.CommandType = CommandType.StoredProcedure;
SqlParameter param1 = new SqlParameter("@RegisterEmail", entity.Email);
command.Parameters.Add(param1);
using (DataTable dt = DataAccess.GetData(command))
{
foreach (DataRow dr in dt.Rows)
{
registerEntity = GetRow(dr);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(registerEntity);
}
private HttpRequestMessage RegistrarRequestHttpMessage(RegisterEntity usuario)
{
return(new HttpRequestMessage(new HttpMethod("POST"), "user/signup")
{
Headers = { { "X-Version", "1" } },
Content = new ObjectContent <RegisterEntity>(usuario, new JsonMediaTypeFormatter(), "application/json")
});
}
public bool EditMemberPhoto(RegisterModel rm)
{
RegisterEntity re = new RegisterEntity();
re.IdMembre = rm.IdMembre;
re.Photo = rm.Photo;
return(((RegisterRepository)_registerRepo).UpdatePhoto(re));
}
public bool SaveSignUp(RegisterModel rm, PaysListModel plm)
{
RegisterEntity r = new RegisterEntity();
r.Nom = rm.Nom;
r.Prenom = rm.Prenom;
r.Email = rm.Email;
r.Login = rm.Login;
r.Password = rm.Password;
r.Telephone = rm.Telephone;
r.IdPays = plm.IdPays;
r.IdMembre = rm.IdMembre;
return(_registerRepo.Insert(r));
}
private static RegisterEntity GetRow(DataRow dr)
{
RegisterEntity registerEntity = new RegisterEntity {
Id = DataConvert.ToInt(dr["Id"]),
Name = DataConvert.ToString(dr["Name"]),
Email = DataConvert.ToString(dr["Email"]),
CreatedAt = DataConvert.ToDateTime(dr["CreatedAt"]),
CreatedByUserId = DataConvert.ToString(dr["CreatedBy"]),
UpdatedAt = DataConvert.ToDateTime(dr["UpdatedAt"]),
UpdatedByUserId = DataConvert.ToString(dr["UpdatedBy"]),
IsActive = DataConvert.ToBoolean(dr["IsActive"])
};
return(registerEntity);
}
public static ApplicationUser MapperApplicationUserToUserDataResponse(RegisterEntity model)
{
var user = new ApplicationUser
{
FirstName = model.Name,
LastName = model.LastName,
UserName = model.Email,
Email = model.Email,
CreatedAt = DateTime.Now,
LastLogin = DateTime.Now,
Phones = Utils.MapperEntitiesPhoneToPhones(model.Phones)
};
return(user);
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
try
{
if (ModelState.IsValid)
{
var userDb = new ApplicationUser(
model.Email, model.Email, model.Name, model.LastName,
hash.HashPassword(model.Password), null
);
var userExists =
//await _uow.UserRepository.Query($"UserName = '******'");
await _uow.UserRepository.Query("UserName = @Email", new { Email = model.Email });
if (userExists.Any())
{
return(BadRequest("E-mail " + model.Email + " já registrado."));
}
var defaultRole = _configuration.GetValue <string>("DefaultRole");
var roleDb = await _uow.RoleRepository.Query("Name = @Name", new { Name = defaultRole });
_uow.UserRepository.Add(userDb);
_uow.UserRoleRepository.Add(new ApplicationUserRole(userDb, roleDb.FirstOrDefault()));
if (!_uow.Commit())
{
return(BadRequest("Ocorreu um erro ao gravar no banco de dados."));
}
var token = TokenService.GenerateToken(userDb, roleDb.ToList());
var expirationTime = DateTime.Now.AddHours(HashingOptions.ExpirationInHours);
return(Ok(new LoginResponse(userDb.ApplicationUserId, userDb.Email, userDb.UserName, userDb.Name,
userDb.LastName,
roleDb.ToList(), token, expirationTime.ToString())));
}
string errorMessage =
string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
catch (Exception e)
{
return(BadRequest("Erro: " + e.Message));
}
}
public async Task <bool> UpdateTeamShareCodeAsync(long id, string codeUrl)
{
using (MyDbContext dbc = new MyDbContext())
{
RegisterEntity entity = await dbc.GetAll <RegisterEntity>().SingleOrDefaultAsync(u => u.Id == id);
if (entity == null)
{
return(false);
}
entity.TeamShareCode = codeUrl;
await dbc.SaveChangesAsync();
return(true);
}
}
public ActionResult RegisterMember(RegisterEntity model)
{
BaseUserService userService = new BaseUserService();
ReturnEntity <bool> data = new ReturnEntity <bool>
{
Status = false
};
if (string.IsNullOrWhiteSpace(model.Account))
{
data.Msg = "帐号未填写";
}
else if (string.IsNullOrWhiteSpace(model.Pwd))
{
data.Msg = "密码未填写";
}
else if (userService.GetAccoutExistCheck(model.Account))
{
data.Msg = "该帐号已存在！";
}
else
{
BaseUser user = new BaseUser
{
Account = model.Account,
Pwd = EncryptionHelper.Md5(model.Pwd),
RoleType = 0,
ProfessionId = 0
};
bool flag = userService.Add(user);
if (flag)
{
//记录session
MemberEntity member = new MemberEntity
{
UserId = user.Id,
Account = user.Account,
ProfessionId = user.ProfessionId.GetValueOrDefault()
};
SessionData.Member.LoginedUser = member;
data.Msg = "注册成功！";
data.Status = true;
}
}
return(JsonCResult(data));
}
public async Task <ActionResult <User> > Register(RegisterEntity registerEntity)
{
bool isEmailUsed = await _repository.IsEmailUsed(_cryptService.EncryptString(registerEntity.Email));
if (isEmailUsed)
{
return(BadRequest("Email already used!"));
}
User user = new User
{
FirstName = _cryptService.EncryptString(registerEntity.FirstName),
LastName = _cryptService.EncryptString(registerEntity.LastName),
Email = _cryptService.EncryptString(registerEntity.Email),
Password = _cryptService.EncryptString(registerEntity.Password)
};
await _repository.AddUser(user);
return(CreatedAtAction("GetById", new { id = user.Id }, user));
}
public void Register([FromBody] RegisterEntity register)
{
// generate a 128-bit salt using a secure PRNG
byte[] salt = new byte[128 / 8];
using (var rng = RandomNumberGenerator.Create())
{
rng.GetBytes(salt);
}
// derive a 256-bit subkey (use HMACSHA1 with 10,000 iterations)
string hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(
password: register.Password,
salt: salt,
prf: KeyDerivationPrf.HMACSHA1,
iterationCount: 10000,
numBytesRequested: 256 / 8));
UserEntity user = new UserEntity(register.Email, Convert.ToBase64String(salt), hashed, register.Username, register.IsAdmin);
_dinerContext.Add(user);
_dinerContext.SaveChanges();
}
public async Task <IActionResult> Register(RegisterEntity _user)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
FirstName = _user.FirstName, LastName = _user.LastName, UserName = _user.Email, Email = _user.Email
};
var result = await _userManager.CreateAsync(user, _user.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(Ok(user));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
var errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
private static RegisterEntity InsertUpdate(RegisterEntity registerEntity, DatabaseAccessKey databaseAccessKey)
{
try
{
using (SqlCommand command = new SqlCommand())
{
command.CommandText = "RegisterMasterAction";
command.CommandType = CommandType.StoredProcedure;
SqlParameter RegisterName = new SqlParameter("@RegisterName", registerEntity.Name);
command.Parameters.Add(RegisterName);
SqlParameter RegisterEmail = new SqlParameter("@RegisterEmail", registerEntity.Email);
command.Parameters.Add(RegisterEmail);
SqlParameter User = new SqlParameter("@User", registerEntity.CreatedByUserId);
command.Parameters.Add(User);
SqlParameter IsActive = new SqlParameter("@IsActive", registerEntity.IsActive);
command.Parameters.Add(IsActive);
SqlParameter RegisterId = new SqlParameter("@RegisterId", registerEntity.Id);
command.Parameters.Add(RegisterId);
SqlParameter ActionMode = new SqlParameter("@ActionMode", databaseAccessKey);
command.Parameters.Add(ActionMode);
using (DataTable dt = DataAccess.GetData(command))
{
foreach (DataRow dr in dt.Rows)
{
registerEntity.Id = DataConvert.ToInt(dr["Id"]);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(registerEntity);
}
public async Task <UserDataResponse> Register(RegisterEntity user)
{
var response = await _client.PostAsJsonAsync($"{_client.BaseAddress}api/v1/Users/Register", user);
if (response.StatusCode == System.Net.HttpStatusCode.Created)
{
var content = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <UserDataResponse>(content);
data.StatusCode = response.StatusCode;
return(data);
}
string error;
switch (response.StatusCode)
{
case HttpStatusCode.Unauthorized:
error = "Unauthorized Access";
break;
case HttpStatusCode.BadRequest:
error = "Bad Request";
break;
case HttpStatusCode.InternalServerError:
error = "Internal Server Error";
break;
default:
error = "Undefined Error Occured";
break;
}
UserDataResponse failedResponse = new UserDataResponse(error, null, null, new DateTime());
failedResponse.StatusCode = response.StatusCode;
return(failedResponse);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.Register);
EditText storeNameText = FindViewById <EditText>(Resource.Id.editTextStoreName);
EditText storeUsernameText = FindViewById <EditText>(Resource.Id.editTextUserName);
EditText storeEmailText = FindViewById <EditText>(Resource.Id.editTextEmail);
EditText storeAddressText = FindViewById <EditText>(Resource.Id.editTextAddress);
EditText storePasswordText = FindViewById <EditText>(Resource.Id.textViewPassword);
Button btnRegisterStore = FindViewById <Button>(Resource.Id.button1);
Firebase.FirebaseApp.InitializeApp(this);
FirebaseIIDService fireService = new FirebaseIIDService();
btnRegisterStore.Click += async(sender, e) =>
{
try
{
UserDTO userinfo = new UserDTO();
userinfo.Active = true;
userinfo.Address = storeAddressText.Text;
userinfo.Email = storeEmailText.Text;
userinfo.Password = storePasswordText.Text;
userinfo.StoreName = storeNameText.Text;
userinfo.Username = storeUsernameText.Text;
RegisterEntity registerEntity = new RegisterEntity {
AuthToken = "", UserInfo = userinfo
};
JsonValue json = await HttpRequestHelper <RegisterEntity> .POSTreq(ServiceTypes.RegisterStore, registerEntity);
ParseJSON(json);
}
catch (Exception ex)
{
}
};
}
public async Task Create(RegisterModel registerModel)
{
try
{
string partitionKey = registerModel.Login.Substring(0, 1).ToUpper();
string rowKey = registerModel.Login;
RegisterEntity registerEntity = new RegisterEntity(partitionKey, rowKey);
registerEntity.User = registerModel.User;
registerEntity.Login = registerModel.Login;
registerEntity.Password = registerModel.Password;
LoginEntity loginEntity = new LoginEntity(partitionKey, rowKey);
loginEntity.Login = registerModel.Login;
loginEntity.Password = registerModel.Password;
UserEntity userEntity = new UserEntity(partitionKey, rowKey);
userEntity.User = registerModel.User;
userEntity.Login = registerModel.Login;
registerEntity.Password = null;
TableOperation insertRegisterEntityOp = TableOperation.InsertOrReplace(registerEntity);
await _registerTable.ExecuteAsync(insertRegisterEntityOp);
TableOperation insertLoginEntityOp = TableOperation.InsertOrReplace(loginEntity);
await _loginTable.ExecuteAsync(insertLoginEntityOp);
TableOperation insertUserEntityOp = TableOperation.InsertOrReplace(userEntity);
await _userTable.ExecuteAsync(insertUserEntityOp);
}
catch (Exception exception)
{
throw exception;
}
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = Utils.MapperApplicationUserToUserDataResponse(model);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = AuthenticationHelper.GenerateJwtToken(model.Email, user, _configuration);
var rootData = new RegisterResponse(token, user.UserName, user.Email);
return(Created("user/register", rootData));
}
return(BadRequest(result.Errors.ReturnErrorDetailsHandlingIdentityErrors()));
}
return(BadRequest(new ErrorDetails()
{
Message = Startup.StaticConfig["MessagesError:MissingFields"],
ErrorCode = Convert.ToInt32(Startup.StaticConfig["MessagesError:MissingFieldsErrorCode"])
}));
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
Name = model.Name, Farm = model.Farm, UserName = model.UserName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = AuthenticationHelper.GenerateJwtToken(model.UserName, user, _configuration);
var rootData = new SignUpResponse(token, user.UserName);
return(Created("api/authentication/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
