public PartialViewResult List(FilterUserModel filter)
{
var userList = filter.DivisionId == null ?
DalContainer.WcfDataManager.UserList :
DalContainer.WcfDataManager.UserList.Where(user => user.DivisionId == filter.DivisionId);
var userModelList = userList.Select(user => new UserModel(user)).OrderBy(user => user.IsAdmin).ThenBy(user => user.Name).ToList();
return(PartialView(userModelList));
}
public virtual ActionResult Search(FilterUserModel model)
{
GetIsActive(model.IsActive);
var result = _userBusiness.Search(model);
if (!Request.IsAjaxRequest())
{
return(View(result));
}
return(PartialView(MVC.User.Views.Partials._SearchList, result.Result));
}
public async Task <GenericModel <ApplicationUser> > GetFilteredDataAsync(FilterUserModel filter)
{
var users = _userManager.Users.Where(user => user.IsRemoved == false);
users = users.Where(user => user.Id != Constants.AdminSettings.AdminId);
if (!string.IsNullOrWhiteSpace(filter.SearchString))
{
users = _userManager.Users.Where(user => user.FirstName.Contains(filter.SearchString));
}
if (filter.IsBlocked.Equals(Enums.BlockState.True))
{
users = users.Where(x => x.LockoutEnd != null);
}
if (filter.IsBlocked.Equals(Enums.BlockState.False))
{
users = users.Where(x => x.LockoutEnd == null);
}
Expression <Func <ApplicationUser, object> > predicate = x => x.FirstName;
if (filter.SortType.Equals(Enums.SortType.Email))
{
predicate = x => x.Email;
}
var responseModel = new GenericModel <ApplicationUser>()
{
CollectionCount = await users.AsNoTracking().CountAsync()
};
if (filter.SortState.Equals(Enums.SortState.Asc))
{
users = users.OrderBy(predicate);
}
if (filter.SortState.Equals(Enums.SortState.Desc))
{
users = users.OrderByDescending(predicate);
}
var usersPage = await users.Skip((filter.Page - 1) *filter.PageSize).Take(filter.PageSize).ToArrayAsync();
responseModel.Collection = usersPage;
return(responseModel);
}
public async Task <ActionResult <IEnumerable <User> > > GetFilteredUsers(FilterUserModel filterUserModel)
{
List <User> users = await _context.Users.Include(u => u.UserType)
.Include(u => u.UserSkills).ThenInclude(u => u.Skill).ThenInclude(s => s.Category)
.Include(u => u.ContactInfo)
.Include(u => u.TagUsers).ThenInclude(u => u.Tag)
.Include(u => u.Location).ToListAsync();
if (filterUserModel.Email != null && filterUserModel.Email != "" && filterUserModel.Email != " ")
{
users = users.Where(u => u.Email.ToLower().Contains(filterUserModel.Email.ToLower())).ToList();
}
if (filterUserModel.Username != null && filterUserModel.Username != "" && filterUserModel.Username != " ")
{
users = users.Where(u => u.Username.ToLower().Contains(filterUserModel.Username.ToLower())).ToList();
}
if (filterUserModel.UserType != null && filterUserModel.UserType != "")
{
users = users.Where(u => u.UserType.Type == filterUserModel.UserType).ToList();
}
return(users);
}
public async Task <UserModel> GetAllUsersAsync(FilterUserModel filterModel)
{
var userModel = new UserModel();
var repositoryModel = _mapperHelper.Map <FilterUserModel, DataFilter.FilterUserModel>(filterModel);
if (repositoryModel == null)
{
userModel.Errors.Add(Constants.Errors.OccuredProcessing);
return(userModel);
}
var filteringUsers = await _userRepository.GetFilteredDataAsync(repositoryModel);
if (filteringUsers == null)
{
userModel.Errors.Add(Constants.Errors.OccuredProcessing);
return(userModel);
}
foreach (var user in filteringUsers.Collection)
{
var userModelItem = user.MapToModel <UserModelItem>();
if (userModelItem == null)
{
userModel.Errors.Add(Constants.Errors.OccuredProcessing);
continue;
}
userModel.Items.Add(userModelItem);
}
userModel.ItemsCount = filteringUsers.CollectionCount;
return(userModel);
}
public IActionResponse <List <UserDetailsModel> > Search(FilterUserModel filterModel)
{
var response = new ActionResponse <List <UserDetailsModel> >();
var result = _user.Where(x =>
(!string.IsNullOrEmpty(filterModel.FirstName) ? x.FirstName.Contains(filterModel.FirstName) : true) &&
(!string.IsNullOrEmpty(filterModel.LastName) ? x.LastName.Contains(filterModel.LastName) : true) &&
(!string.IsNullOrEmpty(filterModel.NationalCode) ? x.NationalCode == filterModel.NationalCode : true) &&
(filterModel.MobileNumber != null ? x.MobileNumber == filterModel.MobileNumber : true) &&
(filterModel.IsActive != null ? x.IsActive == filterModel.IsActive : true)
)
.OrderByDescending(x => x.RegisterDateMi)
.Select(s => new UserDetailsModel
{
MobileNumber = s.MobileNumber,
NationalCode = s.NationalCode,
IsActive = s.IsActive,
UserId = s.UserId,
FullName = s.FirstName + " " + s.LastName,
LastLoginDateMi = s.LastLoginDateMi,
RegisterDateMi = s.RegisterDateMi,
Email = s.Email
})
.Take(filterModel.ItemsCount)
.ToList();
if (result.Any())
{
response.IsSuccessful = true;
}
else
{
response.Message = BusinessMessage.UserNotFound;
}
response.Result = result;
return(response);
}
public ViewResult Index()
{
var filter = new FilterUserModel();
return(View(filter));
}
public async Task <IHttpActionResult> GetEnrollment([FromUri] int courseId, int?courseEventId, [FromBody] FilterUserModel request)
{
Course course = await db.Courses
.FirstOrDefaultAsync(x => x.Id == courseId);
if (course == null)
{
return(BadRequest());
}
CourseEvent courseEvent = new CourseEvent();
var users = new List <User>();
if (course.Status == CourseStatus.Trial)
{
courseEvent = await db.CourseEvents.FirstOrDefaultAsync(x => x.CourseId == course.Id &&
x.Status == CourseEventStatus.Trial);
}
if (course.Status == CourseStatus.Published)
{
if (courseEventId != null)
{
courseEvent = await db.CourseEvents.FirstOrDefaultAsync(x => x.Id == courseEventId.Value);
}
else
{
courseEvent = await db.CourseEvents.Where(x => x.CourseId == courseId).OrderByDescending(x => x.CreatedDate)
.FirstOrDefaultAsync();
}
}
if (courseEvent != null)
{
users = db.Enrollments
.Include(x => x.Learner)
.Where(x => x.CourseEventId == courseEvent.Id && x.Status == EnrollmentStatus.Enrolled)
.Select(x => x.Learner.User).ToList();
}
else
{
return(BadRequest());
}
if (users == null)
{
return(NotFound());
}
var totalCount = users.Count();
//advance search
var query = users.Where(s => (request.Name == null || s.Name.Contains(request.Name)) &&
(request.Email == null || s.Email.Contains(request.Email)) &&
(request.UserType == null || s.UserType == request.UserType)
);
//quick search
if (!string.IsNullOrEmpty(request.search.value))
{
var value = request.search.value.Trim();
query = query.Where(p => p.Name.Contains(value) ||
p.Email.Contains(value)
);
}
var filteredCount = query.Count();
if (request.order != null)
{
string sortBy = request.columns[request.order[0].column].data;
bool sortAscending = request.order[0].dir.ToLower() == "asc";
switch (sortBy)
{
case "Name":
if (sortAscending)
{
query = query.OrderBy(o => o.Name);
}
else
{
query = query.OrderByDescending(o => o.Name);
}
break;
case "UserType":
if (sortAscending)
{
query = query.OrderBy(o => o.UserType);
}
else
{
query = query.OrderByDescending(o => o.UserType);
}
break;
case "Email":
if (sortAscending)
{
query = query.OrderBy(o => o.Email);
}
else
{
query = query.OrderByDescending(o => o.Email);
}
break;
default:
query = query.OrderByDescending(o => o.Name);
break;
}
}
else
{
query = query.OrderByDescending(o => o.Name);
}
var data = query.Skip(request.start).Take(request.length)
.Select(s => new UserModel
{
Id = s.Id,
Name = s.Name,
Email = s.Email,
UserType = s.UserType
}).ToList();
data.ForEach(item => { item.UserTypeDesc = item.UserType.GetDisplayName(); });
return(Ok(new DataTableResponse
{
draw = request.draw,
recordsTotal = totalCount,
recordsFiltered = filteredCount,
data = data.ToArray()
}));
}
public async Task <IActionResult> GetAllUsersAsync([FromBody] FilterUserModel filterUserModel)
{
var responseModel = await _userService.GetAllUsersAsync(filterUserModel);
return(Ok(responseModel));
}
public IHttpActionResult GetUser([FromUri] int RoleId, [FromBody] FilterUserModel request)
{
var role = db.Role.Where(r => r.Id == RoleId).FirstOrDefault();
if (role == null)
{
return(NotFound());
}
var query = db.UserRole.Where(ur => ur.RoleId == RoleId);
var totalCount = query.Count();
//advance search
query = query.Where(s => (request.Name == null || s.UserAccount.User.Name.Contains(request.Name)) &&
(request.Email == null || s.UserAccount.User.Email.Contains(request.Email)) &&
(request.UserType == null || s.UserAccount.User.UserType == request.UserType)
);
//quick search
if (!string.IsNullOrEmpty(request.search.value))
{
var value = request.search.value.Trim();
query = query.Where(p => p.UserAccount.User.Name.Contains(value) ||
p.UserAccount.User.Email.Contains(value)
);
}
var filteredCount = query.Count();
if (request.order != null)
{
string sortBy = request.columns[request.order[0].column].data;
bool sortAscending = request.order[0].dir.ToLower() == "asc";
switch (sortBy)
{
case "Name":
if (sortAscending)
{
query = query.OrderBy(o => o.UserAccount.User.Name);
}
else
{
query = query.OrderByDescending(o => o.UserAccount.User.Name);
}
break;
case "UserType":
if (sortAscending)
{
query = query.OrderBy(o => o.UserAccount.User.UserType);
}
else
{
query = query.OrderByDescending(o => o.UserAccount.User.UserType);
}
break;
case "Email":
if (sortAscending)
{
query = query.OrderBy(o => o.UserAccount.User.Email);
}
else
{
query = query.OrderByDescending(o => o.UserAccount.User.Email);
}
break;
default:
query = query.OrderByDescending(o => o.UserAccount.User.Name);
break;
}
}
else
{
query = query.OrderByDescending(o => o.UserAccount.User.Name);
}
var data = query.Skip(request.start).Take(request.length)
.Select(s => new UserModel
{
Id = s.UserId,
Name = s.UserAccount.User.Name,
Email = s.UserAccount.User.Email,
UserType = s.UserAccount.User.UserType
}).ToList();
data.ForEach(item => { item.UserTypeDesc = item.UserType.GetDisplayName(); });
return(Ok(new DataTableResponse
{
draw = request.draw,
recordsTotal = totalCount,
recordsFiltered = filteredCount,
data = data.ToArray()
}));
}
