public async Task <IActionResult> GetAllHierachy()
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "FUNCTION", Operations.Read);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
string userId = User.GetSpecialClaimsApi("Id");
List <FunctionViewModel> funtionVm;
if (User.CheckIsAdminApi())
{
funtionVm = _functionService.GetAll(string.Empty);
}
else
{
funtionVm = _functionService.GetAllWithPermission(userId);
}
List <FunctionViewModel> parents = funtionVm.FindAll(x => x.ParentId == null);
foreach (var parent in parents)
{
parent.ChildFunctions = funtionVm.Where(x => x.ParentId == parent.Id).ToList();
}
return(new OkObjectResult(parents));
}
public HttpResponseMessage GetAllHierarchy(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
IEnumerable <Function> model;
if (User.IsInRole("Admin"))
{
model = _functionService.GetAll(string.Empty);
}
else
{
model = _functionService.GetAllWithPermission(User.Identity.GetUserId());
}
IEnumerable <FunctionViewModel> modelVm = Mapper.Map <IEnumerable <Function>, IEnumerable <FunctionViewModel> >(model);
var parents = modelVm.Where(x => x.Parent == null);
foreach (var parent in parents)
{
parent.ChildFunctions = modelVm.Where(x => x.ParentId == parent.ID).ToList();
}
response = request.CreateResponse(HttpStatusCode.OK, JsonConvert.SerializeObject(parents, Formatting.None,
new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}));
return response;
}));
}
public HttpResponseMessage GetAllHierachy(HttpRequestMessage request, string userName)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
IEnumerable <Function> model;
if (userName == "admin")
{
model = _functionService.GetAll(string.Empty);
}
else
{
//model = _functionService.GetAll(string.Empty);
//var myString = "2fdaa74a-ccd1-4fa0-a256-9349f7c5e4bc";
model = _functionService.GetAllWithPermission(userName);
}
IEnumerable <FunctionViewModel> modelVm = Mapper.Map <IEnumerable <Function>, IEnumerable <FunctionViewModel> >(model);
var parents = modelVm.Where(x => x.Parent == null);
foreach (var parent in parents)
{
parent.ChildFunctions = modelVm.Where(x => x.ParentId == parent.ID).ToList();
}
response = request.CreateResponse(HttpStatusCode.OK, parents);
return response;
}));
}
public HttpResponseMessage GetAllHierachy(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
IEnumerable <Function> model;
if (User.IsInRole("Admin"))
{
model = _functionService.GetAll(string.Empty);
}
else
{
model = _functionService.GetAllWithPermission(User.Identity.GetUserId());
}
IEnumerable <FunctionViewModel> modelVm = Mapper.Map <IEnumerable <Function>, IEnumerable <FunctionViewModel> >(model);
var parents = modelVm.Where(x => x.Parent == null);
foreach (var parent in parents)
{
parent.ChildFunctions = modelVm.Where(x => x.ParentId == parent.ID).ToList();
}
response = request.CreateResponse(HttpStatusCode.OK, parents);
return response;
}));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
var rolesId = new List <string>();
List <FunctionModel> functions;
if (roles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = _functionService.GetAll();
}
else
{
// functions = _functionService.GetFunctionByRoleId()
//if (roles != null && roles.Count() > 0)
//{
// var listRoleToModel = new List<RoleModel>();
// foreach (var item in roles)
// {
// var roleEntity = _roleService.GetRoleByName(item.ToString());
// if (roleEntity != null)
// {
// var roleModel = new RoleModel();
// roleModel.Id = roleEnti;
// listRoleToModel.Add(roleModel.T);
// }
// }
//}
functions = _functionService.GetAll();//("73D8E119-0AAE-4786-F916-08D907B6FBDC");
}
return(View(functions));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
List <FunctionViewModel> functions = new List <FunctionViewModel>();
if (roles.Split(";").Contains(AppRole.AdminRole))
{
functions = await _functionService.GetAll();
}
else
{
// TODO
var functionsTemp = await _functionService.GetAll(string.Empty);
if (functionsTemp.Any())
{
functionsTemp.ForEach(async x =>
{
var havePermission = await _authorizationService.AuthorizeAsync((ClaimsPrincipal)User, x.Id, Operations.Read);
if (havePermission.Succeeded)
{
functions.Add(x);
}
});
}
}
return(View(functions));
}
private async Task loadCbParentId()
{
// List<FunctionViewModel> funs = _functionService.GetAll_List();
List <FunctionViewModel> funs = await _functionService.GetAll();
cbManHinhCha.DataSource = funs;
cbManHinhCha.DisplayMember = "Name";
cbManHinhCha.ValueMember = "Id";
}
public async Task <IActionResult> Get(string filter)
{
var result =
await _authorizationService.AuthorizeAsync(User, CommonConstants.Functions.Function, Operations.Read);
if (!result.Succeeded)
{
return(new ForbidResult());
}
return(new OkObjectResult(_functionService.GetAll(filter)));
}
public async Task <IActionResult> GetAllFilter(string filter)
{
try
{
var model = await _funtionService.GetAll(filter);
return(Ok(new OkObjectResult(model)));
}
catch (Exception ex)
{
return(BadRequest(new OkObjectResult(new { key = "Error: ", value = ex.ToString() })));
}
}
// GET: Webmaster
public ActionResult Index()
{
var user = UserLoginViewModel.Current;
if (user != null && user.UserType == Data.Enum.UserType.Webmaster)
{
List <FunctionViewModel> data = _functionService.GetAll();
return(View(data));
}
else
{
return(RedirectToAction("Login", "Webmaster"));
}
}
public async Task <IActionResult> GetAll()
{
var model = await _functionService.GetAll(string.Empty);
var parentFunctions = model.Where(c => c.ParentId == null);
var items = new List <FunctionViewModel>();
foreach (var function in parentFunctions)
{
//add the parent category to the item list
items.Add(function);
//now get all its children (separate Category in case you need recursion)
GetByParentId(model.ToList(), function, items);
}
return(new ObjectResult(items));
}
public async Task <ResponseResult <List <FunctionDto> > > GetAll()
{
var list = await _functionService.GetAll <FunctionDto>();
list = GetForTree <FunctionDto>(list.OrderBy(f => f.Id).ToList(), null);
return(new ResponseResult <List <FunctionDto> >(list));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
List <FunctionViewModel> functions = new List <FunctionViewModel>();
if (roles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = await _functionService.GetAll(string.Empty);
}
else
{
foreach (var item in roles.Split(";"))
{
var role = await _roleService.GetByName(item);
if (role != null)
{
var permissions = _roleService.GetListFunctionWithRole((Guid)role.Id);
foreach (var per in permissions)
{
if (!functions.Any(x => x.Id == per.FunctionId))
{
functions.Add(_functionService.GetById(per.FunctionId));
}
}
}
}
}
return(View(functions));
}
public async Task <IViewComponentResult> InvokeAsync()
{
List <FunctionViewModel> functions;
if (UserClaimsPrincipal.Claims.Count() != 0)
{
var role = UserClaimsPrincipal.Claims?.FirstOrDefault(x => x.Type == "Roles").Value;
if (role.Split(";").Contains(CommonConstants.AdminRole))
{
functions = await _functionService.GetAll();
}
else
{
//TODO: Get by Permission
functions = new List <FunctionViewModel>();
}
}
else
{
functions = new List <FunctionViewModel>();
}
return(View(functions));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var stringRoles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
List <FunctionViewModel> functions;
if (stringRoles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = await _functionService.GetAll(string.Empty);
}
else
{
//TODO: Get by permission
var roles = stringRoles.Split(";");
var roleId = _roleService.GetByName(roles[0]).Result;
var permissions = _roleService.GetListFunctionWithRole(roleId).Result;
functions = new List <FunctionViewModel>();
foreach (var permission in permissions)
{
if (permission.CanRead == true)
{
functions.Add(_functionService.GetById(permission.FunctionId));
}
}
}
return(View(functions));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
List <FunctionViewModel> functions;
if (roles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = await _functionService.GetAll(string.Empty);
}
else
{
//TODO: Get by permission
functions = await _functionService.GetAll(string.Empty);
}
return(View(functions));
}
// GET: Function
public ActionResult Index()
{
var functions = _functionService.GetAll();
var functionsVm = Mapper.Map <IEnumerable <Function>, IEnumerable <FunctionVm> >(functions);
return(View(functionsVm));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
List <FunctionViewModel> functions;
if (roles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = await _functionService.GetAll(string.Empty);
}
else
{
var listRole = roles.Split(";");
var listfunctions = await _functionService.GetAllFunctionByRole(listRole);
functions = listfunctions.Select(x => new FunctionViewModel()
{
Id = x.Id,
Name = x.Name,
IconCss = x.IconCss,
ParentId = x.ParentId,
SortOrder = x.SortOrder,
Status = x.Status,
URL = x.URL
}).ToList();
}
return(View(functions));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificDefault("Role");
List <FunctionViewModel> functions;
if (roles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = await _functionService.GetAll(string.Empty);
return(View(functions));
}
//TODO: Get by permission
if (roles.Length > 4)
{
functions = await _functionService.GetFunctionByRoles(new FunctionRequest
{
Roles = roles.Split(";").ToList()
});
return(View(functions));
}
return(View(new List <FunctionViewModel>()));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Roles");
List <FunctionViewModel> lstFunctionViewModels = null;
var rolesSplit = roles.Split(";");
if (rolesSplit.Contains(CommonConstants.AdminRole))
{
lstFunctionViewModels = await _functionService.GetAll();
}
else
{
foreach (var itemRole in rolesSplit)
{
var roleModelView = await _roleService.GetByName(itemRole);
if (roleModelView.Id == null)
{
continue;
}
var tmpQueryable = _roleService.GetListFunctionWithRole_Function(roleModelView.Id.Value).OrderBy(t => t.SortOrder).ToList();
if (lstFunctionViewModels == null)
{
lstFunctionViewModels = tmpQueryable;
}
else
{
lstFunctionViewModels.AddRange(tmpQueryable.Except(lstFunctionViewModels));
}
}
}
return(View(lstFunctionViewModels));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecifiedIdentity("Roles");
var model = new List <FunctionViewModel>();
if (roles.Split(';').Contains("Admin"))
{
model = await _functionService.GetAll();
}
return(View(model));
}
public IHttpActionResult GetAll()
{
return(CreateResponse(() =>
{
// var model = User.IsInRole(RoleName.Admin)
// ? _functionService.GetAll()
// : _functionService.GetSpecifiedByUser(User.Identity.GetUserId());
var model = _functionService.GetAll();
return Ok(Mapper.Map <IEnumerable <FunctionDto> >(model));
}));
}
public async Task <IActionResult> GetAllFunction()
{
var functionVms = await _functionService.GetAll();
var sortedFunctions = new List <FunctionViewModel>();
foreach (var item in functionVms.Where(x => x.ParentId == null))
{
sortedFunctions.Add(item);
sortedFunctions.AddRange(functionVms.Where(x => x.ParentId == item.Id).OrderBy(x => x.SortOrder));
}
return(new OkObjectResult(sortedFunctions));
}
public async Task <HttpResponseMessage> GetAll(HttpRequestMessage request, string filter = "")
{
return(await CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
IEnumerable <Function> model = null;
var cacheFunctions = MemoryCacheHelper.GetValue("function");
if (cacheFunctions != null)
{
model = (IEnumerable <Function>)cacheFunctions;
}
else
{
MemoryCacheHelper.Add("function", _functionService.GetAll(filter), DateTimeOffset.MaxValue);
model = _functionService.GetAll(filter);
}
IEnumerable <FunctionViewModel> modelVm = Mapper.Map <IEnumerable <Function>, IEnumerable <FunctionViewModel> >(model);
response = request.CreateResponse(HttpStatusCode.OK, modelVm);
return response;
}));
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
//bool isAuthorized = MumboJumboFunction(context.HttpContext.User, _item, _action); // :)
var functions = _functionService.GetAll();
bool isAuthorized = true;
if (!isAuthorized)
{
context.Result = new UnauthorizedResult();
}
else
{
await next();
}
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsIdentity)User.Identity).Claims.FirstOrDefault(x => x.Type == CommonConstants.UserClaim.Roles);
List <FunctionViewModel> functions;
if (roles != null && roles.Value.Split(";").Contains(CommonConstants.AppRole.Admin))
{
functions = await _functionService.GetAll(string.Empty);
}
else
{
functions = await _functionService.GetAllWithPermission(User.Identity.Name);
}
return(View(functions));
}
public IActionResult GetAllHierachy()
{
IEnumerable <FunctionViewModel> model;
model = CurrentRoleNames.Contains("Administrator") ? _functionService.GetAll(string.Empty) : _functionService.GetAllWithPermission(CurrentRoleIds);
var parents = model.Where(x => x.Parent == null);
var functionViewModels = parents as IList <FunctionViewModel> ?? parents.ToList();
foreach (var parent in functionViewModels)
{
parent.ChildFunctions = model.Where(x => x.ParentId == parent.Id).ToList();
}
return(Ok(functionViewModels));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = (User as ClaimsPrincipal).GetSpecificClaim("Roles");
List <FunctionViewModel> functions;
if (roles.Split(";").Contains(Constants.AdminRole))
{
functions = await _functionService.GetAll();
}
else
{
functions = new List <FunctionViewModel>();
}
return(View(functions));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetClaim("Roles");
if (roles.Split(";").Contains(CommonConstants.Admin))
{
var functionViewModel = await _functionService.GetAll();
return(View(functionViewModel));
}
else
{
//TODO: Get by permission
var func = new List <FunctionViewModel>();
return(View(func));
}
}
public async Task <IViewComponentResult> InvokeAsync()
{
var roles = ((ClaimsPrincipal)User).GetSpecificClaim("Role");
List <FunctionViewModel> functions;
if (roles.Split(";").Contains(CommonConstants.AppRole.AdminRole))
{
functions = await _functionService.GetAll(string.Empty);
}
else
{
//TODO: Get by permission
// viết 1 hàm truyền vào list role trả về những function nào được truy xuất từ roles đó.
// lấy con thì phải lấy cha nó để hiểu thị hehe // thử nghiệm lấy con thôi ?
functions = _functionService.GetAllByRoles(roles);
}
return(View(functions));
}
