public void AddUser(int id)
{
var user = _applicationDbContext.Users.First(u => u.Id == _userManager.GetUserId(HttpContext.User));
PostModel post;
try
{
post = _applicationDbContext.Posts.First(p => p.Id == id);
}
catch (Exception)
{
Redirect("/Post");
return;
}
try
{
UserPostModel userPost = _applicationDbContext.UserPosts.First(d =>
d.ApplicationUserId == user.Id && d.PostModelId == id);
}
catch (Exception)
{
_applicationDbContext.UserPosts.Add(new UserPostModel
{
ApplicationUserId = user.Id,
PostModelId = id
});
_applicationDbContext.SaveChanges();
Redirect("/Post");
return;
}
return;
}
public ErrorsCollection Create(UserPostModel createInfo)
{
var errors = createValidator.Validate(createInfo, context);
if (errors != null)
{
return(errors);
}
User toAdd = new User
{
FirstName = createInfo.FirstName,
LastName = createInfo.LastName,
Email = createInfo.Email,
Username = createInfo.UserName,
Password = ComputeSha256Hash(createInfo.Password),
UserUserRoles = new List <UserUserRole>()
};
var defaultRole = context
.UserRoles
.FirstOrDefault(urole => urole.Name == UserRoles.Regular);
context.Users.Add(toAdd);
context.UserUserRoles.Add(new UserUserRole
{
User = toAdd,
UserRole = defaultRole,
StartTime = DateTime.Now,
EndTime = null
});
context.SaveChanges();
return(null);
}
public User Create(UserPostModel userModel)
{
User toAdd = UserPostModel.ToUser(userModel);
context.Users.Add(toAdd);
context.SaveChanges();
context.Users.Attach(toAdd);
UserRole userRole = new UserRole
{
Id = 1,
Name = RoleConstants.REGULAR
};
HistoryUserRole history = new HistoryUserRole
{
UserRole = userRole,
StartTime = DateTime.Now
};
List <HistoryUserRole> list = new List <HistoryUserRole>
{
history
};
context.UserRoles.Add(userRole);
context.UserRoles.Attach(userRole);
toAdd.HistoryUserRole = list;
context.SaveChanges();
//dbcontext.Users.Add(toAdd);
//dbcontext.SaveChanges();
return(toAdd);
}
public IActionResult Put(int id, [FromBody] UserPostModel userPostModel)
{
User addedBy = _userService.GetCurentUser(HttpContext);
var result = _userService.Upsert(id, userPostModel, addedBy);
return(Ok(result));
}
public UserGetModel Upsert(int id, UserPostModel userPostModel)
{
var existing = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == id);
if (existing == null)
{
//User UserAdd = User.ToUser(user);
userPostModel.Password = ComputeSha256Hash(userPostModel.Password);
User toAdd = UserPostModel.ToUser(userPostModel);
context.Users.Add(toAdd);
context.SaveChanges();
return(UserGetModel.FromUser(toAdd));
}
//User UserUp = User.ToUser(user);
userPostModel.Password = ComputeSha256Hash(userPostModel.Password);
User toUpdate = UserPostModel.ToUser(userPostModel);
toUpdate.Id = id;
context.Users.Update(toUpdate);
context.SaveChanges();
return(UserGetModel.FromUser(toUpdate));
}
public IActionResult PostUser([FromBody] UserPostModel model)
{
if (model == null ||
string.IsNullOrEmpty(model.FirstName) ||
string.IsNullOrEmpty(model.LastName) ||
string.IsNullOrEmpty(model.LoginName) ||
string.IsNullOrEmpty(model.Password))
{
return(new BadRequestObjectResult("invalid data"));
}
var existing = dataContext.WebAppUsers.FirstOrDefault(u => u.LoginName.Equals(model.LoginName));
if (existing != null)
{
return(new BadRequestObjectResult("user already existing"));
}
var newUser = new WebAppUser
{
LoginName = model.LoginName,
FirstName = model.FirstName,
LastName = model.LastName,
Password = model.Password
};
dataContext.WebAppUsers.Add(newUser);
dataContext.SaveChanges();
return(new OkObjectResult(newUser));
}
public async Task <IActionResult> PostUsers([FromBody] UserPostModel model)
{
Roles _role = await _roleRepository.getRole(model.RoleId);
if (_role == null)
{
List <ValidationMessageModel> _validationMessages = new List <ValidationMessageModel>();
_validationMessages.Add(new ValidationMessageModel
{
Code = "RoleId",
Key = "RoleId",
Message = "RoleId Is Invalid"
});
ProblemReporter.ReportBadRequest(JsonConvert.SerializeObject(_validationMessages));
}
Users _user = await _userRepository.InsertUser(model);
UserResponseModel _result = new UserResponseModel
{
Id = _user.Id,
CreatedDate = _user.CreatedDate,
Email = _user.Email,
FirstName = _user.FirstName,
LastName = _user.LastName,
Phone = _user.Phone,
Role = _user.Role.Role
};
return(Ok(_result));
}
public HttpResponseMessage CreatePost([FromBody] UserPostCreateModel model, [FromUri] string sessionKey)
{
var responseMsg = this.PerformOperationAndHandleExceptions(() =>
{
this.ValidatePostContent(model.Content);
var user = this.GetUserBySessionKey(sessionKey);
var newPost = new UserPost()
{
Content = model.Content,
PostDate = DateTime.Now
};
user.Posts.Add(newPost);
this.db.Users.Update(user);
this.db.SaveChanges();
var returnModel = new UserPostModel()
{
Id = newPost.Id,
Content = model.Content,
PostedBy = user.FirstName + " " + user.LastName,
PostDate = newPost.PostDate
};
var response = this.Request.CreateResponse(HttpStatusCode.Created, returnModel);
return(response);
});
return(responseMsg);
}
public UserViewModel Create(UserPostModel model)
{
var user = _mapper.Map <UserModel>(model);
var createdUser = _usersService.Create(user);
return(_mapper.Map <UserViewModel>(createdUser));
}
static void Main(string[] args)
{
var chefTypeController = new ChefTypesController();
var chef = new ChefTypePostModel
{
Name = "Pastry Chef"
};
chefTypeController.CreateChef(chef);
Console.WriteLine(chefTypeController.GetById(1).Name);
var userController = new UsersController();
var user = new UserPostModel()
{
FullName = "Freddy Krueger",
Phone = "+66666661313"
};
userController.CreateUser(user);
foreach (var person in userController.GetAll())
{
Console.Write(person.FullName + " ");
Console.WriteLine(person.Phone);
}
Console.WriteLine();
var waitersController = new WaitersController();
var waiter = new WaiterPostModel()
{
FullName = "Andrew Miller",
Address = "15 Wilson Street"
};
var model = waitersController.CreateWaiter(waiter);
Console.WriteLine(model.FullName);
var orderController = new CateringOrdersController();
var order = new CateringOrderPostModel()
{
UserId = 1,
ChefTypeId = 1,
Date = new DateTime(2021, 06, 13),
NumberOfPeople = 36,
Outdoors = false,
Address = "13 Elm Street",
WaiterId = 1
};
var newOrder = orderController.CreateCateringOrder(order);
Console.WriteLine(newOrder.Id);
foreach (var or in orderController.GetAll())
{
Console.Write(or.User.FullName + " ");
Console.WriteLine(or.ChefType.Name);
}
Console.WriteLine();
}
public async Task <IActionResult> GridStateChange(UserPostModel model)
{
HttpResponseModel response = await HttpClientAsync.Async <IList <UserModel> >(UserRoute.Search, model);
UserViewConfiguration <UserModel> configuration = new UserViewConfiguration <UserModel>(response);
return(this.GridConfiguration(configuration));
}
public UserViewModel CreateUser(UserPostModel model)
{
var user = _mapper.Map <UserModel>(model);
var addedUser = _userService.CreateUser(user);
return(_mapper.Map <UserViewModel>(addedUser));
}
public UserViewModel UpdateUser(UserPostModel model)
{
var user = _mapper.Map <UserModel>(model);
var updatedUser = _userService.UpdateUser(user);
return(_mapper.Map <UserViewModel>(updatedUser));
}
public User Create(UserPostModel user)
{
User toAdd = UserPostModel.ToUser(user);
context.Users.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
public UserGetModel Create(UserPostModel userModel)
{
User toAdd = UserPostModel.ToUser(userModel);
context.Users.Add(toAdd);
context.SaveChanges();
return(UserGetModel.FromUser(toAdd));
}
public RegisterPageViewModel(Page page, INavigation navigation)
{
Title = "Register";
this._navigation = navigation;
this._page = page;
this.Register = new Command(async() => await RegisterUser());
this._userServices = new UserLogin();
this.UserPostModel = new UserPostModel();
}
public IActionResult Put(int id, [FromBody] UserPostModel userPostModel)
{
User addedBy = _userService.GetCurrentUser(HttpContext);
var result = _userService.Upsert(id, userPostModel, addedBy);
if (result == null)
{
return(Forbid("You don't have rigts to perform this action!"));
}
return(Ok(result));
}
public object Post([FromBody] UserPostModel model)
{
if (!ModelState.IsValid)
{
return new { error = ModelState.First() }
}
;
return(_userService.CreateUser(model.UserName));
}
}
public User Create(UserPostModel userPostModel, User addedby)
{
User toAdd = UserPostModel.ToUser(userPostModel);
toAdd.Password = ComputeSha256Hash(toAdd.Password);
toAdd.CreatedBy = addedby.Username;
toAdd.CreatedByRole = addedby.UserRole.ToString();
context.Users.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
public IActionResult Search(UserPostModel model)
{
using (this.DbContext)
{
this.DbContext.Set <UserStatus>().Load();
this.DbContext.Set <UserRoleMapping>().Load();
this.DbContext.Set <Role>().Load();
IQueryable <User> query = this.DbContext.User.AsNoTracking();
query = model.GenerateQuery(query);
return(this.StandardSearchResponse(query, model, UserModel.Convert));
}
}
public bool HasIn(PostModel post, string userId)
{
try
{
var user = _applicationDbContext.Users.First(u => u.Id.Equals(userId));
UserPostModel userPost = _applicationDbContext.UserPosts.First(d =>
d.ApplicationUserId == user.Id && d.PostModelId == post.Id);
}
catch (Exception)
{
return(false);
}
return(true);
}
public IActionResult Put(int id, [FromBody] UserPostModel userPostModel)
{
User currentLogedUser = userService.GetCurrentUser(HttpContext);
var regDate = currentLogedUser.DataRegistered;
var currentDate = DateTime.Now;
var minDate = currentDate.Subtract(regDate).Days / (365 / 12);
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser == null)
{
return(NotFound());
}
}
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser.UserRole == UserRole.Admin)
{
return(Forbid());
}
}
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser.UserRole == UserRole.UserManager && minDate <= 6)
{
return(Forbid());
}
}
if (currentLogedUser.UserRole == UserRole.UserManager)
{
UserGetModel getUser = userService.GetById(id);
if (getUser.UserRole == UserRole.UserManager && minDate >= 6)
{
var result1 = userService.Upsert(id, userPostModel);
return(Ok(result1));
}
}
var result = userService.Upsert(id, userPostModel);
return(Ok(result));
}
public HttpResponseMessage PostRegisterUser(UserPostModel model)
{
var responseMsg = this.PerformOperationAndHandleExceptions(
() =>
{
this.ValidateUsername(model.Username);
this.ValidateName(model.Name);
this.ValidatePassword(model.Password);
var usernameToLower = model.Username.ToLower();
User user = this.Data.Users.All().FirstOrDefault(
x => x.Username == usernameToLower);
if (user != null)
{
throw new InvalidOperationException("User already exists");
}
user = new User()
{
Username = usernameToLower,
Name = model.Name,
Password = model.Password,
SessionKey = string.Empty,
Level = this.Data.Levels.All().OrderBy(x => x.Rank).FirstOrDefault(),
UserRole = this.Data.UserRoles.All().Where(x => x.Role == RoleUser).FirstOrDefault()
};
this.Data.Users.Add(user);
this.Data.SaveChanges();
user.SessionKey = user.Id.ToString();
this.Data.SaveChanges();
var loggedModel = new UserLoggedModel()
{
SessionKey = user.SessionKey
};
var response =
this.Request.CreateResponse(HttpStatusCode.Created,
loggedModel);
return(response);
});
return(responseMsg);
}
public async Task <UserModel> SaveAsync(UserPostModel user)
{
var identityUser = new User()
{
FirstName = user.FirstName,
LastName = user.LastName,
Occupation = user.Occupation,
Email = user.Email,
UserName = user.Email
};
var identityResult = await _userManager.CreateAsync(identityUser, user.Password);
CustomIdentityError.CatchErrorIfNeeded(identityResult);
return(new UserModel(identityUser));
}
public ActionResult PostUsers(UserPostModel user)
{
try
{
var userCreated = _userService.Save(user);
return(Created($"/api/v1/users/{user.Id}", userCreated));
}
catch (System.ApplicationException ex)
{
return(StatusCode(StatusCodes.Status422UnprocessableEntity, ex.Message));
}
catch (System.Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "A server error has occurred"));
}
}
public int Add(UserPostModel model)
{
if (!model.IsValid(out Exception ex))
{
throw ex;
}
var entity = _mapper.Map <UserEntity>(model);
entity.AddTime = DateTime.Now;
var result = _userRepository.Add(entity, true);
if (!result)
{
throw new Exception($"新增失败");
}
return(entity.UserId);
}
public async Task <int> AddAsync(UserPostModel model)
{
if (!model.IsValid(out Exception ex))
{
throw ex;
}
var entity = _mapper.Map <SubDbUserEntity>(model);
entity.AddTime = DateTime.Now;
var result = await _repository.AddAsync(entity, true);
if (!result)
{
throw new Exception($"新增失败");
}
return(entity.UserId);
}
public async Task <IActionResult> OnPostAsync(string id, UserPostModel model, IFormCollection collection)
{
await Init(id);
if (!ModelState.IsValid)
{
return(Page());
}
var unselectedRoles = SelectedUserRoles.Where(r => !model.SelectedRoles?.Contains(r) ?? false).ToList();
var newRoles = model.SelectedRoles?.Where(r => !SelectedUserRoles.Contains(r)).ToList();
var rolesUpdated = false;
if (unselectedRoles.Any())
{
await _userManager.RemoveFromRolesAsync(SelectedUser, unselectedRoles);
rolesUpdated = true;
}
if (!newRoles.IsNullOrEmpty())
{
await _userManager.AddToRolesAsync(SelectedUser, newRoles);
rolesUpdated = true;
}
if (rolesUpdated)
{
EZmsInMemoryCache.Remove($"EZms:principal:userroles:{id}");
}
SelectedUser.Email = model.Email;
SelectedUser.PhoneNumber = model.PhoneNumber;
await _userManager.UpdateAsync(SelectedUser);
if (unselectedRoles.Any() || newRoles.Any())
{
SelectedUserRoles = await GetUserRoles(SelectedUser);
}
return(Page());
}
public object Upsert(int id, UserPostModel userPostModel, User requestedBy)
{
var existing = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == id);
if (existing == null)
{
User toAdd = new User
{
Email = userPostModel.Email,
LastName = userPostModel.LastName,
FirstName = userPostModel.FirstName,
Password = ComputeSha256Hash(userPostModel.Password),
Username = userPostModel.UserName,
CreatedBy = requestedBy.Username,
CreatedByRole = requestedBy.CreatedByRole,
UserUserRoles = new List <UserUserRole>(),
CreatedAt = DateTime.Today
};
var regularRole = context.UserRoles.AsNoTracking().FirstOrDefault(ur => ur.Name == UserRoles.Regular);
context.Users.Add(toAdd);
context.UserUserRoles.Add(new UserUserRole
{
User = toAdd,
UserRole = regularRole,
StartTime = DateTime.Now,
EndTime = null,
});
context.SaveChanges();
}
User toUpdate = UserPostModel.ToUser(userPostModel);
toUpdate.Id = existing.Id;
toUpdate.Password = ComputeSha256Hash(toUpdate.Password);
toUpdate.UserUserRoles = existing.UserUserRoles;
context.Users.Update(toUpdate);
context.SaveChanges();
return(toUpdate);
}
public UserGetModel Upsert(int id, UserPostModel userPostModel)
{
var existing = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == id);
if (existing == null)
{
User toAdd = UserPostModel.ToUser(userPostModel);
context.Users.Add(toAdd);
context.SaveChanges();
return(UserGetModel.FromUser(toAdd));
}
User toUpdate = UserPostModel.ToUser(userPostModel);
toUpdate.Id = id;
context.Users.Update(toUpdate);
context.SaveChanges();
return(UserGetModel.FromUser(toUpdate));
}
