public PermissionsViewModel GetUserPermissions(string uniqueName)
{
try
{
var data = (from up in _context.UsersPermissions
join r in _context.Resources on up.ResourceID equals r.ResourceID
where up.UniqueName == uniqueName
orderby r.CategorySequence, r.ResourceSequence
select new Permission
{
category = r.Category,
resource = r.DisplayName
}).ToList();
var permissions = new PermissionsViewModel()
{
permissions = data
};
return(permissions);
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult> RemoveRole(PermissionsViewModel model)
{
var _context = new ApplicationDbContext();
if (ModelState.IsValid)
{
var user = UserManager.FindByName(model.UserName);
if (user != null)
{
var result = await UserManager.RemoveFromRoleAsync(user.Id, model.RoleName);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Users"));
}
AddErrors(result);
}
else
{
ModelState.AddModelError("", "Username not found");
}
}
var roles = _context.Roles.ToList();
model.RolesList = roles;
return(View(model));
}
public ActionResult SaveEmployeeForm(PermissionsViewModel model)
{
if (model.Id == 0)
{
if (model.Account == null)
{
using (var ctx = new SolutionsContext())
model.ResourceRepo = ctx.Resources.ToList();
model.SelectedApproveResources = new List <int>();
model.SelectedPerformResources = new List <int>();
ModelState.AddModelError("Account", "Не указана учетная запись");
return(View("EmployeeForm", model));
}
var employee = Employee.GetEmployee(model.Account);
if (employee == null)
{
InsertEmployee(model);
}
else
{
Employee.EmployeeActivity(employee.Id, true);
model.Id = employee.Id;
UpdateEmployee(model);
}
}
else
{
UpdateEmployee(model);
}
return(RedirectToAction("Index"));
}
public ActionResult PreviousYear()
{
int annee;
var viewModel = new PermissionsViewModel();
if (int.TryParse(Request.Form["inputAnnee"], out annee) && annee > ContexteStatic.MinYearPermission)
{
viewModel.Annee = --annee;
}
else
{
viewModel.Annee = DateTime.Now.Year;
}
var dateMax = new DateTime(annee, 12, 31);
var dateMin = new DateTime(annee, 01, 01);
viewModel.ListePermissions =
Db.Permissions.Where(
x =>
x.Date <= dateMax &&
x.Date >= dateMin).ToList();
return(View(viewModel));
}
public HttpResponseMessage GetRoles(PermissionsViewModel model)
{
try
{
if (string.IsNullOrEmpty(model.IdPermission))
{
model.success = "true";
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
else
{
int id = int.Parse(model.IdPermission);
List <ApplicationRole> roles = ApplicationRoleManager.GetPermission(id).ROLES;
model.success = "true";
model.ListGruppi = roles;
model.Totale = roles.Count.ToString();
}
}
catch (Exception ex)
{
model.success = "false";
model.message = ex.Message;
}
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
/// <summary>
/// Charge la page de listing des permissions
/// </summary>
/// <param name="year">l'année des permissions à afficher</param>
/// <returns></returns>
public ActionResult Index(int?year)
{
if (year == null)
{
year = DateTime.Now.Year;
}
if (year < ContexteStatic.MinYearPermission)
{
return(RedirectToAction("Index", DateTime.Now.Year));
}
var dateMax = new DateTime(year.Value, 12, 31);
var dateMin = new DateTime(year.Value, 01, 01);
var viewModel = new PermissionsViewModel
{
Annee = year.Value,
ListePermissions =
Db.Permissions.Where(
x =>
x.Date <= dateMax &&
x.Date >= dateMin).ToList()
};
return(View(viewModel));
}
public HttpResponseMessage GetPermissions(PermissionsViewModel model)
{
try
{
List <PERMISSION> rights = new List <PERMISSION>();
int limit = int.Parse(model.limit);
int start = 0;
if (model.page == "1")
{
start = 0;
}
else
{
start = ((int.Parse(model.page) * int.Parse(model.page)) - 5) + 1;
};
rights = ApplicationRoleManager.GetPermissions(start, limit);
int count = ApplicationRoleManager.GetPermissionsCount();
model.ListDiritti = rights;
model.Totale = count.ToString();
}
catch (Exception ex)
{
model.success = "false";
model.message = ex.Message;
}
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
public HttpResponseMessage GetRightsByRole(PermissionsViewModel model)
{
try
{
if (string.IsNullOrEmpty(model.IdRole))
{
model.success = "true";
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
else
{
int id = int.Parse(model.IdRole);
ApplicationRole role = ApplicationRoleManager.GetRole(id);
model.success = "true";
model.ListDiritti = role.PERMISSIONS.ToList();
model.Totale = role.PERMISSIONS.Count.ToString();
}
}
catch (Exception ex)
{
model.success = "false";
model.message = ex.Message;
}
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
public async Task <IActionResult> Put(string id, [FromBody] PermissionsViewModel item)
{
await _documentClient.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(databaseId, collectionId, id),
item);
return(Ok());
}
public HttpResponseMessage RemoveRole(string id, string roleid)
{
PermissionsViewModel model = new PermissionsViewModel();
try
{
if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(roleid))
{
model.success = "true";
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
else
{
int idp = int.Parse(id);
int idrole = int.Parse(roleid);
if (ApplicationRoleManager.RemovePermission4Role(idrole, idp))
{
model.success = "true";
}
else
{
model.success = "false";
model.message = "rimozione non effettuata";
}
}
}
catch (Exception ex)
{
model.success = "false";
model.message = ex.Message;
}
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
public IActionResult Permissions(int id)
{
var employee = _employeeService.GetEmployee(id);
var permissions = _employeeService.GetPermissions(id);
var model = new PermissionsViewModel(id, employee.Name, permissions);
return(View(model));
}
// GET: Admin/Permissions
public ActionResult Index()
{
var viewModel = new PermissionsViewModel
{
Permissions = _permissionService.GetAll()
};
return(View(viewModel));
}
public ActionResult Index()
{
var db = new ApplicationDbContext();
var vm = new PermissionsViewModel();
vm.Users = db.Users.ToList();
return(View(vm));
}
private void UpdateEmployee(PermissionsViewModel permissions)
{
var employee = Employee.GetEmployee(permissions.Id);
SetSendMail(employee, permissions.SendMail);
ActualizePermissions(employee, permissions.Author, (int)Enums.Roles.AUTHOR);
ActualizePermissions(employee, permissions.Tester, (int)Enums.Roles.TESTER);
ActualizePermissions(employee, permissions.SelectedApproveResources, (int)Enums.Roles.APPROVER);
ActualizePermissions(employee, permissions.SelectedPerformResources, (int)Enums.Roles.PERFORMER);
ActualizePermissions(employee, permissions.Administrator, (int)Enums.Roles.ADMINISTRATOR);
}
public ActionResult RemoveRole()
{
var _context = new ApplicationDbContext();
var roles = _context.Roles.ToList();
var viewModel = new PermissionsViewModel
{
RolesList = roles
};
return(View(viewModel));
}
// GET: Role/Permissions/5
public async Task <IActionResult> Permissions(string id)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
var claims = await _roleManager.GetClaimsAsync(role);
var groups = _permissionDefinitionManager.GetGroups();
var model = new PermissionsViewModel
{
Groups = groups.Select(p1 =>
{
var claim1 = new Claim(p1.Name, p1.Name);
return(new PermissionGroupViewModel
{
Name = p1.Name,
DisplayName = p1.DisplayName,
IsGranted = claims.Any(m => m.Type == claim1.Type && m.Value == claim1.Value),
Permissions = p1.Permissions.Select(p2 =>
{
var claim2 = new Claim(p1.Name, p2.Name);
return new PermissionGrantViewModel
{
Name = p2.Name,
DisplayName = p2.DisplayName,
IsGranted = claims.Any(m => m.Type == claim2.Type && m.Value == claim2.Value),
Children = p2.Children.Select(p3 =>
{
var claim3 = new Claim(p1.Name, p3.Name);
return new PermissionGrantViewModel
{
Name = p3.Name,
DisplayName = p3.DisplayName,
IsGranted = claims.Any(m => m.Type == claim3.Type && m.Value == claim3.Value),
};
}).ToList()
};
}).ToList()
});
}).ToList()
};
return(View(model));
}
public ActionResult Edit(int ID)
{
PermissionsViewModel model = new PermissionsViewModel();
var entity = PermissionsService.Find(ID);
model.Name = entity.Name;
model.ID = entity.ID;
model.Description = entity.Description;
model.Action = entity.Action;
model.Controller = entity.Controller;
model.Namespace = entity.Namespace;
model.DepartmentID = entity.DepartmentID;
ViewBag.Data_DepartmentID = GetSelectList(entity.DepartmentID);
return(View(model));
}
private void InsertEmployee(PermissionsViewModel permissions)
{
using (var ctx = new SolutionsContext())
{
var employee = new Employee()
{
Account = AccountFormat(permissions.Account),
Active = true,
SendMail = permissions.SendMail
};
ctx.Employees.Add(employee);
ctx.SaveChanges();
if (permissions.Author)
{
InsertPermission(ctx, employee.Id, (int)Enums.Roles.AUTHOR, 0);
}
if (permissions.Tester)
{
InsertPermission(ctx, employee.Id, (int)Enums.Roles.TESTER, 0);
}
if (permissions.SelectedApproveResources != null)
{
InsertPermissions(
ctx,
employee.Id,
(int)Enums.Roles.APPROVER,
permissions.SelectedApproveResources);
}
if (permissions.SelectedPerformResources != null)
{
InsertPermissions(
ctx,
employee.Id,
(int)Enums.Roles.PERFORMER,
permissions.SelectedPerformResources);
}
if (permissions.Administrator)
{
InsertPermission(ctx, employee.Id, (int)Enums.Roles.ADMINISTRATOR, 0);
}
}
}
private void CollectResources(Employee employee, int roleId, ref PermissionsViewModel model)
{
var permissions = employee.Permissions.Where(x => x.RoleId == roleId).ToList();
foreach (var permission in permissions)
{
if (roleId == (int)Enums.Roles.APPROVER)
{
model.SelectedApproveResources.Add(permission.ResourceId);
}
else if (roleId == (int)Enums.Roles.PERFORMER)
{
model.SelectedPerformResources.Add(permission.ResourceId);
}
}
}
public async Task <IActionResult> Index()
{
var model = new PermissionsViewModel(_defaultModelValues);
try
{
// Do this to load the template controls.
model.TemplateHtml = await _templateRequest.RequestTemplateHtmlAsync();
}
catch (Exception ex)
{
// Catch and report exceptions - don't throw them and cause the page to fail
ex.ToExceptionless().Submit();
}
return(View(model));
}
public async Task <IActionResult> Permissions(string id, PermissionsViewModel model)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(NotFound());
}
var claims = await _roleManager.GetClaimsAsync(role);
foreach (var p1 in model.Groups)
{
var claim1 = new Claim(p1.Name, p1.Name);
await UpdatePermissionAsync(claim1, p1.IsGranted);
foreach (var p2 in p1.Permissions)
{
var claim2 = new Claim(p1.Name, p2.Name);
await UpdatePermissionAsync(claim2, p2.IsGranted);
foreach (var p3 in p2.Children)
{
var claim3 = new Claim(p1.Name, p3.Name);
await UpdatePermissionAsync(claim3, p3.IsGranted);
}
}
}
async Task UpdatePermissionAsync(Claim claim, bool isGranted)
{
if (isGranted)
{
if (!claims.Any(m => m.Type == claim.Type && m.Value == claim.Value))
{
await _roleManager.AddClaimAsync(role, claim);
}
}
else
{
await _roleManager.RemoveClaimAsync(role, claim);
}
}
return(RedirectToAction("Index"));
}
public ActionResult AddEmployee()
{
using (var ctx = new SolutionsContext())
{
var model = new PermissionsViewModel()
{
Author = true,
Tester = true,
Approver = false,
Performer = false,
Administrator = false,
ResourceRepo = ctx.Resources.ToList(),
SelectedApproveResources = new List <int>(),
SelectedPerformResources = new List <int>()
};
return(View("EmployeeForm", model));
}
}
public ActionResult Index()
{
using (var ctx = new SolutionsContext())
{
var permissionRepo = new List <PermissionsViewModel>();
var employees = ctx.Employees.Where(x => x.Active).ToList();
employees.ForEach(x => x.GetData());
employees = employees.OrderBy(x => x.Name).ToList();
foreach (var employee in employees)
{
var model = new PermissionsViewModel()
{
Id = employee.Id,
Account = employee.Account,
Name = employee.Name,
SendMail = employee.SendMail,
Author = employee.HasRole((int)Enums.Roles.AUTHOR),
Tester = employee.HasRole((int)Enums.Roles.TESTER),
Approver = employee.HasRole((int)Enums.Roles.APPROVER),
Performer = employee.HasRole((int)Enums.Roles.PERFORMER),
Administrator = employee.HasRole((int)Enums.Roles.ADMINISTRATOR)
};
if (model.Approver)
{
model.ApproveResources =
BindPermissions(employee.Permissions.ToList(), (int)Enums.Roles.APPROVER);
}
if (model.Performer)
{
model.PerformResources =
BindPermissions(employee.Permissions.ToList(), (int)Enums.Roles.PERFORMER);
}
permissionRepo.Add(model);
}
return(View(permissionRepo));
}
}
public ActionResult EditEmployee(int id)
{
using (var ctx = new SolutionsContext())
{
var employee = Employee.GetEmployee(id);
var model = new PermissionsViewModel()
{
Id = employee.Id,
Account = employee.Account,
SendMail = employee.SendMail,
ResourceRepo = ctx.Resources.ToList(),
SelectedApproveResources = new List <int>(),
SelectedPerformResources = new List <int>()
};
if (employee.HasRole((int)Enums.Roles.AUTHOR))
{
model.Author = true;
}
if (employee.HasRole((int)Enums.Roles.TESTER))
{
model.Tester = true;
}
if (employee.HasRole((int)Enums.Roles.APPROVER))
{
CollectResources(employee, (int)Enums.Roles.APPROVER, ref model);
}
if (employee.HasRole((int)Enums.Roles.PERFORMER))
{
CollectResources(employee, (int)Enums.Roles.PERFORMER, ref model);
}
if (employee.HasRole((int)Enums.Roles.ADMINISTRATOR))
{
model.Administrator = true;
}
return(View("EmployeeForm", model));
}
}
public async Task <IActionResult> Permissions(PermissionsViewModel viewModel)
{
var model = new WeChatPayScorePermissionsBodyModel
{
AppId = _optionsAccessor.Value.AppId,
ServiceId = viewModel.ServiceId,
AuthorizationCode = viewModel.AuthorizationCode,
NotifyUrl = viewModel.NotifyUrl
};
var request = new WeChatPayScorePermissionsRequest();
request.SetBodyModel(model);
var response = await _client.ExecuteAsync(request, _optionsAccessor.Value);
ViewData["response"] = response.Body;
return(View());
}
public HttpResponseMessage Create(PermissionsViewModel model)
{
if (ModelState.IsValid)
{
List <string> _errors = new List <string>();
try
{
PERMISSION newPermission = new PERMISSION()
{
PermissionDescription = model.description
};
if (ApplicationRoleManager.AddPermission(newPermission))
{
model.success = "true";
}
}
catch (Exception ex)
{
model.message = ex.Message;
model.success = "false";
}
if (_errors.Count() > 0)
{
foreach (string e in _errors)
{
model.message += e;
}
model.success = "false";
}
}
else
{
model.success = "false";
foreach (var e in ModelState.Values)
{
foreach (var error in e.Errors)
{
model.message += "Campo non valido " + error.ErrorMessage;
}
}
}
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
public IActionResult Permissions(PermissionsViewModel permissionsViewModel)
{
using (var db = new CrossRefContext())
{
var user = db.Users.Include("Permission").First(u =>
u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value
));
user.Permission.ShowAffiliation = permissionsViewModel.ShowAffiliation;
user.Permission.ShowArticles = permissionsViewModel.ShowArticles;
user.Permission.ShowBiography = permissionsViewModel.ShowBiography;
user.Permission.ShowDateOfBirth = permissionsViewModel.ShowDateOfBirth;
db.Update(user);
db.SaveChanges();
return(RedirectToAction("MyOverview", "Profile"));
}
}
public IActionResult Permissions()
{
using (var db = new CrossRefContext())
{
var user = db.Users.Include("Permission").First(u =>
u.Email.Equals(
User.FindFirst(ClaimTypes.Email).Value
));
var permissionsViewModel = new PermissionsViewModel
{
ShowBiography = user.Permission.ShowBiography,
ShowAffiliation = user.Permission.ShowAffiliation,
ShowArticles = user.Permission.ShowArticles,
ShowDateOfBirth = user.Permission.ShowDateOfBirth
};
return(View(permissionsViewModel));
}
}
public HttpResponseMessage Delete(PermissionsViewModel model)
{
if (ModelState.IsValid)
{
List <string> _errors = new List <string>();
try
{
int id = int.Parse(model.IdPermission);
if (ApplicationRoleManager.DeletePermission(id))
{
model.success = "true";
}
}
catch (Exception ex)
{
model.message = ex.Message;
model.success = "false";
}
if (_errors.Count() > 0)
{
foreach (string e in _errors)
{
model.message += e;
}
model.success = "false";
}
}
else
{
model.success = "false";
foreach (var e in ModelState.Values)
{
foreach (var error in e.Errors)
{
model.message += "Campo non valido " + error.ErrorMessage;
}
}
}
return(this.Request.CreateResponse <PermissionsViewModel>(HttpStatusCode.OK, model));
}
public ActionResult Edit(PermissionsViewModel model)
{
ViewBag.Data_DepartmentID = GetSelectList(model.DepartmentID);
ServiceResult result = new ServiceResult();
TempData["Service_Result"] = result;
if (ModelState.IsValid)
{
try
{
Permissions entity = new Permissions();
entity.ID = model.ID;
entity.Name = model.Name;
entity.Description = model.Description;
entity.Controller = model.Controller;
entity.Action = model.Action;
entity.Namespace = model.Namespace;
entity.DepartmentID = model.DepartmentID;
PermissionsService.Update(entity);
result.Message = "编辑权限成功！";
LogHelper.WriteLog("编辑权限成功");
return(RedirectToAction("index"));
}
catch (DbEntityValidationException ex)
{
result.Message = Utilities.GetInnerMostException(ex);
result.AddServiceError(result.Message);
LogHelper.WriteLog("添加权限错误", ex);
return(View(model));
}
}
else
{
result.Message = "请检查表单是否填写完整！";
result.AddServiceError("请检查表单是否填写完整！");
return(View(model));
}
}
