public async Task <IHttpActionResult> ChangeRoleName([FromUri] string id, [FromBody] RoleBindingModel roleModel)
{
if (roleModel == null)
{
return(BadRequest("Payload is empty!"));
}
var role = await RoleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
role.Name = roleModel.Name;
IdentityResult createRoleResult = await RoleManager.UpdateAsync(role);
if (!createRoleResult.Succeeded)
{
return(GetErrorResult(createRoleResult));
}
var roleDto = RoleFactory.GetModel <RoleForAdminDto>(role);
Uri locationHeader = new Uri(Url.Link("GetRole", new { id = role.Id }));
return(Created(locationHeader, roleDto));
}
public bool Create(RoleBindingModel model)
{
try
{
using (var libraryDb = new LibraryManagementEntities())
{
// check duplicated
var currentRole = libraryDb.Roles.FirstOrDefault(s => s.Name == model.Name);
if (currentRole != null)
{
throw new ArgumentNullException();
}
// Insert db
var roleInfo = _entityMapper.Map <RoleBindingModel, Role>(model);
libraryDb.Roles.Add(roleInfo);
libraryDb.SaveChanges();
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public void CreateOrUpdate(RoleBindingModel model)
{
using (var context = new DatabaseContext())
{
Role role = context.Roles.FirstOrDefault(rec =>
rec.Name == model.Name && rec.ID != model.ID);
if (role != null)
{
throw new Exception("Уже есть роль с таким названием");
}
if (model.ID.HasValue)
{
role = context.Roles.FirstOrDefault(rec => rec.ID == model.ID);
if (role == null)
{
throw new Exception("Роль не найдена");
}
}
else
{
role = new Role();
context.Roles.Add(role);
}
role.Name = model.Name;
role.Type = model.Type;
role.CreationDate = model.CreationDate;
context.SaveChanges();
}
}
public void Insert(RoleBindingModel model)
{
using (var context = new NewsBlogDatabase())
{
context.Role.Add(CreateModel(model, new Role()));
context.SaveChanges();
}
}
public void Insert(RoleBindingModel model)
{
using (var context = new JournalDb())
{
context.Roles.Add(CreateModel(model, new Role()));
context.SaveChanges();
}
}
public IHttpActionResult PostRole(RoleBindingModel roleBindingModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!RoleManager.Roles.Any(r => r.Name == roleBindingModel.Role))
{
return(BadRequest());
}
if (db.Users.Find(roleBindingModel.UserId) == null)
{
return(BadRequest());
}
var userRoles = UserManager.GetRolesAsync(User.Identity.GetUserId()).Result;
if (roleBindingModel.Role == "Administrator" && userRoles.Any(r => r == "Administrator"))
{
// ???
}
else if (roleBindingModel.Role == "Employee" && (userRoles.Any(r => r == "Administrator") ||
userRoles.Any(r => r == "Employee")))
{
if (db.Companies.Find(roleBindingModel.OptionalCompanyId) == null)
{
return(BadRequest());
}
if (db.Employees.Find(roleBindingModel.UserId) != null)
{
return(BadRequest());
}
db.Employees.Add(new Employee
{
UserId = roleBindingModel.UserId,
CompanyId = roleBindingModel.OptionalCompanyId,
JoinDate = DateTime.Now.Date
});
db.SaveChanges();
}
else if (roleBindingModel.Role == "User" && (userRoles.Any(r => r == "Employee")))
{
db.Employees.Remove(db.Employees.Find(roleBindingModel.UserId));
db.SaveChanges();
}
else
{
return(StatusCode(HttpStatusCode.Unauthorized));
}
UserManager.AddToRoleAsync(roleBindingModel.UserId, roleBindingModel.Role).Wait();
return(Ok());
}
public List <RoleViewModel> Read(RoleBindingModel model)
{
if (model == null)
{
return(roleStorage.GetFullList());
}
return(new List <RoleViewModel> {
roleStorage.GetElement(model)
});
}
public void Delete(RoleBindingModel model)
{
var element = roleStorage.GetElement(new RoleBindingModel
{
Id = model.Id
});
if (element == null)
{
throw new Exception("Должность не найден");
}
roleStorage.Delete(model);
}
public void Delete(RoleBindingModel model)
{
var role = _roleStorage.GetElement(new RoleBindingModel
{
Id = model.Id
});
if (role == null)
{
throw new Exception("Роль не найдена");
}
_roleStorage.Delete(model);
}
public void Update(RoleBindingModel model)
{
using (var context = new NewsBlogDatabase())
{
var role = context.Role.FirstOrDefault(rec => rec.Idrole == model.Id);
if (role == null)
{
throw new Exception("Роль не найдена");
}
CreateModel(model, role);
context.SaveChanges();
}
}
public async Task <RoleViewModel> UpdateRole(int id, [FromBody] RoleBindingModel bindingModel)
{
if (bindingModel == null || !ModelState.IsValid)
{
throw new CustomException(Errors.INVALID_ROLE_BINDING_DATA, Errors.INVALID_ROLE_BINDING_DATA_MSG);
}
var role = bindingModel.ToModel(id);
role = await _roleService.UpdateAsync(role);
return(role.ToViewModel());
}
public List <RoleViewModel> Read(RoleBindingModel model)
{
if (model == null)
{
return(_roleStorage.GetFullList());
}
if (model.Id.HasValue)
{
return(new List <RoleViewModel> {
_roleStorage.GetElement(model)
});
}
return(_roleStorage.GetFilteredList(model));
}
public void Delete(RoleBindingModel model)
{
using (var context = new JournalDb())
{
var role = context.Roles.FirstOrDefault(rec => rec.Id == model.Id);
if (role == null)
{
throw new Exception("Должность не найдена");
}
context.Roles.Remove(role);
context.SaveChanges();
}
}
public void Delete(RoleBindingModel model)
{
using (var context = new DatabaseContext())
{
Role role = context.Roles.FirstOrDefault(rec => rec.ID == model.ID);
if (role != null)
{
context.Roles.Remove(role);
context.SaveChanges();
}
else
{
throw new Exception("Роль не найдена");
}
}
}
public IHttpActionResult AddRole([FromBody] RoleBindingModel role)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RoleDTO newRole = new RoleDTO()
{
Title = role.Title
};
_roleService.Add(newRole);
return(Ok());
}
public async Task <bool> ManageUsersInRole(RoleBindingModel model)
{
try
{
var result = await providePolicy().ExecuteAsync(() =>
RES_URL
.AppendPathSegment("/api/roles/ManageUsersInRole")
.WithOAuthBearerToken(Properties.Settings.Default.token)
.PostJsonAsync(model));
return(result.IsSuccessStatusCode);
}
catch (FlurlHttpException ex)
{
return(false);
}
}
public IHttpActionResult NewRole(RoleBindingModel Role)
{
if (RoleManager.RoleExists(Role.Role))
{
return(BadRequest("Already Exists"));
}
var newRole = new IdentityRole(Role.Role);
var result = RoleManager.Create(newRole);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public List <RoleViewModel> GetFilteredList(RoleBindingModel model)
{
if (model == null)
{
return(null);
}
using (var context = new NewsBlogDatabase())
{
return(context.Role
.Where(rec => rec.Namerole.Contains(model.NameRole))
.Select(rec => new RoleViewModel
{
Id = rec.Idrole,
NameRole = rec.Namerole
}).ToList());
}
}
public IHttpActionResult AddRoleToUser([FromUri] string username, [FromBody] RoleBindingModel roleBindingModel)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var user = this.context.Users.FirstOrDefault(u => u.UserName == username);
if (user == null)
{
return(this.BadRequest("User " + username + " does not exist"));
}
var role = this.context.Roles.FirstOrDefault(r => r.Name == roleBindingModel.Name);
if (role == null)
{
this.context.Roles.Add(new IdentityRole()
{
Name = roleBindingModel.Name
});
this.context.SaveChanges();
role = this.context.Roles.FirstOrDefault(r => r.Name == roleBindingModel.Name);
}
user.Roles.Add(new IdentityUserRole()
{
UserId = user.Id,
RoleId = role.Id
});
try
{
this.context.SaveChanges();
return(this.Ok(string.Format("Role {0} added to user {1}", roleBindingModel.Name, username)));
}
catch (Exception)
{
return(this.BadRequest());
}
}
public async Task <IHttpActionResult> AddUserToRole([FromBody] RoleBindingModel userData)
{
var role = await AppRoleManager.FindByIdAsync(userData.RoleId);
if (role != null)
{
IdentityResult result = await AppUserManager.AddToRoleAsync(userData.UserId, role.Name);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
return(NotFound());
}
public RoleViewModel GetElement(RoleBindingModel model)
{
if (model == null)
{
return(null);
}
using (var context = new NewsBlogDatabase())
{
var role = context.Role
.FirstOrDefault(rec => rec.Namerole.Equals(model.NameRole) || rec.Idrole == model.Id);
return(role != null ?
new RoleViewModel
{
Id = role.Idrole,
NameRole = role.Namerole
} : null);
}
}
public List <RoleViewModel> Read(RoleBindingModel model)
{
using (var context = new DatabaseContext())
{
return(context.Roles
.Where(rec => model == null || rec.ID == model.ID ||
model.StartDate.HasValue && model.EndDate.HasValue &&
rec.CreationDate >= model.StartDate.Value &&
rec.CreationDate <= model.EndDate.Value)
.Select(rec => new RoleViewModel
{
ID = rec.ID,
Name = rec.Name,
Type = rec.Type,
CreationDate = rec.CreationDate
})
.ToList());
}
}
public void CreateOrUpdate(RoleBindingModel model)
{
var role = _roleStorage.GetElement(new RoleBindingModel
{
NameRole = model.NameRole
});
if (role != null && role.Id != model.Id)
{
throw new Exception("Уже есть роль с таким названием");
}
if (model.Id.HasValue)
{
_roleStorage.Update(model);
}
else
{
_roleStorage.Insert(model);
}
}
public void CreateOrUpdate(RoleBindingModel model)
{
var element = roleStorage.GetElement(new RoleBindingModel
{
NameRole = model.NameRole
});
if (element != null && element.Id != model.Id)
{
throw new Exception("Уже присутствует такая должность");
}
if (model.Id.HasValue)
{
roleStorage.Update(model);
}
else
{
roleStorage.Insert(model);
}
}
public IHttpActionResult RemoveUserFromRole([FromUri] string username, [FromBody] RoleBindingModel roleBindingModel)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var user = this.context.Users.FirstOrDefault(u => u.UserName == username);
if (user == null)
{
return(this.BadRequest("User " + username + " does not exist"));
}
var role = this.context.Roles.FirstOrDefault(r => r.Name == roleBindingModel.Name);
if (role == null)
{
return(this.BadRequest("Role " + roleBindingModel.Name + " does not exist"));
}
var userRole = user.Roles.FirstOrDefault(r => r.RoleId == role.Id);
if (userRole == null)
{
return(this.BadRequest(string.Format("User {0} does not have role {1}", username, role.Name)));
}
user.Roles.Remove(userRole);
try
{
this.context.SaveChanges();
return(this.Ok(string.Format("User {0} removed from role {1}", username, roleBindingModel.Name)));
}
catch (Exception)
{
return(this.BadRequest());
}
}
private void btnSave_Click(object sender, EventArgs e)
{
bool add = txtId.Text == "" ? false : true;
if (!add)
{
RoleBindingModel model = new RoleBindingModel()
{
Name = txtName.Text
};
if (manager.Create(model))
{
add = false;
MessageBox.Show("Thêm mới thành công !", "Thông báo");
}
else
{
MessageBox.Show("Thêm mới không thành công!. Liên hệ với quản trị viên.", "Thông báo");
}
}
else
{
RoleBindingModel model = new RoleBindingModel()
{
Id = int.Parse(txtId.Text),
Name = txtName.Text
};
if (manager.Update(model))
{
MessageBox.Show("Sửa thành công !", "Thông báo");
}
else
{
MessageBox.Show("Sửa không thành công!. Liên hệ với quản trị viên.", "Thông báo");
}
}
LoadData(Searching, PageIndex, PageSize);
}
public static Role ToModel(this RoleBindingModel bindingModel, int?roleId = null)
{
if (bindingModel == null)
{
return(null);
}
else
{
var model = new Role
{
Name = bindingModel.Name
};
if (roleId.HasValue)
{
model.Id = roleId.Value;
}
return(model);
}
}
public async Task <IHttpActionResult> CreateRole(RoleBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var role = new IdentityRole()
{
Name = model.Name
};
// role.description = string.Empty;
IdentityResult result = await RoleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public RoleViewModel GetElement(RoleBindingModel model)
{
if (model == null)
{
return(null);
}
using (var context = new JournalDb())
{
var role = context.Roles
.FirstOrDefault(rec => rec.NameRole == model.NameRole ||
rec.Id == model.Id);
return(role != null ?
new RoleViewModel
{
Id = role.Id,
NameRole = role.NameRole
} :
null);
}
}
public bool Update(RoleBindingModel model)
{
try
{
using (var libraryDb = new LibraryManagementEntities())
{
// Check first get item
var role = libraryDb.Roles.FirstOrDefault(s => s.Id == model.Id);
if (role == null)
{
throw new ArgumentNullException("No exist");
}
role.Name = model.Name;
libraryDb.SaveChanges();
return(true);
}
}
catch (Exception)
{
return(false);
}
}
