public string Create([FromBody] UserCreateModel userCreateModel)
{
try
{
User user = new User {
Name = userCreateModel.name, Password = userCreateModel.password, Points = 0
};
db.users.Add(user);
db.SaveChanges();
return(user.UserID);
} catch (Exception e)
{
return("!ThisMightBeAnErrorBeCarefull!");
}
}
public void NotCreateUserWhenModelError()
{
_sut.ModelState.AddModelError("x", "Model Error");
var userCreateModel = new UserCreateModel
{
FirstName = "Jess"
};
IActionResult result = _sut.CreateUser(userCreateModel);
_mockedRepository.Verify(
x => x.AddGameUser(It.IsAny <GameUser>(), It.Is <string>(p => p == userCreateModel.Password)), Times.Never);
UnprocessableEntityObjectResult badResult = Assert.IsType <UnprocessableEntityObjectResult>(result);
Assert.Equal(422, badResult.StatusCode);
}
public UserReturnModel Register(UserCreateModel userData)
{
//Generate an Id
Guid g;
g = Guid.NewGuid();
string id = g.ToString();
string pass = Bcrypt.net.bcrypt.hashpassword(userdata.Password);
//Construct a user
User user = new User()
{
Id = id,
Name = userData.Name,
Email = userData.Email,
Password = pass // encrypt it
};
//Run a sql command to insert
var success = _db.Execute(@"
INSERT INTO users(
id,
name,
email,
password)
values
(@Id,
@Name,
@Email,
@Password)
)
", user);
if (success < 1)
{
throw new Exception("EMAIL IN USE"); // SHOULD BE IN TRY-CATCH
}
//Cound send here sendUserRegEmail();
//create and return a user return model
return(new UserReturnModel()
{
Name = user.Name,
Email = user.Email,
Id = user.Id
});
// can call set claims, saving context - in the controller.
//best to use a try-catch stmt for above
}
public IResponse <NoValue> AddUser(UserCreateModel createModel, string userId)
{
Logger.Message($"Adduser({createModel.Username}, {userId})");
var result = new Response <NoValue>();
try
{
var user = new User
{
Username = createModel.Username,
FirstName = createModel.FirstName,
LastName = createModel.LastName,
Email = createModel.Email,
City = createModel.City,
Street = createModel.Street,
StreetNumber = createModel.StreetNumber,
AdressInfo = createModel.AdressInfo,
Password = createModel.Password,
ZipCode = createModel.ZipCode,
CreatedDate = DateTime.UtcNow,
DateOfBirth = createModel.DateOfBirth,
Gender = (int)createModel.Gender,
PointBalance = 0
};
_uow.Users.Add(user);
_uow.Complete();
result.Status = Status.Success;
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException.InnerException != null && ex.InnerException.InnerException.Message.Contains("duplicate key"))
{
result.Message = Message.UniqueName;
}
else
{
result.Message = Message.SomethingWrongError;
}
result.Status = Status.Error;
Logger.ErrorWithException(ex);
}
return(result);
}
public string AddUser(UserCreateModel userCreateModel)
{
// validate input
if (string.IsNullOrWhiteSpace(userCreateModel.UserName))
{
return("Invalid User Name");
}
if (string.IsNullOrWhiteSpace(userCreateModel.UserEmail))
{
return("Invalid User email");
}
if (string.IsNullOrWhiteSpace(userCreateModel.UserAddress))
{
return("Invalid User address");
}
if (string.IsNullOrWhiteSpace(userCreateModel.MobileNo))
{
return("Invalid User mobile");
}
if (string.IsNullOrWhiteSpace(userCreateModel.AdditionalInfo))
{
return("Invalid User additional info");
}
if (userCreateModel.DateOfBirth == null || userCreateModel.DateOfBirth == default(DateTime))
{
return("Invalid User date of birth");
}
// query for inserting user
var query = $"insert into Users(UserId, UserName,MobileNo, UserEmail, UserAddress,DateOfBirth, AdditionalInfo, CreateDate" +
$" )values(@pUserId, @pUserName, @pMobilrNo, @pUserEmail, @pAddress, @pDateOfBirth, @pAdditionInfo, @pCreateDate)";
var sqlParameters = new SqlParameter[]
{
new SqlParameter("@pUserId", Guid.NewGuid()),
new SqlParameter("@pUserName", userCreateModel.UserName),
new SqlParameter("@pMobilrNo", userCreateModel.MobileNo),
new SqlParameter("@pUserEmail", userCreateModel.UserEmail),
new SqlParameter("@pAddress", userCreateModel.UserAddress),
new SqlParameter("@pDateOfBirth", userCreateModel.DateOfBirth),
new SqlParameter("@pAdditionInfo", userCreateModel.AdditionalInfo),
new SqlParameter("@pCreateDate", DateTime.UtcNow)
};
var result = SqlHelper.ExecuteNonQuery(query, sqlParameters);
return(result);
}
public IActionResult Registration(UserCreateModel userCreateModel)
{
var validator = new UserCreateValidator();
if (validator.Validate(userCreateModel).IsValid)
{
var accountBL = new AccountBL(_uow, _mapper);
if (accountBL.Registration(userCreateModel))
{
return(RedirectToAction("Login", new UserLoginModel
{
Email = userCreateModel.Email,
Password = userCreateModel.Password
}));
}
}
return(View(userCreateModel));
}
public async Task Post_should_create_user_With_valid_data_and_postal_code_not_found_Must_return_user_created_Async()
{
var user = new UserCreateModel()
{
Document = "45166568095",
FirstName = "FirstName",
LastName = "LastName",
PostalCode = "14804412"
};
httpMockServer.Reset();
httpMockServer.Given(Request.Create().WithPath($"/ws/{user.PostalCode}/json").UsingGet())
.RespondWith(Response.Create().WithStatusCode(204).WithBody(@""));
var request = await PostAsync("api/User", user);
Assert.Equal(HttpStatusCode.Created, request.StatusCode);
}
public bool CreateUser(UserRegisterBindingModel userModel)
{
using (this.userRepository)
{
bool isUserWithSameUsernameExisting = this.userRepository.IsUserWithSameUsernameExisting(userModel.Username);
if (isUserWithSameUsernameExisting)
{
return(false);
}
string passwordSalt = PasswordUtilities.GeneratePasswordSalt();
string passwordHash = PasswordUtilities.GeneratePasswordHash(userModel.Password, passwordSalt);
UserCreateModel user = new UserCreateModel(userModel.Username, userModel.Name, passwordHash, passwordSalt);
bool createUserResult = this.userRepository.CreateUser(user);
return(createUserResult);
}
}
public IActionResult Create([FromForm] UserCreateModel model)
{
List <Dictionary <string, string> > lst = DB.Query($"SELECT * FROM user WHERE name = '{model.Username}'");
if (lst.Count > 0)
{
return(BadRequest(new { title = "User already exists.", status = 400 }));
}
SHA384 sha = SHA384.Create();
byte[] bSalt = sha.ComputeHash(Guid.NewGuid().ToByteArray());
string salt = BitConverter.ToString(bSalt).Replace("-", "");
string saltedPassword = DB.SaltedPassword(model.Password, salt);
DB.Query($"INSERT INTO user (`name`,`hash`,`role`,`salt`)VALUES('{model.Username}','{saltedPassword}','{model.Role}','{salt}')");
return(CreatedAtAction("Create", null));
}
public ActionResult Create(UserCreateModel userCreateModel)
{
//service.Create(userViewModel.ToBllUser());
//return RedirectToAction("Index");
if (ModelState.IsValid)
{
if (service.GetByPredicate(u => u.Email == userCreateModel.Email).FirstOrDefault() != null)
{
ModelState.AddModelError("Email", "Email already registered");
}
else if (((CustomMembershipProvider)Membership.Provider).CreateUser(userCreateModel) == null)
{
ModelState.AddModelError(string.Empty, "Registration error");
}
else
{
FormsAuthentication.SetAuthCookie(userCreateModel.Email, false);
return RedirectToAction("Index", "Home");
}
}
return View(userCreateModel);
}
public ActionResult Create(UserCreateModel model)
{
if ((Request.IsAuthenticated && !User.IsInRole(Definitions.Roles.Administrator)) || (!Request.IsAuthenticated && !UserConfiguration.Current.AllowAnonymousRegistration))
{
return RedirectToAction("Unauthorized", "Home");
}
while (!String.IsNullOrEmpty(model.Username) && model.Username.Last() == ' ')
{
model.Username = model.Username.Substring(0, model.Username.Length - 1);
}
if (ModelState.IsValid)
{
if (MembershipService.CreateUser(model.Username, model.Password, model.Name, model.Surname, model.Email))
{
if (User.IsInRole(Definitions.Roles.Administrator))
{
TempData["CreateSuccess"] = true;
return RedirectToAction("Index");
}
else
{
AuthenticationProvider.SignIn(model.Username, Url.Action("Index", "Home"));
return new EmptyResult();
}
}
else
{
ModelState.AddModelError("Username", Resources.Account_Create_AccountAlreadyExists);
}
}
return View(model);
}
public void Update(UserCreateModel model)
{
var entity = UserManager.FindById(model.Id);
entity.UserName = model.Email;
entity.FirstName = model.FirstName;
entity.LastName = model.LastName;
entity.Email = model.Email;
entity.PhoneNumber = model.PhoneNumber;
entity.Address = model.Address;
entity.Others = model.Others;
entity.Website = model.Website;
entity.Files = ManageFiles(model);
#region Manage Educations
foreach (var m in model.Educations.Where(m => string.IsNullOrEmpty(m.UserId)))
{
m.UserId = model.Id;
}
foreach (var education in model.Educations)
{
_educationRepository.InsertOrUpdate(_modelFactory.MapToDomain<EducationModel, Education>(education, null));
}
foreach (var m in entity.Educations.Where(y => model.Educations.FirstOrDefault(x => x.Id == y.Id) == null))
{
_educationRepository.Delete(m.Id);
}
_educationRepository.Save();
#endregion
#region Manage Experiences
foreach (var m in model.Experiences.Where(m => string.IsNullOrEmpty(m.UserId)))
{
m.UserId = model.Id;
}
foreach (var m in model.Experiences)
{
_experienceRepository.InsertOrUpdate(_modelFactory.MapToDomain<ExperienceModel, Experience>(m, null));
}
foreach (var m in entity.Experiences.Where(y => model.Experiences.FirstOrDefault(x => x.Id == y.Id) == null))
{
_experienceRepository.Delete(m.Id);
}
_experienceRepository.Save();
#endregion
#region Manage Projects
foreach (var m in model.Projects.Where(m => string.IsNullOrEmpty(m.UserId)))
{
m.UserId = model.Id;
}
foreach (var m in model.Projects)
{
_projectRepository.InsertOrUpdate(_modelFactory.MapToDomain<ProjectModel, Project>(m, null));
}
foreach (var m in entity.Projects.Where(y => model.Projects.FirstOrDefault(x => x.Id == y.Id) == null))
{
_projectRepository.Delete(m.Id);
}
_projectRepository.Save();
#endregion
#region Manage Skills
foreach (var m in model.Skills.Where(m => string.IsNullOrEmpty(m.UserId)))
{
m.UserId = model.Id;
}
foreach (var m in model.Skills)
{
_skillRepository.InsertOrUpdate(_modelFactory.MapToDomain<SkillModel, Skill>(m, null));
}
foreach (var m in entity.Skills.Where(y => model.Skills.FirstOrDefault(x => x.Id == y.Id) == null))
{
_skillRepository.Delete(m.Id);
}
_skillRepository.Save();
#endregion
UserManager.Update(entity);
}
private static ICollection<File> ManageFiles(UserCreateModel model)
{
var files = new List<File>();
var httpFileCollection = HttpContext.Current.Request.Files;
for (var index = 0; index < httpFileCollection.Count; index++)
{
if (httpFileCollection[index].ContentLength <= 0)
{
continue;
}
FileType fileType;
if (httpFileCollection[index].FileName == model.AvatarFileName)
{
fileType = FileType.Avatar;
}
else if (httpFileCollection[index].FileName == model.ResumeFileName)
{
fileType = FileType.Resume;
}
else
{
fileType = FileType.Document;
}
var uploadConfig = FileHelper.Upload(httpFileCollection[index], fileType);
if (uploadConfig.FileBase == null) continue;
var existingRecords = _fileRepository.FindAll(x => x.User.Id == model.Id).Select(x => new
{
x.Id,
x.RelativePath
}).ToList();
foreach (var record in existingRecords)
{
FileHelper.Delete(record.RelativePath);
_fileRepository.Delete(record.Id);
}
_fileRepository.Save();
var file = new File
{
Name = uploadConfig.FileName,
MimeType = uploadConfig.FileBase.ContentType,
Size = uploadConfig.FileBase.ContentLength,
RelativePath = uploadConfig.FilePath + uploadConfig.FileName,
FileType = fileType,
ObjectState = ObjectState.Added,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow,
CreatedBy = HttpContext.Current.User.Identity.GetUserId(),
UpdatedBy = HttpContext.Current.User.Identity.GetUserId()
};
files.Add(file);
}
return files;
}
