private PermissionDTO ToPermission(Permission dbitem)
{
PermissionDTO result = new PermissionDTO();
result.ID = dbitem.ID;
// result.ObjectCategory = (DatabaseObjectCategory)Enum.Parse(typeof(DatabaseObjectCategory), dbitem.ObjectCategory);
result.SecurityObjectID = dbitem.SecurityObjectID;
result.SecuritySubjectID = dbitem.SecuritySubjectID;
result.SecurityObjectCategory = (DatabaseObjectCategory)dbitem.SecurityObject.Type;
//if (dbitem.RoleID != null)
//{
// result.RoleOrRoleGroup = new RoleOrRoleGroupDTO();
// result.RoleOrRoleGroup.ID = dbitem.RoleID.Value;
// result.RoleOrRoleGroup.Name = dbitem.Role.Name;
// result.RoleOrRoleGroup.Type = RoleOrRoleGroupType.Role;
//}
//else if (dbitem.SecurityRoleGroupID != null)
//{
// result.RoleOrRoleGroup = new RoleOrRoleGroupDTO();
// result.RoleOrRoleGroup.ID = dbitem.SecurityRoleGroupID.Value;
// result.RoleOrRoleGroup.Name = dbitem.RoleGroup.Name;
// result.RoleOrRoleGroup.Type = RoleOrRoleGroupType.RoleGroup;
//}
//if (withActions)
//{
foreach (var action in dbitem.Permission_Action)
{
// SecActionDTO item = new SecActionDTO();
var securityAction = (SecurityAction)Enum.Parse(typeof(SecurityAction), action.Action);
//item.ID = dbItem.ID;
result.Actions.Add(securityAction);
}
//}
return(result);
}
public static string Edit(PermissionDTO Permission)
{
using (ArmyBaseContext db = new ArmyBaseContext())
{
string error = null;
var toModify = db.Permissions.Where(x => x.Id == Permission.Id).FirstOrDefault();
toModify.Name = Permission.Name;
toModify.Description = Permission.Description;
toModify.MinRankId = Permission.MinRankId;
var context = new ValidationContext(toModify, null, null);
var result = new List <ValidationResult>();
Validator.TryValidateObject(toModify, context, result, true);
foreach (var x in result)
{
error = error + x.ErrorMessage + "\n";
}
if (error == null)
{
db.SaveChanges();
}
return(error);
}
}
public static List <PermissionDTO> getRolePermissions(string idRole, string idModule)
{
List <PermissionDTO> permissions = new List <PermissionDTO>();
using (SqlConnection connection = new SqlConnection(WebConfigurationManager.ConnectionStrings["connectionRRHHDatabase"].ConnectionString))
{
SqlCommand command = new SqlCommand("usp_get_rolePermissions_byModule", connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add("@role_id", SqlDbType.Int);
command.Parameters["@role_id"].Value = idRole;
command.Parameters.Add("@id_module", SqlDbType.Int);
command.Parameters["@id_module"].Value = idModule;
command.Connection.Open();
SqlDataReader rdr = command.ExecuteReader();
while (rdr.Read())
{
PermissionDTO permissionDTO = new PermissionDTO();
permissionDTO.id_permission = rdr["id_permission"].ToString();
permissionDTO.name = rdr["name"].ToString();
permissionDTO.module_id = rdr["id_permission"].ToString();
permissionDTO.isEnabled = rdr["isEnabled"].ToString();
permissionDTO.id_role_permission = rdr["id_role_permission"].ToString();
permissions.Add(permissionDTO);
}
};
return(permissions);
}
public async Task <IEnumerable <PermissionDTO> > GetPermissionsAsync(Guid?userId)
{
Task <IEnumerable <PermissionDTO> > taskInvoke = Task <IEnumerable <PermissionDTO> > .Factory.StartNew(() =>
{
var permissions = _store.QueryAsync(new RemoteStorage.Permission()).Result.Cast <RemoteStorage.Permission>();
var userPermissions = permissions.Where(p => p.UserId == userId);
List <PermissionDTO> permissionsDTO = new List <PermissionDTO>();
foreach (var permission in userPermissions)
{
PermissionDTO permissionDTO = new PermissionDTO()
{
AuctionId = permission.AuctionId,
Id = permission.Id,
UserId = permission.UserId,
Role = (BussinessLogic.Models.Role)permission.Role,
CategoriesId = new List <Guid>()
};
permissionDTO.CategoriesId = permission.CategoriesId.ToList();
permissionsDTO.Add(permissionDTO);
}
return(permissionsDTO);
});
return(await taskInvoke);
}
public AddPermissionViewModel(PermissionDTO permission)
{
Ranks = RankService.GetAllBindableCollection();
IsEdit = true;
ButtonLabel = "Edit";
int i = 0;
while (ActualRank == null)
{
if (Ranks[i].Id == permission.MinRankId)
{
ActualRank = i;
break;
}
else
{
i++;
}
}
this.toEdit = permission;
Name = permission.Name;
Description = permission.Description;
NotifyOfPropertyChange(() => Name);
NotifyOfPropertyChange(() => Description);
}
public ActionResult EditMenuPermission(Guid menuId, PermissionDTO permission, Guid?id)
{
var menu = _menuService.FindBy(menuId) ?? new MenuDTO();
if (!id.HasValue)
{
menu.Permissions.Add(permission);
}
else
{
permission.Id = id.Value;
var oldPermission = menu.Permissions.FirstOrDefault(x => x.Id == permission.Id);
if (oldPermission != null)
{
permission.Created = oldPermission.Created;
menu.Permissions.Remove(oldPermission);
}
menu.Permissions.Add(permission);
}
_menuService.UpdatePermission(menu);
return(Json(new AjaxResponse
{
Succeeded = true,
ShowMessage = false,
RedirectUrl = Url.Action("MenuPermissionList", new { menuId = menuId })
}));
}
void FillAll()
{
dto = PermissionBLL.GetAll();
if (!UserStatic.isAdmin)
{
dto.Permissions = dto.Permissions.Where(x => x.EmployeeID == UserStatic.EmployeeID).ToList();
}
dataGridView1.DataSource = dto.Permissions;
combofull = false;
cmbDepartment.DataSource = dto.Departments;
cmbDepartment.DisplayMember = "DepartmentName";
cmbDepartment.ValueMember = "ID";
cmbDepartment.SelectedIndex = -1;
cmbPosition.DataSource = dto.Positions;
cmbPosition.DisplayMember = "PositionName";
cmbPosition.ValueMember = "ID";
cmbPosition.SelectedIndex = -1;
combofull = true;
cmbState.DataSource = dto.States;
cmbState.DisplayMember = "StateName";
cmbState.ValueMember = "ID";
cmbState.SelectedIndex = -1;
}
public void TestAddNewPermission()
{
string name = Guid.NewGuid().ToString();
long id = permService.AddNewPermission(name, name);
PermissionDTO permissionDto1 = permService.GetById(id);
Assert.AreEqual(permissionDto1.Name, name);
Assert.AreEqual(permissionDto1.Description, name);
PermissionDTO permissionDto2 = permService.GetByName(name);
Assert.AreEqual(permissionDto2.Name, name);
Assert.AreEqual(permissionDto2.Description, name);
var permissions = permService.GetAll();
Assert.IsNotNull(permissions);
string newName = Guid.NewGuid().ToString();
permService.UpdatePermission(id, newName, newName);
PermissionDTO permissionDto3 = permService.GetById(id);
Assert.AreEqual(permissionDto3.Name, newName);
Assert.AreEqual(permissionDto3.Description, newName);
Assert.AreNotEqual(permissionDto3.Name, name);
Assert.AreNotEqual(permissionDto3.Description, name);
}
public async Task <bool> UpdateAsync(string id, [FromBody] PermissionDTO dto)
{
var service = await _dbContext.Services.FirstOrDefaultAsync(x => x.Id == dto.ServiceId.Trim());
if (service == null)
{
throw new ApplicationException($"Service not exists");
}
var entity = await _dbContext.Permissions.FirstOrDefaultAsync(x => x.Id == id);
if (entity == null)
{
throw new ArgumentException("Permission not exists");
}
var type = Enum.Parse <PermissionType>(dto.Type);
entity.Modify(dto.ServiceId, type, dto.Module, dto.Name, dto.Identification, dto.Description);
entity.SetModificationAudited(Session.UserId, Session.UserName);
_dbContext.Permissions.Update(entity);
await _dbContext.SaveChangesAsync();
return(true);
}
public static string GetOperationLog(this PermissionDTO entity, PermissionDTO oldDTO = null)
{
var sb = new StringBuilder();
if (oldDTO == null)
{
sb.AppendLine(string.Format("{0}: {1}", CommonMessageResources.Name, entity.Name));
sb.AppendLine(string.Format("{0}: {1}", CommonMessageResources.Code, entity.Code));
sb.AppendLine(string.Format("{0}: {1}", CommonMessageResources.SortOrder, entity.SortOrder));
}
else
{
if (entity.Name != oldDTO.Name)
{
sb.AppendLine(string.Format("{0}: {1} => {2}",
CommonMessageResources.Name, oldDTO.Name, entity.Name));
}
if (entity.Code != oldDTO.Code)
{
sb.AppendLine(string.Format("{0}: {1} => {2}",
CommonMessageResources.Code, oldDTO.Code, entity.Code));
}
if (entity.SortOrder != oldDTO.SortOrder)
{
sb.AppendLine(string.Format("{0}: {1} => {2}",
CommonMessageResources.SortOrder, oldDTO.SortOrder, entity.SortOrder));
}
}
return(sb.ToString().TrimEnd('\r', '\n'));
}
public bool AddPermission(PermissionDTO model)
{
var permission = model.Map <Permission>();
_eventPublisher.EntityInserted(permission);//清缓存
return(_permissionRepository.Add(permission));
}
public ActionResult EditMenuPermission(Guid menuId, PermissionDTO permission, Guid?id)
{
return(HttpHandleExtensions.AjaxCallGetResult(() =>
{
var menu = _menuService.FindBy(menuId) ?? new MenuDTO();
if (!id.HasValue)
{
menu.Permissions.Add(permission);
}
else
{
permission.Id = id.Value;
var oldPermission = menu.Permissions.FirstOrDefault(x => x.Id == permission.Id);
if (oldPermission != null)
{
permission.Created = oldPermission.Created;
menu.Permissions.Remove(oldPermission);
}
menu.Permissions.Add(permission);
}
_menuService.UpdatePermission(menu);
this.JsMessage = MessagesResources.Update_Success;
return Json(new AjaxResponse
{
Succeeded = true,
RedirectUrl = Url.Action("MenuPermissionList", new { menuId = menuId })
});
}));
}
/// <summary>
/// Crea un perfil en base al modelo recibido, considerando únicamente los hijos del primer nivel.
/// </summary>
/// <param name="profile"></param>
/// <returns></returns>
public ResultBM CreateProfile(ProfileBM profile)
{
try
{
log.AddLogInfo("Creando perfil", "Creando perfil.", this);
ProfileDAL profileDal = new ProfileDAL();
ResultBM isValidResult = IsValid(profile);
if (!isValidResult.IsValid())
{
return(isValidResult);
}
//Se agrega el root
PermissionDTO root = new PermissionDTO(profile.fatherCode, profile.code, profile.Description);
profileDal.SaveProfile(root);
CreateRelation(profile);
log.AddLogInfo("Creando perfil", "El perfil se ha creado exitosamente.", this);
return(new ResultBM(ResultBM.Type.OK, "Perfil creado: " + profile.Description));
}
catch (Exception exception)
{
log.AddLogCritical("Recuperando perfil", exception.Message, this);
return(new ResultBM(ResultBM.Type.EXCEPTION, SessionHelper.GetTranslation("SAVING_ERROR") + " " + exception.Message, exception));
}
}
public OutPutDTO AddPermissions([FromBody] PermissionDTO permission)
{
var trans = commonBu.getDbContext().Database.BeginTransaction();
try
{
List <SqlParameter> parameters = new List <SqlParameter>();
string sql = "";
foreach (var PermissionID in permission.Selection)
{
string param = "@PermissionID" + parameters.Count;
sql += @" INSERT INTO RolePermission (RoleID, PermissionID) Values(@RoleID, " + param + ") ";
parameters.Add(new SqlParameter(param, PermissionID));
}
parameters.Add(new SqlParameter("@RoleID", permission.RoleID));
int n = commonBu.getDbContext().Database.ExecuteSqlCommand(sql, parameters.ToArray());
trans.Commit();
return(new OutPutDTO(true, Constants.STATUS_CODE.SUCCESS, Constants.STATUS_MESSAGE.SUCCESS, null));
}
catch (Exception ex)
{
trans.Rollback();
return(new OutPutDTO(false, Constants.STATUS_CODE.EXCEPTION, Constants.STATUS_MESSAGE.EXCEPTION + ex.Message, null));
}
}
public PermissionModel CreatePermissionModel(PermissionDTO permissionDTO)
{
return new PermissionModel()
{
PermissionId = permissionDTO.PermissionId,
Description = permissionDTO.Description
};
}
public async Task <IActionResult> UpdatePermission(PermissionDTO permissionDTO)
{
var permission = _mapper.Map <Permission>(permissionDTO);
await _permissionBusiness.Update(permission);
return(Ok(permission));
}
public async Task <ResponseDTO> Register(PermissionDTO dto)
{
if (ModelState.IsValid)
{
return(await _PermissionApplicationService.Register(dto));
}
return(ModelState.ToResponse());
}
public IHttpActionResult updateRoleElement(PermissionDTO pPermissionDTO)
{
if (!RolesData.updateRolePermission(pPermissionDTO))
{
return(BadRequest());
}
return(Ok());
}
public void LoadModifyPermissionPage(PermissionDTO permission)
{
IWindowManager manager = new WindowManager();
AddPermissionViewModel modify = new AddPermissionViewModel(permission);
manager.ShowDialog(modify, null, null);
Reload();
}
public async Task RemovePermissionAsync(PermissionDTO permissionDTO)
{
await Task.Factory.StartNew(async() =>
{
RemoteStorage.Permission permission = Mapper.Map <RemoteStorage.Permission>(permissionDTO);
await _store.RemoveAsync(permission);
});
}
public void RemovePermission(PermissionDTO permissionDTO)
{
var permission = new Permission()
{
};
permission.InjectFrom(permissionDTO);
_userRoleRepo.RemovePermission(permission);
}
public async Task <ResponseDTO> Register(PermissionDTO dto)
{
//Map to Command
var command = _mapper.Map <PermissionDTO, RegisterPermissionCommand>(dto);
//Execute Command
var resp = await _bus.SendAsync(command);
return(ResponseBuilder.Correct(resp));
}
private PermissionDTO ToDTO(PermissionEntity permission)
{
PermissionDTO permissionDto = new PermissionDTO();
permissionDto.Name = permission.Name;
permissionDto.Description = permission.Description;
permissionDto.CreateDateTime = permission.CreateDateTime;
permissionDto.Id = permission.Id;
return(permissionDto);
}
public static void Delete(PermissionDTO Permission)
{
using (ArmyBaseContext db = new ArmyBaseContext())
{
var toDelete = db.Permissions.Where(x => x.Id == Permission.Id).FirstOrDefault();
toDelete.IsDisabled = true;
db.SaveChanges();
}
}
public async Task AddPermissionAsync(PermissionDTO permissionDTO)
{
await Task.Factory.StartNew(async() =>
{
var permission = Mapper.Map <RemoteStorage.Permission>(permissionDTO);
permission.Role = (int)permissionDTO.Role;
permission.CategoriesId = permissionDTO.CategoriesId?.ToArray();
await _store.AddAsync(permission);
});
}
public PartialViewResult Form(int?id)
{
PermissionDTO model = new PermissionDTO();
if (id.GetValueOrDefault() != 0)
{
model = _accountService.GetPermissionById(id.Value);
}
return(PartialView("_Form", model));
}
private PermissionDTO ToDTO(PermissionEntity entity)
{
PermissionDTO dto = new PermissionDTO();
dto.Name = entity.Name;
dto.CreateDateTime = entity.CreateDateTime;
dto.Description = entity.Description;
dto.Id = entity.Id;
return(dto);
}
public static PermissionDTO GetAll()
{
PermissionDTO dto = new PermissionDTO();
dto.Departments = DepartmentDAO.GetDepartments();
dto.Positions = PositionDAO.GetPositions();
dto.States = PermissionDAO.GetStates();
dto.Permissions = PermissionDAO.GetPermissions();
return(dto);
}
private PermissionDTO ToDTO(PermissionEntity p)
{
PermissionDTO dto = new PermissionDTO();
dto.CreateDateTime = p.CreateDateTime;
dto.Description = p.Description;
dto.Id = p.Id;
dto.Name = p.Name;
return(dto);
}
PermissionDTO ToDto(PermissionEntity permission)
{
PermissionDTO dto = new PermissionDTO();
dto.CreateDateTime = permission.CreateDateTIme;
dto.Description = permission.Description;
dto.Id = permission.Id;
dto.Name = permission.Name;
return(dto);
}
public Permission(PermissionDTO source)
: base(source)
{
PermissionID = source.PermissionID;
Name = source.Name;
GroupID = source.GroupID;
Namespace = source.Namespace;
Controller = source.Controller;
Action = source.Action;
}
