public async Task <IActionResult> DeleteAccess(int accessId)
{
UserAccessViewModel model = new UserAccessViewModel();
UserAccess uaModel = await _progenyHttpClient.GetUserAccess(accessId);
model.ProgenyId = uaModel.ProgenyId;
model.UserId = uaModel.UserId;
model.AccessId = uaModel.AccessId;
model.AccessLevel = uaModel.AccessLevel;
model.Email = uaModel.UserId;
model.UserName = "******";
model.FirstName = "No user found";
model.MiddleName = "No user found";
model.LastName = "No user found";
UserInfo appUser = await _progenyHttpClient.GetUserInfo(uaModel.UserId);
if (appUser != null)
{
model.Email = appUser.UserEmail;
model.UserName = appUser.UserName;
model.FirstName = appUser.FirstName;
model.MiddleName = appUser.MiddleName;
model.LastName = appUser.LastName;
}
model.Progeny = await _progenyHttpClient.GetProgeny(uaModel.ProgenyId);
model.ProgenyName = model.Progeny.Name;
return(View(model));
}
public ActionResult Login(UserAccessViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
AccessRequest oAR = new AccessRequest();
oAR.Email = model.Email;
oAR.Password = UtilitiesChat.Tools.Encrypt.GetSHA256(model.Password);
RequestUtil oRequestUtil = new RequestUtil();
UtilitiesChat.Models.WS.Reply oReply =
oRequestUtil.Execute <AccessRequest>(Constants.Url.ACCESS, "Post", oAR);
UtilitiesChat.Models.WS.UserResponse oUserResponse =
JsonConvert.DeserializeObject <UtilitiesChat.Models.WS.UserResponse>(JsonConvert.SerializeObject(oReply.data));
if (oReply.result == 1)
{
Session["User"] = oUserResponse;
return(RedirectToAction("Index", "Lobby"));
}
ViewBag.error = "Datos incorrectos";
return(View());
}
public ActionResult Edit(int id, UserAccessViewModel objEntity)
{
var objUserAccessRepository = new UserAccessRepository();
if (ModelState.IsValid)
{
// objEntity.Name = objEntity.Name.Trim();
objEntity.UserAccessId = (Int16)id;
objEntity = objUserAccessRepository.Update(RoleFlags.UpdateByID.GetHashCode(), objEntity);
if (objEntity.Result == ResultFlags.Success.GetHashCode())
{
this.Flash("success", "UserAccess Details updated successfully");
//reload all new setting
MenuHelpers.SetMenuByRoleMaster();
MenuHelpers.SetMenuByRoleMain();
return(RedirectToAction("Index"));
}
else if (objEntity.Result == ResultFlags.Failure.GetHashCode())
{
this.Flash("error", "UserAccess Details failed to Update");
}
}
return(View(objEntity));
}
public IActionResult UserAccess(int userId)
{
var authData = HttpContext.Session.GetString("userInfo");
if (authData != "")
{
User userInfo = JsonConvert.DeserializeObject <User>(authData);
if (userAccess.HasAccess(userInfo.Id, -10, userInfo.DesignationId))
{
if (userManager.IsUserExists(userId))
{
UserAccessViewModel userAccessViewModel = userAccess.GetUserAccess(userId);
ViewBag.UserId = userId;
return(View(userAccessViewModel));
}
else
{
return(NotFound("404 Not Found"));
}
}
else
{
return(RedirectToAction("AccessDenied", "Home"));
}
}
else
{
HttpContext.Session.SetString("userInfo", "");
return(RedirectToAction("Login", "LogIn"));
}
}
public ActionResult Create(UserAccessViewModel objEntity)
{
UserAccessRepository objUserAccessRepository = new UserAccessRepository();
if (ModelState.IsValid)
{
objEntity.UserAccessTitle = objEntity.UserAccessTitle.Trim();
objEntity.Url = objEntity.Url.Trim();
objEntity.CssClass = objEntity.CssClass.Trim();
objEntity.CreatedBy = 1;//admin
objEntity = objUserAccessRepository.Insert(objEntity);
if (objEntity.Result == ResultFlags.Success.GetHashCode())
{
// Install-Package MvcFlashMessages
this.Flash("Success", "User Access Insert successfully");
return(RedirectToAction("Index"));
}
else if (objEntity.Result == ResultFlags.Failure.GetHashCode())
{
this.Flash("Error", "Failed to Insert UserAccess");
return(RedirectToAction("Index"));
}
else if (objEntity.Result == ResultFlags.Duplicate.GetHashCode())
{
this.Flash("Warning", "UserAccess Name is Already Exist");
return(RedirectToAction("Index"));
}
}
return(View(objEntity));
}
public UserAccessView(string listID)
{
InitializeComponent();
BindingContext = new UserAccessViewModel(Navigation, listID);
Title = "Users' accesses";
BackgroundColor = Color.FromHex("#fffffc");
}
private UserAccessViewModel buildGroup(UserAccessViewModel user)
{
try
{
var group = new Group();
user.group = new Group();
using (DB_FleetServiceEntities db = new DB_FleetServiceEntities())
{
// group data
group = db.Groups.Where(grp => grp.grp_id == user.id_group)
.Select(grp => new Group
{
id_group = grp.grp_id,
groupName = grp.grp_name
}).FirstOrDefault();
user.group = group;
}
}
catch (Exception ex)
{
return(new UserAccessViewModel());
}
return(user);
}
public ActionResult Login(UserAccessViewModel model)
{
if (!ModelState.IsValid)
{
//REGRESO as LA VISTA
return(View(model));
}
Reply oReply = new Reply();
AccessRequest oAR = new AccessRequest();
oAR.Email = model.Email;
oAR.Password = UtilitiesChat.Tools.Encrypt.GetSHA256(model.Password);
RequestUtil oRequestUtil = new RequestUtil();
oReply = oRequestUtil.Execute <AccessRequest>(Constants.Url.ACESS, "post", oAR);
JavaScriptSerializer js = new JavaScriptSerializer();
UtilitiesChat.Models.WS.UserResponse oUserResponse = js.Deserialize <UtilitiesChat.Models.WS.UserResponse>(js.Serialize(oReply.data));
if (oReply.result == 1)
{
Session["User"] = oUserResponse;
return(RedirectToAction("Index", "Lobby"));
}
//mandar error
ViewBag.error = "Datos Incorrectos";
return(View(model));
}
public async Task <IActionResult> Access(string UserId)
{
var user = await _userManager.FindByIdAsync(UserId);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{UserId}'.");
}
UserAccessViewModel userAccess = new UserAccessViewModel();
userAccess.AccessVM = new List <AccessViewModel>();
var Roles = await _context.Roles.ToListAsync();
foreach (var item in Roles)
{
if (await _userManager.IsInRoleAsync(user, item.Name) == true)
{
userAccess.AccessVM.Add(new AccessViewModel {
Id = item.Id, Name = item.Name, Selected = true
});
}
else
{
var a2 = new AccessViewModel {
Id = item.Id, Name = item.Name, Selected = false
};
userAccess.AccessVM.Add(a2);
}
}
return(View(userAccess));
}
// get given user access
public UserAccessViewModel GetUserAccess(int userId)
{
List <UserAccess> result = unitOfWork.UserAccess.Get(x => x.UserId == userId && x.State == 1).ToList();
UserAccessViewModel userAccessViewModel = new UserAccessViewModel();
if (result.Count > 0)
{
userAccessViewModel.UserId = result[0].UserId;
List <int> listOfPageId = new List <int>();
foreach (var data in result)
{
listOfPageId.Add(data.PageId);
}
userAccessViewModel.PageId = listOfPageId;
return(userAccessViewModel);
}
else
{
userAccessViewModel.Id = userId;
return(userAccessViewModel);
}
}
public List <UserAccessViewModel> Select(int Flag, Int16 RoleId, UserAccessViewModel objEntity)
{
var objEntityList = new List <UserAccessViewModel>();
try
{
Database objDB = base.GetDatabase();
// Create a suitable command type and add the required parameter.
using (DbCommand sprocCmd = objDB.GetStoredProcCommand(SPS_USERACCESSVIEWMODELMENUSELECT))
{
objDB.AddInParameter(sprocCmd, COLUMN_NAME_FLAG, DbType.Int32, Flag);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_ROLE_ID, DbType.Int32, RoleId);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_URL, DbType.String, objEntity.Url);
using (IDataReader reader = objDB.ExecuteReader(sprocCmd))
{
while (reader.Read())
{
var objEntityViewModel = new UserAccessViewModel();
objEntityViewModel.UserAccessId = reader.GetColumnValue <Int16>(COLUMN_NAME_USERACCESS_ID);
objEntityViewModel.ParentId = (UserAccessParentIdEnum)reader.GetColumnValue <Int16>(COLUMN_NAME_PARENT_ID);
objEntityViewModel.UserAccessTitle = reader.GetColumnValue <String>(COLUMN_NAME_USERACCESS_TITLE);
objEntityViewModel.Url = reader.GetColumnValue <String>(COLUMN_NAME_URL);
objEntityViewModel.CssClass = reader.GetColumnValue <String>(COLUMN_NAME_CSSCLASS);
objEntityViewModel.UserAccessStatus = (StatusEnum)reader.GetColumnValue <Int16>(COLUMN_NAME_USERACCESS_STATUS);
objEntityViewModel.SortOrder = reader.GetColumnValue <Int16>(COLUMN_NAME_SORT_ORDER);
objEntityViewModel.AddPermission = reader.GetColumnValue <bool>(COLUMN_NAME_ADDPERMISSION);
objEntityViewModel.EditPermission = reader.GetColumnValue <Boolean>(COLUMN_NAME_EDITPERMISSION);
objEntityViewModel.ViewPermission = reader.GetColumnValue <Boolean>(COLUMN_NAME_VIEWPERMISSION);
objEntityViewModel.DeletePermission = reader.GetColumnValue <Boolean>(COLUMN_NAME_DELETEPERMISSION);
if (objEntityViewModel != null)
{
objEntityList.Add(objEntityViewModel);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
return(objEntityList);
}
public async Task <IActionResult> AddAccess(UserAccessViewModel model)
{
string userEmail = User?.GetEmail() ?? _defaultUser;
var userinfo = await _progenyHttpClient.GetUserInfo(userEmail);
if (userinfo != null && userinfo.ViewChild > 0)
{
_progId = userinfo.ViewChild;
}
UserAccess accessModel = new UserAccess();
accessModel.ProgenyId = model.ProgenyId;
accessModel.UserId = model.Email.ToUpper();
accessModel.AccessLevel = model.AccessLevel;
var progenyAccessList = await _progenyHttpClient.GetUserAccessList(model.Email.ToUpper());
var oldUserAccess = progenyAccessList.SingleOrDefault(u => u.ProgenyId == model.ProgenyId);
if (oldUserAccess == null)
{
await _progenyHttpClient.AddUserAccess(accessModel);
}
else
{
await _progenyHttpClient.DeleteUserAccess(oldUserAccess.AccessId);
await _progenyHttpClient.AddUserAccess(accessModel);
}
// Todo: Notify user of update
return(RedirectToAction("Index"));
}
public IHttpActionResult GetById(int pId)
{
try
{
var oUserDB = new UserAccessViewModel();
var access = new List <GroupModuleAction>();
using (DB_FleetServiceEntities db = new DB_FleetServiceEntities())
{
oUserDB = db.Users.Where(us => us.usr_id == pId)
.Select(usr => new UserAccessViewModel
{
id_user = usr.usr_id,
user = usr.usr_name,
id_group = usr.grp_id
}).FirstOrDefault();
access = db.GroupModuleAction.Where(gma => gma.grp_id.Equals(oUserDB.id_group)).ToList();
}
oUserDB = buildGroup(oUserDB);
oUserDB = buildModulesActions(oUserDB, access);
return(Ok(oUserDB));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public UserAccessViewModel Update(int Flag, UserAccessViewModel objEntity)
{
try
{
Database objDB = base.GetDatabase();
// Create a suitable command type and add the required parameter.
using (DbCommand sprocCmd = objDB.GetStoredProcCommand(SPS_USERACCESSVIEWMODELUPDATE))
{
objDB.AddInParameter(sprocCmd, COLUMN_NAME_PARENT_ID, DbType.Int16, objEntity.ParentId);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_USERACCESS_TITLE, DbType.String, objEntity.UserAccessTitle);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_URL, DbType.String, objEntity.Url);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_CSSCLASS, DbType.String, objEntity.CssClass);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_SORT_ORDER, DbType.Int16, objEntity.SortOrder);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_USERACCESS_STATUS, DbType.Int16, objEntity.UserAccessStatus);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_USERACCESS_ID, DbType.Int16, objEntity.UserAccessId);
objDB.AddOutParameter(sprocCmd, COLUMN_NAME_RESULT, DbType.Int32, objEntity.Result);
objDB.ExecuteNonQuery(sprocCmd);
objEntity.Result = Convert.ToInt32(objDB.GetParameterValue(sprocCmd, COLUMN_NAME_RESULT));
}
//
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
return(objEntity);
}
public async Task <IActionResult> Index(int?pageNumber)
{
int pageSize = 20;
var users = await _userManager.Users.ToListAsync();
var userRoles = new List <UserAccessViewModel>();
foreach (User user in users)
{
var thisViewModel = new UserAccessViewModel
{
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
AccountCreationDate = user.AccountCreationDate.Date,
LockoutEnd = user.LockoutEnd,
Roles = await GetUserRoles(user)
};
userRoles.Add(thisViewModel);
}
//ViewBag for bell icon on the nav menu
var userLoggedIn = await _userManager.GetUserAsync(User);
ViewBag.HasNotificationToRead = _context.Notification.Include(n => n.User).Where(notif => notif.DestinaryID == userLoggedIn.Id && !notif.IsRead).Count();
return(View(await PaginatedList <UserAccessViewModel> .CreateAsync(userRoles, pageNumber ?? 1, pageSize)));
}
public ActionResult <UserAccessViewModel> Post([FromServices] TokenConfig tokenConfig,
[FromServices] UserLogin user,
[FromServices] TokenSecurityConfig tokenSecurityConfig,
UserAccessViewModel authModel)
{
if (String.IsNullOrEmpty(authModel.Email) || String.IsNullOrEmpty(authModel.Password))
{
return(BadRequest(new { error = "Authentication failed" }));
}
else
{
bool validCredentials = (user != null && authModel.Email == user.Email && authModel.Password == user.Password);
if (validCredentials)
{
ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(authModel.Email, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, authModel.Email)
});
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(tokenConfig.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfig.Issuer,
Audience = tokenConfig.Audience,
SigningCredentials = tokenSecurityConfig.Credentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
var result = new
{
AccessToken = token,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
authenticated = true
};
return(Ok(result));
}
else
{
var result = new
{
AccessToken = "",
authenticated = false
};
return(Ok(result));
}
}
}
public ActionResult UserAccess([Bind(Include = "User, UserAccessArray")] UserAccessViewModel userAccess)
{
try
{
UserAccess[] oldAccess = pp.GetUserAccess(userAccess.User.UserID);
for (int i = 0; i < userAccess.UserAccessArray.Length; i++)
{
if ((userAccess.UserAccessArray[i].Name.ToString() == oldAccess[i].Name.ToString()) && (userAccess.UserAccessArray[i].IsSet.ToString() != oldAccess[i].IsSet.ToString()))
{
if (userAccess.UserAccessArray[i].IsSet == true)
{
pp.AddAccessToUser(userAccess.User.UserID, userAccess.UserAccessArray[i].ThingID);
}
else
{
pp.RemoveAccessFromUser(userAccess.User.UserID, userAccess.UserAccessArray[i].ThingID);
}
}
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ViewBag.Error = e;
return(RedirectToAction("UserAccess"));
}
}
public List <UserAccessViewModel> Select(int Flag, UserAccessViewModel objEntity)
{
var objEntityList = new List <UserAccessViewModel>();
try
{
Database objDB = base.GetDatabase();
// Create a suitable command type and add the required parameter.
using (DbCommand sprocCmd = objDB.GetStoredProcCommand(SPS_USERACCESSVIEWMODELSELECT))
{
objDB.AddInParameter(sprocCmd, COLUMN_NAME_FLAG, DbType.Int32, Flag);
objDB.AddInParameter(sprocCmd, COLUMN_NAME_USERACCESS_ID, DbType.Int32, objEntity.UserAccessId);
using (IDataReader reader = objDB.ExecuteReader(sprocCmd))
{
while (reader.Read())
{
var objEntityViewModel = new UserAccessViewModel();
objEntityViewModel.UserAccessId = reader.GetColumnValue <Int16>(COLUMN_NAME_USERACCESS_ID);
objEntityViewModel.ParentId = (UserAccessParentIdEnum)reader.GetColumnValue <Int16>(COLUMN_NAME_PARENT_ID);
objEntityViewModel.UserAccessTitle = reader.GetColumnValue <String>(COLUMN_NAME_USERACCESS_TITLE);
objEntityViewModel.Url = reader.GetColumnValue <String>(COLUMN_NAME_URL);
objEntityViewModel.CssClass = reader.GetColumnValue <String>(COLUMN_NAME_CSSCLASS);
objEntityViewModel.UserAccessStatus = (StatusEnum)reader.GetColumnValue <Int16>(COLUMN_NAME_USERACCESS_STATUS);
objEntityViewModel.SortOrder = reader.GetColumnValue <Int16>(COLUMN_NAME_SORT_ORDER);
objEntityViewModel.CreatedDate = reader.GetColumnValue <DateTime>(COLUMN_NAME_CREATED_DATE);
objEntityViewModel.CreatedBy = reader.GetColumnValue <Int32>(COLUMN_NAME_CREATED_BY);
objEntityViewModel.ModifiedDate = reader.GetColumnValue <DateTime>(COLUMN_NAME_MODIFIED_DATE);
objEntityViewModel.ModifiedBy = reader.GetColumnValue <Int32>(COLUMN_NAME_MODIFIED_BY);
if (objEntityViewModel != null)
{
objEntityList.Add(objEntityViewModel);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
return(objEntityList);
}
public UserAccessPage()
{
InitializeComponent();
_viewModel = new UserAccessViewModel();
_viewModel.AnyChildren = true;
_reload = true;
BindingContext = _viewModel;
ProgenyCollectionView.ItemsSource = _viewModel.ProgenyCollection;
UserAccessCollectionView.ItemsSource = _viewModel.UserAccessCollection;
}
public ActionResult Select(string accessInd, string userId)
{
var viewModel = new UserAccessViewModel()
{
_userAccessPermission = (UserAccessService.GetUserAccessDetail(accessInd, userId)).userAccess
};
viewModel._userAccessPermission.SelectedAccessInd = accessInd;
return(View(viewModel));
}
public async Task <IActionResult> DeleteAccess(UserAccessViewModel model)
{
await _progenyHttpClient.GetUserAccess(model.AccessId);
await _progenyHttpClient.DeleteUserAccess(model.AccessId);
// To do: Notify user of update
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Access(string UserId, UserAccessViewModel accessVM, IFormCollection collection)
{
var user = await _userManager.FindByIdAsync(UserId);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{UserId}'.");
}
return(View());
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (UserAccessViewModel.AuthenticateUser(model.UserName, model.Password))
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return(View(model));
}
public JsonResult AddProductToUserCart(Product selectedProduct)
{
if (System.Web.HttpContext.Current.Session != null && System.Web.HttpContext.Current.Session["IsValidSession"] != null)
{
var userID = Convert.ToInt32(System.Web.HttpContext.Current.Session["UserID"]);
var IsAdded = UserAccessViewModel.AddProductToUserCart(userID, selectedProduct);
return(Json(IsAdded, JsonRequestBehavior.AllowGet));
}
else
{
return(null);
}
}
public async Task <IActionResult> EditAccess(UserAccessViewModel model)
{
UserAccess uaModel = new UserAccess();
uaModel.AccessId = model.AccessId;
uaModel.ProgenyId = model.ProgenyId;
uaModel.UserId = model.Email;
uaModel.AccessLevel = model.AccessLevel;
await _progenyHttpClient.UpdateUserAccess(uaModel);
// To do: Notify user of update
return(RedirectToAction("Index"));
}
public JsonResult GetAllProducts()
{
if (System.Web.HttpContext.Current.Session != null && System.Web.HttpContext.Current.Session["IsValidSession"] != null)
{
IList <Product> result = UserAccessViewModel.GetAllProducts();
return(Json(result, JsonRequestBehavior.AllowGet));
}
else
{
return(null);
}
}
public ActionResult Varify(string ID, string activationToken)
{
if (UserAccessViewModel.ActivateUser(ID, activationToken))
{
ViewBag.Message = "user is activated. Please go to login page for login";
}
else
{
ViewBag.Message = "Activation url is not valid";
}
return(View());
}
public async Task <IActionResult> AddAccess(string progenyId)
{
string userEmail = User?.GetEmail() ?? _defaultUser;
var userinfo = await _progenyHttpClient.GetUserInfo(userEmail);
if (userinfo == null)
{
return(RedirectToAction("Index"));
}
if (userinfo.ViewChild > 0)
{
_progId = userinfo.ViewChild;
}
UserAccessViewModel model = new UserAccessViewModel();
model.ProgenyId = int.Parse(progenyId);
if (progenyId == "0")
{
progenyId = userinfo.ViewChild.ToString();
}
model.Progeny = await _progenyHttpClient.GetProgeny(int.Parse(progenyId));
model.ProgenyName = model.Progeny.Name;
model.Email = "";
model.AccessLevel = (int)AccessLevel.Users;
model.UserId = "";
model.ProgenyList = new List <SelectListItem>();
if (User.Identity.IsAuthenticated && userEmail != null && userinfo.UserId != null)
{
var accessList = await _progenyHttpClient.GetProgenyAdminList(userEmail);
if (accessList.Any())
{
foreach (Progeny prog in accessList)
{
SelectListItem selItem = new SelectListItem()
{
Text = accessList.Single(p => p.Id == prog.Id).NickName,
Value = prog.Id.ToString()
};
if (prog.Id == _progId)
{
selItem.Selected = true;
}
model.ProgenyList.Add(selItem);
}
}
}
return(View(model));
}
private UserAccessViewModel buildModulesActions(UserAccessViewModel user, List <GroupModuleAction> groupMA)
{
try
{
//var groupModuls = new List<Module>();
user.group.modules = new List <Module>();
var groupModuleById = groupMA.GroupBy(g => g.mdl_id);
using (DB_FleetServiceEntities db = new DB_FleetServiceEntities())
{
// group data
foreach (var module in groupModuleById)
{
var moduleItem = db.Modules.Where(mdl => mdl.mdl_id == module.Key)
.Select(mdl => new Module
{
id_module = mdl.mdl_id,
moduleName = mdl.mdl_name,
id_moduleF = mdl.mdl_father,
moduleDescription = mdl.mdl_description,
path = mdl.mdl_path
}).FirstOrDefault();
moduleItem.actions = new List <ActionModule>();
foreach (var action in module)
{
var actionItem = db.Actions.Where(act => act.act_id == action.act_id)
.Select(act => new ActionModule
{
id_action = act.act_id,
actionName = act.act_name
}).FirstOrDefault();
moduleItem.actions.Add(actionItem);
}
user.group.modules.Add(moduleItem);
}
}
}
catch (Exception ex)
{
return(new UserAccessViewModel());
}
return(user);
}
/// <summary>
/// When trying to block or unblock a user, this will render the view with the detailed activity of that user, in
/// order for the moderators to take informed action,
/// </summary>
/// <param name="userId">User identification</param>
/// <param name="complaintID">Complaint identification</param>
/// <returns>Returns a Task of an IActionResult</returns>
/// <seealso cref="Task"/>
/// <seealso cref="IActionResult"/>
public async Task <IActionResult> UserActivity(string userId, int?complaintID)
{
if (userId == null)
{
return(View("/Views/Shared/NotFound.cshtml"));
}
ViewBag.ComplaintID = complaintID;
var user = await _userManager.FindByIdAsync(userId);
var thisViewModel = new UserAccessViewModel
{
Id = user.Id,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Birthdate = user.Birthdate,
Email = user.Email,
AccountCreationDate = user.AccountCreationDate,
LastSeen = user.LastSeen,
LockoutDays = user.LockoutDays,
BlockMotive = user.BlockMotive,
LockoutEnd = user.LockoutEnd,
ComplaintID = complaintID
};
ViewBag.Services = await _context.Service.Where(u => u.User == user).CountAsync();
ViewBag.ServicesRequestedTo = await _context.ServiceRequisition.Where(u => u.Service.User == user).CountAsync();
ViewBag.ServicesRequestedBy = await _context.ServiceRequisition.Where(u => u.Requisitioner == user).CountAsync();
ViewBag.ComplaintsMade = await _context.Complaint.Where(u => u.UserComplaining == user).CountAsync();
ViewBag.ComplaintsReceived = await _context.Complaint.Where(u => u.ComplaintTargetUser == user || u.ComplaintTargetService.User == user).CountAsync();
ViewBag.CommentAndEvaluationsMade = await _context.CommentAndEvaluation.Where(u => u.UserCommenting == user).CountAsync();
ViewBag.CommentAndEvaluationsReceived = await _context.CommentAndEvaluation.Where(u => u.Service.User == user).CountAsync();
//ViewBag for bell icon on the nav menu
var userLoggedIn = await _userManager.GetUserAsync(User);
ViewBag.HasNotificationToRead = _context.Notification.Include(n => n.User).Where(notif => notif.DestinaryID == userLoggedIn.Id && !notif.IsRead).Count();
return(View(thisViewModel));
}
