public static RoleDTO MapToDTO(Role model )
{
RoleDTO dto = new RoleDTO();
dto.RoleId = model.RoleId;
dto.RoleName = model.RoleName;
return dto;
}
public static Role MapFromDTO(RoleDTO dto)
{
Role Role = new Role();
Role.RoleId = dto.RoleId;
Role.RoleName = dto.RoleName;
return Role;
}
public JsonResult Update(RoleDTO dto)
{
var manager = this.GetManagerFor<IRoleManager>();
var result = manager.Update(dto);
var resultDTO = new RoleDTO(result);
return Json(resultDTO);
}
public JsonResult DeleteRole(RoleDTO dto)
{
var manager = this.GetManagerFor<IRoleManager>();
var role = manager.Delete(dto.Id);
var result = new RoleDTO(role);
return Json(result);
}
public void CreateRoleMethodTest()
{
RoleDTO role = new RoleDTO() { Name = "Genenal User" };
response = this.InvokeOperation(targetOperationId, "RetrieveAll", null);
List<UserDTO> users = response.Result.Value as List<UserDTO>;
foreach(var user in users)
{
role.Users.Add(user);
}
response = this.InvokeOperation(targetOperationId, "Create", new object[] { role });
}
public JsonResult Save(RoleDTO.SaveModel model)
{
if (!ModelState.IsValid)
return ModelState.GetAajaFirstErrorMessage();
if (rolePrivoder.Count(c => c.Name == model.Name) > 0)
{
ModelState.AddModelError("Name", "角色名称已存在");
return ModelState.GetAajaFirstErrorMessage();
}
rolePrivoder.Add(model.Source);
return Json(new AjaxResult() { Success = true, Message = "操作成功" });
}
public JsonResult GetRole(int id, IEnumerable<string> query)
{
var queries = new Query[] { };
if (query != null)
{
queries = query.Select(q => new Query { Name = q }).ToArray();
}
var manager = this.GetManagerFor<IRoleManager>();
var result = manager.GetById(id);
var resultDTO = new RoleDTO(queries, result);
return Json(resultDTO);
}
// PUT api/BusinessAPI/Business/{businessId}/Role/{roleId}
public HttpResponseMessage PutBusinessRole(Guid businessId, Guid roleId, RoleDTO roleDTO)
{
//Ensure user has "Put" manager permissions for the business which the request corresponds to
if (!ClaimsAuthorization.CheckAccess("Put", "BusinessId", businessId.ToString()))
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "You do not have permissions."));
}
if (ModelState.IsValid)
{
var role = MapperFacade.MapperConfiguration.Map <RoleDTO, Role>(roleDTO, db.Roles.Single(r => r.Id == roleId));
db.Entry(role).State = EntityState.Modified;
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
private static void AutoMapperIdentity123()
{
Console.WriteLine("\nApplication Identity DTO -> Data -> DTO\n");
{
Console.WriteLine("Role");
Role data = new Role();
RoleDTO dto = DIHelper.Mapper.Map <RoleDTO>(data);
data = DIHelper.Mapper.Map <Role>(dto);
}
{
Console.WriteLine("UserClaim");
UserClaim data = new UserClaim();
UserClaimDTO dto = DIHelper.Mapper.Map <UserClaimDTO>(data);
data = DIHelper.Mapper.Map <UserClaim>(dto);
}
{
Console.WriteLine("UserLogim");
UserLogin data = new UserLogin();
UserLoginDTO dto = DIHelper.Mapper.Map <UserLoginDTO>(data);
data = DIHelper.Mapper.Map <UserLogin>(dto);
}
{
Console.WriteLine("UserRole");
UserRole data = new UserRole();
UserRoleDTO dto = DIHelper.Mapper.Map <UserRoleDTO>(data);
data = DIHelper.Mapper.Map <UserRole>(dto);
}
{
Console.WriteLine("User");
User data = new User();
UserDTO dto = DIHelper.Mapper.Map <UserDTO>(data);
data = DIHelper.Mapper.Map <User>(dto);
}
}
public RoleDTO GetRoleByName(string roleName)
{
if (string.IsNullOrWhiteSpace(roleName))
{
return(null);
}
var roleDTO = new RoleDTO();
try
{
var role = _userRepository.GetRoleAsync(roleName).Result;
roleDTO = _mapper.Map <Role, RoleDTO>(role);
}
catch (Exception ex)
{
_logger.LogError(ex, ErrorMessageConstants.GetErrorMessage);
return(null);
}
return(roleDTO);
}
public static DTOStatus UpdateRole(int id, RoleDTO RoleDTO, string ConnectionString)
{
// Status to return
DTOStatus objDTOStatus = new DTOStatus();
objDTOStatus.Success = true;
var optionsBuilder = new DbContextOptionsBuilder <ADefHelpDeskContext>();
optionsBuilder.UseSqlServer(ConnectionString);
using (var context = new ADefHelpDeskContext(optionsBuilder.Options))
{
var existingRole = context.AdefHelpDeskRoles.SingleOrDefaultAsync(x => x.Id == id).Result;
if (existingRole == null)
{
objDTOStatus.StatusMessage = $"id #{id} Not Found";
objDTOStatus.Success = false;
return(objDTOStatus);
}
// Update the Role
existingRole.RoleName = RoleDTO.roleName;
context.Entry(existingRole).State = EntityState.Modified;
try
{
context.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
objDTOStatus.StatusMessage = ex.GetBaseException().Message;
objDTOStatus.Success = false;
}
}
return(objDTOStatus);
}
public async Task <IActionResult> PutRole(string id, RoleDTO roleDTO)
{
if (id != roleDTO.Id)
{
return(BadRequest());
}
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
role.Name = roleDTO.Name;
var result = await _roleManager.UpdateAsync(role);
if (!result.Succeeded)
{
if (result.Errors != null)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
if (ModelState.IsValid)
{
return(BadRequest());
}
return(BadRequest(ModelState));
}
return(Ok());
}
// POST api/BusinessAPI/Business/{businessId}/Role/{roleId}
public HttpResponseMessage PostBusinessRole(Guid businessId, Guid roleId, RoleDTO roleDTO)
{
//Ensure user has "Put" manager permissions for the business which the request corresponds to
if (!ClaimsAuthorization.CheckAccess("Put", "BusinessId", businessId.ToString()))
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "You do not have permissions."));
}
if (String.IsNullOrEmpty(roleDTO.Name))
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, "Role name cannot be empty"));
}
if (db.Roles.Where(r => r.Name == roleDTO.Name && r.Business.Id == businessId).Count() > 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, "Role already exists"));
}
if (ModelState.IsValid)
{
var role = MapperFacade.MapperConfiguration.Map <RoleDTO, Role>(roleDTO);
role.Id = Guid.NewGuid(); //Assign new ID on save.
//Lookup Business and attach, so that no updates or inserts are performed on BusinessType lookup table
role.Business = db.Businesses.Find(businessId);
db.Roles.Add(role);
db.SaveChanges();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created);
response.Headers.Location = new Uri(Url.Link("BusinessRole", new { businessId = businessId, roleId = role.Id }));
return(response);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public List <RoleDTO> GetAll()
{
List <RoleDTO> roleDTOs = new List <RoleDTO>();
SqlCommand cmd = new SqlCommand("SELECT * FROM Administration.TblRole", DbConnector.Connect());
SqlDataAdapter adapter = new SqlDataAdapter(cmd);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
DataTable dt = dataSet.Tables[0];
for (int i = 0; i < dt.Rows.Count; i++)
{
RoleDTO roleDTO = new RoleDTO()
{
Id = Convert.ToInt32(dt.Rows[i]["Id"]),
Code = Convert.ToString(dt.Rows[i]["Code"]),
Name = Convert.ToString(dt.Rows[i]["Name"]),
CreatedOn = Convert.ToDateTime(dt.Rows[i]["CreatedOn"]),
CreatedBy = Convert.ToInt32(dt.Rows[i]["CreatedBy"]),
Active = Convert.ToBoolean(dt.Rows[i]["Active"])
};
if (dt.Rows[i]["ModifiedOn"] != DBNull.Value)
{
roleDTO.ModifiedOn = Convert.ToDateTime(dt.Rows[i]["ModifiedOn"]);
}
if (dt.Rows[i]["ModifiedBy"] != DBNull.Value)
{
roleDTO.ModifiedBy = Convert.ToInt32(dt.Rows[i]["ModifiedBy"]);
}
roleDTOs.Add(roleDTO);
}
return(roleDTOs);
}
// "R - READ" of CRUD
public List <RoleDTO> GetRoles()
{
List <RoleDTO> _list = new List <RoleDTO>();
using (SqlConnection con = new SqlConnection(_conn))
{
using (SqlCommand _sqlCommand = new SqlCommand("uspGetRole", con))
{
_sqlCommand.CommandType = CommandType.StoredProcedure;
_sqlCommand.CommandTimeout = 10;
//_sqlCommand.Parameters.AddWithValue("@BookID", inOneParticularBook);
con.Open();
RoleDTO _role;
using (SqlDataReader reader = _sqlCommand.ExecuteReader())
{
while (reader.Read())
{
_role = new RoleDTO
{
RoleID = reader.GetInt32(reader.GetOrdinal("RoleID")),
RoleName = (string)reader["RoleName"],
Comment = reader["Comment"] is DBNull ? "" : (string)reader["Comment"],
DateModified = reader.GetDateTime(reader.GetOrdinal("DateModified")),
ModifiedByUserId = reader.GetInt32(reader.GetOrdinal("ModifiedByUserID"))
//Price = reader.GetDecimal(reader.GetOrdinal("Book_Price")),
//IsPaperback = (string)reader["Book_IsPaperBack"],
//Author_FK = reader.GetInt32(reader.GetOrdinal("Book_AuthorID_FK")),
//Genre_FK = reader.GetInt32(reader.GetOrdinal("GenreID_FK"))
};
_list.Add(_role); // add current object to the list object
}
}
con.Close();
}
}
return(_list);
}
public ActionResult RoleCreate(RoleDTO roleDTO, Guid?businessLocationId)
{
roleDTO.Enabled = true;
if (ModelState.IsValid)
{
using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
{
var responseMessage = httpClient.PostAsJsonAsync("api/BusinessAPI/Business/" + roleDTO.BusinessId.ToString() + "/Role/" + Guid.Empty.ToString(), roleDTO).Result;
if (responseMessage.IsSuccessStatusCode)
{
//Invalidate dependant cache item
CacheManager.Instance.Remove(CacheManager.CACHE_KEY_BUSINESS + roleDTO.BusinessId.ToString());
if (businessLocationId.HasValue)
{
return(RedirectToAction("RoleIndex", new { businessid = roleDTO.BusinessId, businessLocationId = businessLocationId.Value }));
}
else
{
return(RedirectToAction("RoleIndex", new { businessid = roleDTO.BusinessId }));
}
}
else
{
//If and error occurred add details to model error.
var error = JsonConvert.DeserializeObject <System.Web.Http.HttpError>(responseMessage.Content.ReadAsStringAsync().Result);
ModelState.AddModelError(String.Empty, error.Message);
}
}
}
ViewBag.IsNew = false;
ViewBag.BusinessId = roleDTO.BusinessId;
return(PartialView());
}
public override bool IsUserInRole(string email, string roleName)
{
bool result = false;
try
{
PersonDTO person = _authenticationRepository.GetPersonByEmail(email);
if (person != null)
{
RoleDTO PersonRole = _authenticationRepository.GetRoleById(person.Id);
if (PersonRole != null && PersonRole.Name == roleName)
{
result = true;
}
}
}
catch
{
result = false;
}
return(result);
}
public ActionResult EditRole(Guid groupId, RoleDTO role)
{
return(HttpHandleExtensions.AjaxCallGetResult(() =>
{
role.RoleGroupId = groupId;
if (role.Id == Guid.Empty)
{
_roleService.Add(role);
this.JsMessage = MessagesResources.Add_Success;
}
else
{
_roleService.Update(role);
this.JsMessage = MessagesResources.Update_Success;
}
return Json(new AjaxResponse
{
Succeeded = true,
RedirectUrl = Url.Action("RoleList", new { groupId = groupId })
});
}));
}
public void TestDtoToUser()
{
RoleDTO roleDTO = new RoleDTO()
{
Id = 1, RoleName = "FakeName", Version = 0
};
UserDTO dto = new UserDTO()
{
Id = 1, UserName = "******", Password = "******", Version = 1
};
dto.Roles.Add(roleDTO);
Assert.AreEqual(true, dto.IsValid);
Assert.AreEqual(true, roleDTO.IsValid);
User user = SecurityAdapter.DtoToUser(dto);
Assert.AreEqual <int>(dto.Id, user.UserId);
Assert.AreEqual <string>(dto.UserName, user.UserName);
Assert.AreEqual <string>(dto.Password, user.Password);
Assert.AreEqual(dto.Version, user.Version);
Assert.AreEqual(true, user.IsValid);
}
public Task RemoveFromRoleAsync(CustomIdentityUser user, string roleName)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (String.IsNullOrEmpty(roleName))
{
throw new ArgumentNullException("roleName");
}
RoleDTO roleDTO = this.roleService.GetRoleByTitle(roleName);
bool userIsInRole = user.Roles.Any(role => role.Id == roleDTO.Id);
if (roleDTO != null && userIsInRole)
{
user.Roles.Remove(roleDTO);
this.userService.Update(user);
}
return(Task.FromResult <object>(null));
}
public async Task <IHttpActionResult> PutUserMaster(Guid id, RoleDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != dto.Id)
{
return(BadRequest());
}
int EntityStateId = (int)EntityState.Modified;
Guid result = await _roleService.SaveStatus(dto, id, EntityStateId);
if (result == Guid.Empty)
{
return(NotFound());
}
return(StatusCode(HttpStatusCode.NoContent));
}
//----------------------------------------- Gets -----------------------------------------
public static List <RoleDTO> getRoles()
{
List <RoleDTO> roles = new List <RoleDTO>();
using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["connectionRRHHDatabase"].ConnectionString))
{
SqlCommand command = new SqlCommand("usp_get_roles", connection);
command.CommandType = CommandType.StoredProcedure;
command.Connection.Open();
SqlDataReader rdr = command.ExecuteReader();
while (rdr.Read())
{
RoleDTO rollDTO = new RoleDTO();
rollDTO.id_role = rdr["id_role"].ToString();
rollDTO.name = rdr["name"].ToString();
rollDTO.description = rdr["description"].ToString();
rollDTO.permissions = rdr["permissions"].ToString();
roles.Add(rollDTO);
}
};
return(roles);
}
public SaveResult <RoleEntryModel> Save(RoleDTO roleDTO, DateTime dateStamp)
{
ModelValidationResult validationResult = roleValidator.Validate(roleDTO);
bool success = false;
RoleEntryModel model = null;
if (validationResult.IsValid)
{
tblM_Role role = Insert(roleDTO, dateStamp);
Db.SaveChanges();
success = true;
model = roleEntryDataProvider.Get(role.Role_PK);
}
return(new SaveResult <RoleEntryModel>
{
Success = success,
Message = validationResult.IsValid ? "Data successfully created." : "Validation error occured.",
Model = model,
ValidationResult = validationResult
});
}
public bool SuaRole(string Id, string Ten, string SPhong, string IPhong, string UPhong, string DPhong, string UTen, string ITen, string UGia, string IGia)
{
RoleDTO role = new RoleDTO();
try
{
role.Id = Id;
role.Ten = Ten;
role.SPhong = SPhong;
role.IPhong = IPhong;
role.UPhong = UPhong;
role.DPhong = DPhong;
role.UTen = UTen;
role.ITen = ITen;
role.UGia = UGia;
role.IGia = IGia;
}
catch (Exception)
{
return(false);
}
return(RoleDAO.Instance.SuaRole(role));
}
public async Task <GetRolesResponse> Handle(GetRolesRequest request, CancellationToken cancellationToken)
{
try
{
var records = await _context.Roles
.AsNoTracking()
.ToListAsync(cancellationToken);
List <RoleDTO> listOfDTO = new List <RoleDTO>();
if (records.Count > 0)
{
foreach (var record in records)
{
var data = new RoleDTO
{
RoleID = record.RoleID,
Name = record.Name
};
if (data != null)
{
listOfDTO.Add(data);
}
}
}
return(new GetRolesResponse
{
Data = listOfDTO
});
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Update(int id, RoleDTO roleDTO)
{
if (roleDTO.RoleId != id)
{
return(BadRequest());
}
try
{
var role = _mapper.Map <RoleDTO, Role>(roleDTO);
await _unitOfWork.Roles.Update(id, role);
}
catch (DbUpdateConcurrencyException)
{
if (!await RoleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static List <RoleDTO> getUserRoles(string pUser)
{
List <RoleDTO> roleDTOList = new List <RoleDTO>();
using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["connectionRRHHDatabase"].ConnectionString))
{
SqlCommand command = new SqlCommand("usp_get_userRoles", connection);
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.Add("@user_id", SqlDbType.Int);
command.Parameters["@user_id"].Value = pUser;
command.Connection.Open();
SqlDataReader rdr = command.ExecuteReader();
while (rdr.Read())
{
RoleDTO roleDTO = new RoleDTO();
roleDTO.id_role = rdr["id_role"].ToString();
roleDTO.name = rdr["name"].ToString();
roleDTO.description = rdr["description"].ToString();
roleDTO.user_id = rdr["user_id"].ToString();
roleDTOList.Add(roleDTO);
}
};
return(roleDTOList);
}
public async Task <ActionResult <RoleDTO> > PostRole(RoleDTO roleDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var role = new IdentityRole()
{
Name = roleDTO.Name
};
IdentityResult result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
if (result.Errors != null)
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
if (ModelState.IsValid)
{
return(BadRequest());
}
return(BadRequest(ModelState));
}
var roles = RoleToRoleDTO(role);
return(CreatedAtAction("GetRoles", new { id = role.Id }, roles));
}
public async Task <IActionResult> CreateRole(RoleDTO roleDTO)
{
if (!await RoleExists(roleDTO.Name))
{
IdentityRole identityRole = new IdentityRole
{
Name = roleDTO.Name
};
IdentityResult result = await _roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(CreatedAtAction("GetRole", new { id = identityRole.Id }, roleDTO));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
ModelState.AddModelError(string.Empty, "Role ja existent");
return(BadRequest(ModelState));
}
public async Task <IActionResult> EditRole(int accountId, [FromBody] RoleDTO role)
{
try
{
var accountFromDb = await _repo.GetAccountDetail(accountId);
if (accountFromDb == null)
{
return(NotFound());
}
if (accountFromDb.Roles.Any(r => r.Role.Name == role.RoleName))
{
var removeResult = await _userManager.RemoveFromRoleAsync(accountFromDb, role.RoleName);
if (removeResult.Succeeded)
{
return(Ok());
}
}
else
{
var result = await _userManager.AddToRoleAsync(accountFromDb, role.RoleName);
if (result.Succeeded)
{
return(Ok());
}
}
return(NoContent());
}
catch (System.Exception e)
{
throw e;
}
}
public ActionResult AddRole(RoleDTO paramRoleDTO)
{
GetCurrentUserInViewBag();
try
{
if (paramRoleDTO == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var RoleName = paramRoleDTO.RoleName.Trim();
if (RoleName == "")
{
throw new Exception("No RoleName");
}
// Create Role
var roleManager =
new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(new ApplicationDbContext())
);
if (!roleManager.RoleExists(RoleName))
{
roleManager.Create(new IdentityRole(RoleName));
}
return(Redirect("~/Admin/ViewAllRoles"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, "Error: " + ex);
return(View("AddRole"));
}
}
public ActionResult RoleEdit(RoleDTO roleDTO, Guid?businessLocationId)
{
if (ModelState.IsValid)
{
//Replace with updated role
using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
{
var responseMessage = httpClient.PutAsJsonAsync("api/BusinessAPI/Business/" + roleDTO.BusinessId.ToString() + "/Role/" + roleDTO.Id.ToString(), roleDTO).Result;
responseMessage.EnsureSuccessStatusCode();
//Invalidate dependant cache item
CacheManager.Instance.Remove(CacheManager.CACHE_KEY_BUSINESS + roleDTO.BusinessId.ToString());
if (businessLocationId.HasValue)
{
return(RedirectToAction("RoleIndex", new { businessid = roleDTO.BusinessId, businessLocationId = businessLocationId.Value }));
}
else
{
return(RedirectToAction("RoleIndex", new { businessid = roleDTO.BusinessId }));
}
}
}
return(PartialView(roleDTO));
}
public RoleDTO Add(RoleDTO roleDTO)
{
var role = roleDTO.ToModel();
role.Id = IdentityGenerator.NewSequentialGuid();
role.Created = DateTime.UtcNow;
if (role.Name.IsNullOrBlank())
{
throw new DataExistsException(UserSystemResource.Common_Name_Empty);
}
if (_Repository.Exists(role))
{
throw new DataExistsException(UserSystemResource.Role_Exists);
}
_Repository.Add(role);
//commit the unit of work
_Repository.UnitOfWork.Commit();
return(role.ToDto());
}
public async Task OnActionExecutionAsync(ActionExecutingContext filterContext, ActionExecutionDelegate next)
{
UserDTO user = filterContext.HttpContext.GetCurrentUser();
if (user == null)
{
if (filterContext.Controller is Controller controller)
{
controller.TempData["login_error"] = "You are not authenticated.";
}
filterContext.Result = new RedirectToActionResult("Index", "Login", new { @area = "" });
return;
}
RoleDTO role = user.Role;
if (role != null)
{
if ((_superuser && role.RoleName == "Super User") ||
(_admin && role.RoleName == "Admin") ||
(_user && role.RoleName == "User"))
{
await next();
return;
}
}
if (filterContext.Controller is Controller c1)
{
c1.TempData["login_error"] = "You are not authorized.";
}
filterContext.Result = new RedirectToActionResult("Index", "Login", new { @area = "" });
}
public ActionResult Delete(RoleDTO role)
{
MethodBase method = MethodBase.GetCurrentMethod();
try
{
if (role.Id > 0)
{
Role delRole = Mapper.Map <Role>(role);
RoleRepo.Delete(delRole);
CreateLog(Enums.Success, GetMethodCode(method), LogLevel.Information);
return(Ok(true));
}
else
{
CreateLog(Enums.BadRequest, GetMethodCode(method), LogLevel.Information);
return(BadRequest());
}
}
catch (Exception ex)
{
return(HandleError(ex.Message, GetMethodCode(method)));
}
}
public async Task <string> CreateRole(RoleDTO roleDTO)
{
var role = _mapper.Map <RoleDTO, Role>(roleDTO);
RoleValidator validator = new RoleValidator();
ValidationResult results = validator.Validate(role);
if (!results.IsValid)
{
foreach (var failure in results.Errors)
{
string error = ("Property " + failure.PropertyName + " failed validation. Error was: " + failure.ErrorMessage);
return(error);
}
return("Error");
}
else
{
await _eFUnitOfWork.RoleManager.CreateAsync(role);
return("Роль успішно добавлено!");
}
}
public HttpResponseMessage Search(string q, string role, [FromUri] int pageSize, [FromUri] int pageNumber)
{
if (q == null)
{
q = "";
}
RoleDTO criteria = roleService.GetByName(role);
string[] lines = q.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
int? searchParametr = null;
if (role == "blocked")
{
searchParametr = -1;
}
if (lines.Length > 2)
{
lines = lines.Take(2).ToArray();
}
PagedListDTO <UserDTO> users = criteria != null?userService.Search(lines, pageSize, pageNumber, criteria.Id) :
userService.Search(lines, pageSize, pageNumber, searchParametr);
return(Request.CreateResponse <PagedListDTO <UserDTO> >(HttpStatusCode.OK, users));
}
public HttpResponseMessage LeaveGroup(RoleDTO postData)
{
var success = false;
try
{
if (UserInfo.UserID >= 0 && postData.RoleId > 0)
{
var roleController = new RoleController();
_roleInfo = roleController.GetRole(postData.RoleId, PortalSettings.PortalId);
if (_roleInfo != null)
{
if (UserInfo.IsInRole(_roleInfo.RoleName))
{
RoleController.DeleteUserRole(UserInfo, _roleInfo, PortalSettings, false);
}
success = true;
}
}
}
catch (Exception exc)
{
Logger.Error(exc);
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc);
}
if(success)
{
return Request.CreateResponse(HttpStatusCode.OK, new {Result = "success"});
}
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Unknown Error");
}
public HttpResponseMessage JoinGroup(RoleDTO postData)
{
try
{
if (UserInfo.UserID >= 0 && postData.RoleId > 0)
{
var roleController = new RoleController();
_roleInfo = roleController.GetRole(postData.RoleId, PortalSettings.PortalId);
if (_roleInfo != null)
{
var requireApproval = false;
if(_roleInfo.Settings.ContainsKey("ReviewMembers"))
requireApproval = Convert.ToBoolean(_roleInfo.Settings["ReviewMembers"]);
if ((_roleInfo.IsPublic || UserInfo.IsInRole(PortalSettings.AdministratorRoleName)) && !requireApproval)
{
roleController.AddUserRole(PortalSettings.PortalId, UserInfo.UserID, _roleInfo.RoleID, Null.NullDate);
roleController.UpdateRole(_roleInfo);
var url = Globals.NavigateURL(postData.GroupViewTabId, "", new[] { "groupid=" + _roleInfo.RoleID });
return Request.CreateResponse(HttpStatusCode.OK, new { Result = "success", URL = url });
}
if (_roleInfo.IsPublic && requireApproval)
{
roleController.AddUserRole(PortalSettings.PortalId, UserInfo.UserID, _roleInfo.RoleID, RoleStatus.Pending, false, Null.NullDate, Null.NullDate);
var notifications = new Notifications();
notifications.AddGroupOwnerNotification(Constants.MemberPendingNotification, _tabId, _moduleId, _roleInfo, UserInfo);
return Request.CreateResponse(HttpStatusCode.OK, new { Result = "success", URL = string.Empty });
}
}
}
}
catch (Exception exc)
{
Logger.Error(exc);
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc);
}
return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Unknown Error");
}
public static RoleDTO CreateRoleDTO(int ID, global::System.DateTime createDate, bool isSystemRole, global::System.Collections.ObjectModel.ObservableCollection<RoleFunctionDTO> roleFunctions)
{
RoleDTO roleDTO = new RoleDTO();
roleDTO.Id = ID;
roleDTO.CreateDate = createDate;
roleDTO.IsSystemRole = isSystemRole;
if ((roleFunctions == null))
{
throw new global::System.ArgumentNullException("roleFunctions");
}
roleDTO.RoleFunctions = roleFunctions;
return roleDTO;
}
public void AddToRoles(RoleDTO roleDTO)
{
base.AddObject("Roles", roleDTO);
}
