public async Task<ActionResult> Details(string roleId, string permissionId)
{
if (string.IsNullOrWhiteSpace(roleId) || string.IsNullOrWhiteSpace(permissionId))
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
// 取权限
ApplicationPermission permission =
db.Permissions.Find(new object[] { int.Parse(permissionId) });
// 取角色
var role = await RoleManager.FindByIdAsync(int.Parse(roleId));
if (permission == null)
{
return HttpNotFound();
}
var view = new PermissionViewModel
{
Controller = permission.Controller,
Action = permission.Action,
Description = permission.Description
};
view.RoleId = int.Parse(roleId);
view.RoleName = role.Name;
return View(view);
}
public async Task<ActionResult> Index(string roleId, int page = 1)
{
// 取role列表
var roles = await RoleManager.Roles.ToListAsync();
// roleId是否为空
if (string.IsNullOrWhiteSpace(roleId))
{
roleId = roles.FirstOrDefault().Id.ToString();
}
// 放入ViewBag，设置默认值
ViewBag.RoleID = new SelectList(roles, "Id", "Name", roleId);
// 取角色权限列表
var permissions = RoleManager.GetRolePermissions(int.Parse(roleId));
// 创建ViewModel
var permissionViews = new List<PermissionViewModel>();
foreach (var item in permissions)
{
var view = new PermissionViewModel
{
RoleId = int.Parse(roleId),
Controller = item.Controller,
Action = item.Action,
Description = item.Description
};
permissionViews.Add(view);
}
// 排序
//permissionViews.Sort(new PermissionViewModelComparer());
var v = from p in permissionViews
orderby p.Id
select p;
return View(v.ToPagedList(page, 10));
}
public PermissionProperties(User user, PermissionViewModel viewModel)
{
InitializeComponent();
this.User = user;
_model = viewModel;
_permType = User.GetPermissionType(viewModel.Permission);
if (_permType == PERMISSION_TYPE.ALLOWDISALLOW) {
gridAllowDisallow.Visibility = Visibility.Visible;
gridRWIUD.Visibility = Visibility.Collapsed;
bool isAllowed = ((int) _model.Permission & (int) PERMISSION_MASK.ALLOW) != 0;
if (isAllowed) {
optAllowed.IsChecked = true;
} else {
optNotAllowed.IsChecked = true;
}
} else {
gridAllowDisallow.Visibility = Visibility.Collapsed;
gridRWIUD.Visibility = Visibility.Visible;
optNoPermissions.IsChecked = true;
if ((_model.Mask & (int) PERMISSION_MASK.READ) != 0) {
if ((_model.Mask & (int)PERMISSION_MASK.WRITE) != 0) {
optModify.IsChecked = true;
chkDelete.IsChecked = (_model.Mask & (int)PERMISSION_MASK.DELETE) != 0;
chkInsert.IsChecked = (_model.Mask & (int)PERMISSION_MASK.INSERT) != 0;
chkUpdate.IsChecked = (_model.Mask & (int)PERMISSION_MASK.UPDATE) != 0;
} else {
optReadOnly.IsChecked = true;
}
}
}
grp.Header = String.Format("{0}/{1}", PermissionGroups.GetDescriptionForPermission(_model.Permission), _model.Permission);
}
// GET: Permissions/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var permission = await _context.Permission.FindAsync(id);
if (permission == null)
{
return(NotFound());
}
PermissionViewModel pvm = new PermissionViewModel();
BindObject.CopyModel(pvm, permission);
Form form = Form();
form.Model(pvm, "ID");
ViewData["formHtml"] = form.GetContent();
ViewData["script"] = form.GetScript();
return(View(permission));
}
public virtual ActionResult Properties(string tabId, int parentId, int id, FormCollection collection)
{
var permission = Service.ReadForUpdate(id);
var model = PermissionViewModel.Create(permission, tabId, parentId, Service);
TryUpdateModel(model);
model.Validate(ModelState);
if (ModelState.IsValid)
{
try
{
model.Data = Service.Update(model.Data);
return(Redirect("Properties", new { tabId, parentId, id = model.Data.Id, successfulActionCode = ActionCode.UpdateSitePermission }));
}
catch (ActionNotAllowedException nae)
{
ModelState.AddModelError("OperationIsNotAllowedForAggregated", nae.Message);
return(JsonHtml("EntityPermissionProperties", model));
}
}
return(JsonHtml("EntityPermissionProperties", model));
}
public async Task<ActionResult> Index(int page = 1)
{
var permissions = await db.Permissions.ToListAsync();
// 创建ViewModel
var permissionViews = new List<PermissionViewModel>();
foreach (var item in permissions)
{
var view = new PermissionViewModel
{
Id = item.Id,
Controller = item.Controller,
Action = item.Action,
Description = item.Description
};
permissionViews.Add(view);
}
// 排序
permissionViews.Sort(new PermissionViewModelComparer());
var v = from p in permissionViews
orderby p.Id
select p;
return View(v.ToPagedList(page, 10));
}
public async Task <IActionResult> Update(PermissionViewModel model)
{
var role = await _roleManager.FindByIdAsync(model.RoleId);
//Remove all Claims First
var claims = await _roleManager.GetClaimsAsync(role);
foreach (var claim in claims)
{
await _roleManager.RemoveClaimAsync(role, claim);
}
var selectedClaims = model.RoleClaims.Where(a => a.Selected).ToList();
foreach (var claim in selectedClaims)
{
await _roleManager.AddPermissionClaim(role, claim.Value);
}
_notify.Success($"Updated Claims / Permissions for Role '{role.Name}'");
//var user = await _userManager.GetUserAsync(User);
//await _signInManager.RefreshSignInAsync(user);
return(RedirectToAction("Index", new { roleId = model.RoleId }));
}
public async Task <ActionResult> Edit(int id)
{
if (id <= 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var applicationpermissions =
await this.ActionPermissionManager.GetByIdAsync(id);
if (applicationpermissions == null)
{
return(HttpNotFound());
}
var actionRoles = this.ActionPermissionManager.GetControllerActionRoles(id).ToList();
// Get a list, not a DbSet or queryable:
var allRoles = this.RoleManager.Roles.ToList();
var model = new PermissionViewModel()
{
Id = applicationpermissions.Id,
ControllerName = applicationpermissions.ControllerName,
ActionName = applicationpermissions.ActionName
};
// load the roles/Roles for selection in the form:
foreach (var role in allRoles)
{
var listItem = new SelectListItem()
{
Text = role.Name,
Value = role.Id,
Selected = actionRoles.Any(g => g.Id == role.Id)
};
model.RolesList.Add(listItem);
}
return(View(model));
}
/// <summary>
/// Add an entity.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public PermissionViewModel Add(PermissionViewModel model)
{
this.ThrowExceptionIfExist(model);
var entity = model.ToEntity();
entity = this._PermissionsRepository.Add(entity);
var entityAr = new Permission
{
Id = entity.Id,
Description = model.DescriptionAr,
Name = model.NameAr,
Language = Language.Arabic
};
entity.ChildTranslatedPermissions.Add(entityAr);
this._PermissionsRepository.Add(entityAr);
var entityEn = new Permission
{
Id = entity.Id,
Description = model.DescriptionEn,
Name = model.NameEn,
Language = Language.English
};
entity.ChildTranslatedPermissions.Add(entityEn);
this._PermissionsRepository.Add(entityEn);
#region Commit Changes
this._unitOfWork.Commit();
#endregion
model = entity.ToModel();
return(model);
}
// GET: Permission
public async Task <ActionResult> Index()
{
try
{
var results = new PermissionModel();
//Call API Provider
var uid = User.Identity.GetUserId();
controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
var token = _userSession.BearerToken;
var list = await APIProvider.Authorize_Get <List <PermissionViewModel> >(token, controllerName, "GetAll", null, APIConstant.API_Resource_Authorize);
if (list == null)
{
list = new List <PermissionViewModel>();
}
var permission = new PermissionViewModel();
results.lstPermissionViewModel = list;
results.PermissionViewModel = permission;
TempData["Data"] = list;
return(View(results));
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
public async Task <Result <string> > CreateOrUpdateRole(PermissionViewModel role)
{
if (role != null && role.Name != "SuperAdmin" && role.Name != "Basic")
{
if (string.IsNullOrEmpty(role.Id))
{
await _roleManager.CreateAsync(new IdentityRole(role.Name));
}
else
{
var existingRole = await _roleManager.FindByIdAsync(role.Id);
existingRole.Name = role.Name;
existingRole.NormalizedName = role.Name.ToUpper();
await _roleManager.UpdateAsync(existingRole);
var claims = await _roleManager.GetClaimsAsync(existingRole);
foreach (var claim in claims)
{
await _roleManager.RemoveClaimAsync(existingRole, claim);
}
var selectedClaims = role.RoleClaims.Where(a => a.Selected).ToList();
foreach (var claim in selectedClaims)
{
await _roleManager.AddPermissionClaim(existingRole, claim.Value);
}
}
return(Result <string> .Success("Done!!!"));
}
else
{
throw new ApiException("Unexpected Error!");
}
}
public virtual async Task <ActionResult> New(string tabId, int parentId, IFormCollection collection)
{
var permission = Service.New(parentId);
var model = PermissionViewModel.Create(permission, tabId, parentId, Service);
await TryUpdateModelAsync(model);
if (ModelState.IsValid)
{
try
{
model.Data = Service.Save(model.Data);
PersistResultId(model.Data.Id);
return(Redirect("Properties", new { tabId, parentId, id = model.Data.Id, successfulActionCode = ActionCode.SaveSitePermission }));
}
catch (ActionNotAllowedException nae)
{
ModelState.AddModelError("OperationIsNotAllowedForAggregated", nae.Message);
return(await JsonHtml("EntityPermissionProperties", model));
}
}
return(await JsonHtml("EntityPermissionProperties", model));
}
public virtual ActionResult Change(string tabId, int parentId, int?userId, int?groupId, FormCollection collection)
{
var permission = ChangeService.ReadOrDefaultForChange(parentId, userId, groupId);
var model = PermissionViewModel.Create(permission, tabId, parentId, Service, ChangeService.ViewModelSettings);
TryUpdateModel(model);
model.Validate(ModelState);
if (ModelState.IsValid)
{
model.Data = ChangeService.Change(model.Data);
return(Redirect("Change", new
{
tabId,
parentId,
userId = model.Data.UserId,
groupId = model.Data.GroupId,
isPostBack = true,
successfulActionCode = ActionCode.ChangeEntityTypePermission
}));
}
model.IsPostBack = true;
return(JsonHtml("ActionPermissionChange", model));
}
public void Update(PermissionViewModel permissionViewModel)
{
var propertyChanged = false;
var permission = _permissionRespository.GetById(permissionViewModel.Id);
if (permission.EmployeeName != permissionViewModel.EmployeeName)
{
permission.ChangeEmployeeName(permissionViewModel.EmployeeName);
propertyChanged = true;
}
if (permission.LastNameEmployee != permissionViewModel.LastNameEmployee)
{
permission.ChangeLastNameEmployee(permissionViewModel.LastNameEmployee);
propertyChanged = true;
}
if (permission.PermissionTypeId != permissionViewModel.PermissionTypeId)
{
permission.ChangePermissionTypeId(permissionViewModel.PermissionTypeId);
propertyChanged = true;
}
if (permission.PermitDate != permissionViewModel.PermitDate)
{
permission.ChangePermitDate(permissionViewModel.PermitDate);
propertyChanged = true;
}
if (propertyChanged)
{
_permissionRespository.Update(permission);
_permissionRespository.SaveChanges();
}
}
public IActionResult CreatePermissionForm(PermissionViewModel model)
{
if (ModelState.IsValid)
{
user CurrentUser = _context.users.Include(u => u.permissions).SingleOrDefault(u => u.userid == ( int )HttpContext.Session.GetInt32("userid"));
permission NewPerm = new permission
{
landAmt = model.landAmt,
allergies = model.allergies,
accessInfo = model.accessInfo,
accessTime = model.accessTime,
userid = CurrentUser.userid
};
_context.permissions.Add(NewPerm);
_context.SaveChanges();
NewPerm = _context.permissions.SingleOrDefault(p => p.permissionid == NewPerm.permissionid);
HttpContext.Session.SetInt32("permissionid", NewPerm.permissionid);
return(RedirectToAction("PermissionDash")); //FOR TESTING DB, Should RedirectToAction to a DASH
}
return(View("AddPermPage"));
}
public virtual IActionResult RolesIdPermissionsPost([FromRoute] int id, [FromBody] PermissionViewModel item)
{
return(_service.RolesIdPermissionsPostAsync(id, item));
}
public ActionResult CreateEditRoles(PermissionViewModel model)
{
var activeModules = GlobalContext.GetActiveModules();
ViewBag.Modules = activeModules;
var permission = new NccPermission();
permission.Description = model.Description;
permission.Rank = model.Rank;
permission.Group = model.Group;
permission.Name = model.Name;
permission.Id = model.Id;
var removePermissionDetailsIdList = new List <long>();
var addedPermissionDetails = new List <NccPermissionDetails>();
foreach (var item in model.Modules)
{
foreach (var am in item.AdminMenus)
{
foreach (var mi in am.MenuItems)
{
if (mi.IsChecked)
{
var permissionDetails = new NccPermissionDetails()
{
Id = mi.Id,
ModuleName = item.ModuleName,
Name = am.Name,
Action = mi.Action,
Controller = mi.Controller,
PermissionId = permission.Id
};
permission.PermissionDetails.Add(permissionDetails);
if (permission.Id > 0 && permissionDetails.Id == 0)
{
addedPermissionDetails.Add(permissionDetails);
}
}
else
{
if (mi.Id > 0)
{
removePermissionDetailsIdList.Add(mi.Id);
}
}
}
}
foreach (var sm in item.SiteMenus)
{
foreach (var mi in sm.MenuItems)
{
if (mi.IsChecked)
{
var permissionDetails = new NccPermissionDetails()
{
Id = mi.Id,
ModuleName = item.ModuleName,
Name = sm.Name,
Action = mi.Action,
Controller = mi.Controller,
PermissionId = permission.Id
};
permission.PermissionDetails.Add(permissionDetails);
if (permission.Id > 0 && permissionDetails.Id == 0)
{
addedPermissionDetails.Add(permissionDetails);
}
}
else
{
if (mi.Id > 0)
{
removePermissionDetailsIdList.Add(mi.Id);
}
}
}
}
}
var(res, message) = _nccPermissionService.SaveOrUpdate(permission, addedPermissionDetails, removePermissionDetailsIdList);
if (res)
{
TempData["SuccessMessage"] = message;
return(RedirectToAction("CreateEditRoles"));
}
else
{
ViewBag.ErrorMessage = message;
}
return(View(model));
}
private PermissionViewModel GetPermissionViewModel(NccPermission permission)
{
var pvm = new PermissionViewModel(permission);
return(pvm);
}
public async Task <IActionResult> Put(PermissionViewModel model)
{
await _permissionServices.UpdatePermissionAsync(model);
return(Ok());
}
public void Update(PermissionViewModel permission)
{
var permissionModel = _mapper.Map <PermissionViewModel, Permission>(permission);
_repositoryPermission.Update(permissionModel);
}
public virtual IActionResult PermissionsIdPut([FromRoute] int id, [FromBody] PermissionViewModel item)
{
return(this._service.PermissionsIdPutAsync(id, item));
}
public IActionResult CreatePermission(string permissionCode, string permissionLabel)
{
if (HttpContext == null ||
HttpContext.Session == null ||
HttpContext.Session.GetObject <UserViewModel>(MiscConstants.USER_SESSION_VM_KEY) == null)
{
return(RedirectToAction("Warning", "Home"));
}
string logSnippet = new StringBuilder("[")
.Append(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss"))
.Append("][PermissionController][CreatePermission][HttpPost] => ")
.ToString();
User qmsUser = HttpContext.Session.GetObject <User>(MiscConstants.USER_SESSION_KEY);
UserViewModel qmsUserVM = HttpContext.Session.GetObject <UserViewModel>(MiscConstants.USER_SESSION_VM_KEY);
Console.WriteLine(logSnippet + $"(permissionCode)...: '{permissionCode}'");
Console.WriteLine(logSnippet + $"(permissionLabel)..: '{permissionLabel}'");
Console.WriteLine(logSnippet + $"(qmsUser == null)..: {qmsUser == null}");
Console.WriteLine(logSnippet + $"(qmsUserVM == null): {qmsUserVM == null}");
if (qmsUserVM.CanCreatePermission == false)
{
return(RedirectToAction("UnauthorizedAccess", "Home"));
}
PermissionViewModel permissionVM = new PermissionViewModel
{
ShowAlert = true,
UserAdminModule = UserAdminConstants.UserAdminModuleConstants.ACTIVE_PERMISSION,
PermissionNavItemNavLink = UserAdminConstants.UserAdminCssConstants.ACTIVE_NAVITEM_NAVLINK_VALUE,
PermissionTabPadFade = UserAdminConstants.UserAdminCssConstants.ACTIVE_TABPANE_FADE_VALUE,
ActivePermissionNavItemNavLink = UserAdminConstants.UserAdminCssConstants.ACTIVE_NAVITEM_NAVLINK_VALUE,
ActivePermissionTabPadFade = UserAdminConstants.UserAdminCssConstants.ACTIVE_TABPANE_FADE_VALUE,
};
(bool isValid, string[] errorMessages) = _permissionValidator.CreatePermissionValuesAreValid(permissionCode, permissionLabel);
if (isValid == false)
{
StringBuilder sb = new StringBuilder("<ul>");
foreach (string errMsg in errorMessages)
{
sb.Append("<li>").Append(errMsg).Append("</li>");
}
sb.Append("</ul>");
permissionVM.AlertType = UserAdminConstants.AlertTypeConstants.FAILURE;
permissionVM.AlertMessage = sb.ToString();
HttpContext.Session.SetObject(UserAdminConstants.PERMISSION_VIEW_MODEL, permissionVM);
return(RedirectToAction("Index", "Permission"));
}
try
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// CALL PERMISSION SERVICE TO SAVE NEWLY CREATED PERMISSION TO DATABASE
/////////////////////////////////////////////////////////////////////////////////////////////////
int permissionId = _permissionService.CreatePermission(permissionCode, permissionLabel, qmsUser);
/////////////////////////////////////////////////////////////////////////////////////////////////
permissionVM.AlertType = UserAdminConstants.AlertTypeConstants.SUCCESS;
permissionVM.AlertMessage = $"Permission successfully created: ['{permissionId}', '{permissionCode}', '{permissionLabel}']";
}
catch (Exception exc)
{
Console.WriteLine(logSnippet + exc.Message);
permissionVM.AlertType = UserAdminConstants.AlertTypeConstants.FAILURE;
permissionVM.AlertMessage = $"Create new permission failed.";
}
HttpContext.Session.SetObject(UserAdminConstants.PERMISSION_VIEW_MODEL, permissionVM);
return(RedirectToAction("Index", "Permission"));
}
public static ScreenPermissionListTreeResult ToEntity2(this PermissionViewModel model)
{
var entity = AutoMapper.Mapper.Map <ScreenPermissionListTreeResult>(model);
return(entity);
}
public IActionResult Register([FromBody] PermissionViewModel permissionViewModel)
{
_permissionAppService.Register(permissionViewModel);
return(Ok("Permission registered"));
}
public IActionResult Update([FromBody] PermissionViewModel permissionViewModel)
{
_permissionAppService.Update(permissionViewModel);
return(Ok("Permission updated"));
}
public async Task<ActionResult> Create(int page = 1)
{
// 创建ViewModel
var permissionViews = new List<PermissionViewModel>();
// 取程序集中权限
var allPermissions = permissionsOfAssembly;
// 取数据库已有权限
var dbPermissions = await db.Permissions.ToListAsync();
// 取两者差集
var permissions = allPermissions.Except(dbPermissions, new ApplicationPermissionEqualityComparer());
foreach (var item in permissions)
{
var view = new PermissionViewModel
{
Controller = item.Controller,
Action = item.Action,
Description = item.Description
};
permissionViews.Add(view);
}
// 排序
permissionViews.Sort(new PermissionViewModelComparer());
return View(permissionViews.ToPagedList(page, 10));
}
public ActionResult Permission(PermissionViewModel permissionviewmodel)
{
permissionviewmodel.Rolelist = new SelectList(_permissioncomponent.GetAllRoles(), "RoleId", "Role");
return(View(permissionviewmodel));
}
public void Add(PermissionViewModel permission)
{
var permssionModel = _mapper.Map <PermissionViewModel, Permission>(permission);
_repositoryPermission.Add(permssionModel);
}
// GET: Rols
public ActionResult Index()
{
ViewBag.AltaModificacion = PermissionViewModel.TienePermisoAlta(WindowHelper.GetWindowId(ModuleDescription, WindowDescription));
ViewBag.Baja = PermissionViewModel.TienePermisoBaja(WindowHelper.GetWindowId(ModuleDescription, WindowDescription));
return(View(db.Rols.ToList()));
}
/// <summary>
/// Setup the test.
/// </summary>
public PermissionViewModelModelTests()
{
instance = new PermissionViewModel();
}
public void Add(PermissionViewModel permission)
{
_permissionRepository.Add(_mapper.Map <Permission>(permission));
}
public async Task<ActionResult> Create(string roleId, int page = 1)
{
if (string.IsNullOrWhiteSpace(roleId))
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
var roles = await RoleManager.Roles.ToListAsync();
ViewBag.RoleID = new SelectList(roles, "Id", "Name", roleId);
// 取角色权限ID
var rolePermissions = RoleManager.GetRolePermissions(int.Parse(roleId));
// 取全部权限与角色权限的差集
var allPermission = await db.Permissions.ToListAsync();
var permissions = allPermission.Except(rolePermissions, new ApplicationPermissionEqualityComparer());
// 创建ViewModel
var permissionViews = new List<PermissionViewModel>();
foreach (var item in permissions)
{
var permisionView = new PermissionViewModel
{
Id = item.Id,
Controller = item.Controller,
Action = item.Action,
Description = item.Description
};
permissionViews.Add(permisionView);
}
// 排序
permissionViews.Sort(new PermissionViewModelComparer());
var v = from p in permissionViews
orderby p.Id
select p;
return View(v.ToPagedList(page, 10));
}
// GET: Orders
public ActionResult Index()
{
ViewBag.Editar = PermissionViewModel.TienePermisoAcesso(WindowHelper.GetWindowId(ModuleDescription, WindowDescription));
ViewBag.Ver = PermissionViewModel.TienePermisoAlta(WindowHelper.GetWindowId(ModuleDescription, WindowDescription));
ViewBag.Baja = PermissionViewModel.TienePermisoBaja(WindowHelper.GetWindowId(ModuleDescription, WindowDescription));
ViewBag.Imprimir = PermissionViewModel.TienePermisoAcesso(WindowHelper.GetWindowId(ModuleDescription, WindowDescription));
List <OrderIndexViewModel> list = new List <OrderIndexViewModel>();
Usuario usuario = db.Usuarios.Find(SessionHelper.GetUser());
List <Order> orders = new List <Order>();
List <Center> lCentros = new List <Center>();
List <Status> lEstados = new List <Status>();
if (usuario.Rol.IsAdmin)
{
lCentros = db.Centers.Where(x => x.Enable).ToList();
}
else
{
lCentros = db.Centers.Where(x => x.Id == usuario.CenterId).ToList();
}
lEstados = db.Status.ToList();
ViewBag.listaCentros = lCentros;
ViewBag.listaEstados = lEstados;
ViewBag.isAdmin = usuario.Rol.IsAdmin;
if (!usuario.Rol.IsAdmin)
{
orders = db.Orders.Where(x => x.CenterId == usuario.CenterId).Include(o => o.Center).OrderByDescending(x => x.Id).ToList();
}
else
{
orders = db.Orders.Include(o => o.Center).Include(o => o.Usuario).OrderByDescending(x => x.Id).ToList();
}
foreach (var item in orders)
{
OrderIndexViewModel orderIndexViewModel = new OrderIndexViewModel
{
Id = item.Id,
Center = item.Center?.Descripcion,
Fecha = item.InitialDate.ToString("dd/MM/yyyy"),
Usuario = item.Usuario?.Nombreusuario,
Estado = item.Status.Descripcion,
NroPedido = item.NroPedido.ToString("000000")
};
switch (item.StatusId)
{
case (int)StatusOrder.Solicitado:
orderIndexViewModel.Ver = true;
orderIndexViewModel.Modificar = true;
orderIndexViewModel.Eliminar = true;
break;
case (int)StatusOrder.Aceptado:
orderIndexViewModel.Ver = true;
if (usuario.Rol.IsAdmin)
{
orderIndexViewModel.Modificar = true;
orderIndexViewModel.Eliminar = true;
}
break;
case (int)StatusOrder.Rechazado:
orderIndexViewModel.Ver = true;
if (usuario.Rol.IsAdmin)
{
orderIndexViewModel.Eliminar = true;
}
break;
case (int)StatusOrder.Entregado:
orderIndexViewModel.Ver = true;
if (usuario.Rol.IsAdmin)
{
orderIndexViewModel.Eliminar = true;
}
break;
}
list.Add(orderIndexViewModel);
}
return(View(list));
}
public async Task <IActionResult> Post(PermissionViewModel model)
{
await _permissionServices.AddNewAsync(model);
return(Ok());
}
public virtual IActionResult PermissionsPost([FromBody] PermissionViewModel item)
{
return(this._service.PermissionsPostAsync(item));
}
public ActionResult Dashboard()
{
string actionName = "Dashboard";
string inRoleId = ((SessionHelper)Session[SessionKeys.SessionHelperInstance])?.CurrentRoleId;
try
{
string siteId = Session[SessionKeys.UserUnitId]?.ToString();
_logger.Log(LogLevel.Trace, actionName + " :: started.");
if (!string.IsNullOrWhiteSpace(siteId))
{
if (Regex.IsMatch(siteId, RegexHelper.NumberOnly))
{
var applicableUnits = ((List <ClassLibrary.Models.tbl_Unit>)Session[SessionKeys.ApplicableUnits]);
int intSiteId = Convert.ToInt32(siteId);
if (applicableUnits != null && applicableUnits.Where(x => x.Id == intSiteId).Any())
{
DashboardViewModel dashboard = new DashboardViewModel();
List <PermissionViewModel> ListPermissionViewModel = new List <PermissionViewModel>();
dashboard._tbl_Unit = ((List <ClassLibrary.Models.tbl_Unit>)Session[SessionKeys.AllUnits]);
string defaultRoleId = !String.IsNullOrWhiteSpace(inRoleId) ? inRoleId : string.Empty;
dashboard.datetime = DateTime.Now.ToString();
string loginUserId = Session[SessionKeys.UserId]?.ToString();
using (Entities _context = new Entities())
{
if (string.IsNullOrWhiteSpace(defaultRoleId))
{
defaultRoleId = _context.tbl_UserRole.Where(x => x.UserId == loginUserId && x.IsDefault == 1 && x.IsActive != 0 && x.IsDeleted != 1)?.FirstOrDefault().RoleId;
}
else
{
defaultRoleId = _context.tbl_UserRole.Where(x => x.UserId == loginUserId && x.RoleId == inRoleId && x.IsActive != 0 && x.IsDeleted != 1)?.FirstOrDefault().RoleId;
}
if (!String.IsNullOrWhiteSpace(defaultRoleId))
{
SessionKeys.LoadTablesInSession(SessionKeys.RolePermissions, "", defaultRoleId);
var permissions = ((List <tbl_Permission>)Session[SessionKeys.RolePermissions]);
foreach (var item in permissions)
{
PermissionViewModel permissionViewModel = new PermissionViewModel()
{
PermissionId = item.PermissionId,
DisplayName = item.DisplayName,
Level = item.PermissionLevel?.ToString(),
ParentId = item.ParentId,
URL = item.URL,
IconPath = item.IconPath
};
ListPermissionViewModel.Add(permissionViewModel);
}
Session[SessionKeys.SessionHelperInstance] = new SessionHelper(loginUserId, defaultRoleId, ListPermissionViewModel);
dashboard.DashboardId = GetDashboardId(loginUserId);
return(View(dashboard));
}
else
{
_logger.Log(LogLevel.Error, actionName + " :: Role id not found.");
}
}
}
else
{
_logger.Log(LogLevel.Error, actionName + " :: Please select valid site id.");
}
}
else
{
_logger.Log(LogLevel.Error, actionName + " :: Invalid input in site id.");
}
}
else
{
_logger.Log(LogLevel.Error, actionName + " :: Site id empty.");
}
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, actionName + " EXCEPTION :: " + ex.ToString() + " INNER EXCEPTION :: " + ex.InnerException?.ToString());
}
return(RedirectToAction("UnitSelection"));
}
