public async Task <JsonResult> GetList(UserQueryViewModel model, int pageIndex, int pageSize)
{
try
{
using (var db = new AuthDbContext())
{
var query = from u in db.Users
join ur in db.UserRoles on u.Id equals ur.UserId
join r in db.Roles on ur.RoleId equals r.Id
orderby u.CreateTime descending
where u.UserState != UserStates.Delete
select new
{
u.Id,
u.UserName,
u.UserState,
u.Email,
u.PhoneNumber,
u.CreateTime,
u.Operator,
u.Remark,
RoleId = r.Id,
RoleName = r.Name
};
if (!string.IsNullOrEmpty(model.QueryText))
{
query = query.Where(item =>
item.UserName.Contains(model.QueryText) ||
item.Email.Contains(model.QueryText) ||
item.PhoneNumber.Contains(model.QueryText) ||
item.Remark.Contains(model.QueryText) ||
item.RoleName.Contains(model.QueryText) ||
item.Operator.Contains(model.QueryText));
}
if (!string.IsNullOrEmpty(model.RoleId))
{
query = query.Where(item => item.RoleId == model.RoleId);
}
var list = await query
.Skip(pageSize *(pageIndex - 1))
.Take(pageSize)
.Distinct()
.ToListAsync();
return(Success(list, await UserManager.Users.CountAsync()));
}
}
catch (Exception ex)
{
return(Fail(ErrorCode.DataError, ex.Message));
}
}
public async Task <IActionResult> BuscarporEmail(UserQueryViewModel viewmodel)
{
DataResponse <UserDTO> response = await _userService.GetUserByEmail(viewmodel.Email);
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <UserDTO, UserQueryViewModel>();
});
IMapper mapper = configuration.CreateMapper();
List <UserQueryViewModel> userqueryviewmodel =
mapper.Map <List <UserQueryViewModel> >(response.Data);
ViewBag.Users = userqueryviewmodel;
return(View());
}
public async Task <IActionResult> Buscar(UserQueryViewModel viewmodel)
{
DataResponse <List <UserDTO> > sales = await this._userService.GetUser();
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <UserDTO, UserQueryViewModel>();
});
IMapper mapper = configuration.CreateMapper();
List <UserQueryViewModel> userqueryviewmodel =
mapper.Map <List <UserQueryViewModel> >(sales);
ViewBag.Users = userqueryviewmodel;
return(View());
}
public ActionResult Index(UserQueryViewModel model)
{
var dbContext = new OctopusDbContext();
var script = PreparedScriptHelper.Get(model.PreparedScriptId);
ModelState.Remove("Sql");
if (script != null)
{
model.Sql = script.Sql;
model.Params = PreparedScriptHelper.PrepareParams(script.Sql);
}
else
{
model.Sql = string.Empty;
}
return(View(model));
}
public IActionResult UserQuery(int userId)
{
var queues = _bookingService.GetUserQueue(userId);
var user = _userService.GetUser(userId);
var viewModel = new UserQueryViewModel()
{
Queues = new Dictionary <Queue, Book>()
};
viewModel.UserName = user.FullName;
foreach (var queue in queues)
{
viewModel.Queues.Add(queue, _bookService.GetBook(queue.BookId));
_bookingService.RefreshBookStatus(queue.BookId);
}
return(View(viewModel));
}
public async Task <UserQueryViewModel> GetAsync(UserQueryViewModel queryModel)
{
var query = queryModel.MapToQuery <UserQuery>();
await _userRepository.GetByQueryAsync(query);
// var tempQuery = await _cacheManager.GetAsync(
// GirvsEntityCacheDefaults<User>.QueryCacheKey.Create(query.GetCacheKey()), async () =>
// {
// await _userRepository.GetByQueryAsync(query);
// return query;
// });
//
// if (!query.Equals(tempQuery))
// {
// query.RecordCount = tempQuery.RecordCount;
// query.Result = tempQuery.Result;
// }
return(query.MapToQueryDto <UserQueryViewModel, User>());
}
public async Task <ActionResult> Query(UserQueryViewModel model)
{
if (ModelState.IsValid)
{
using (UserServiceClient client = new UserServiceClient())
{
await Task.Run(() =>
{
StringBuilder where = new StringBuilder();
if (model != null)
{
if (!string.IsNullOrEmpty(model.LoginName))
{
where.AppendFormat(" Key LIKE '{0}%'", model.LoginName);
}
if (!string.IsNullOrEmpty(model.UserName))
{
where.AppendFormat(" {0} UserName LIKE '{1}%'",
where.Length > 0?"AND":string.Empty,
model.UserName);
}
}
PagingConfig cfg = new PagingConfig()
{
Where = where.ToString()
};
MethodReturnResult <IList <User> > result = client.Get(ref cfg);
if (result.Code == 0)
{
ViewBag.PagingConfig = cfg;
ViewBag.UserList = result.Data;
}
});
}
}
return(PartialView("_UserListPartial"));
}
public ActionResult Execute(UserQueryViewModel userQuery)
{
SqlQuery query = new SqlQuery();
var preparedScript = PreparedScriptHelper.Get(userQuery.PreparedScriptId);
if (preparedScript != null)
{
query.PreparedScriptName = preparedScript.Name;
}
query.Databases = userQuery.Databases;
query.Sql = PreparedScriptHelper.SetParams(userQuery.Sql, userQuery.Params);
query.UserId = UserHelper.GetUserId(User.Identity);
query.DateStart = DateTime.Now;
query.SingleTable = userQuery.SingleTable;
_dbContext.Queries.Add(query);
_dbContext.SaveChanges();
Worker.ExecuteQuery(query);
return(Redirect(string.Format("~/Query/Execute/{0}", query.Id)));
}
public async Task Get_ShouldReturnUserList()
{
// Arrange
var buyerAccountId = 1;
var buyerAccountUuid = Guid.NewGuid();
var buyerAccount = new BuyerAccount {
BuyerAccountId = buyerAccountId, BuyerAccountUuid = buyerAccountUuid
};
var model = new UserQueryViewModel {
BuyerAccountUuid = buyerAccountUuid
};
var user = new User {
UserId = Guid.NewGuid()
};
var userBuyerRole = new UserBuyerRole {
UserId = user.UserId, BuyerAccountId = buyerAccountId, RoleName = "Role"
};
user.UserBuyerRoles.Add(userBuyerRole);
var users = new List <User> {
user
};
Mock.Mock <IAccountService>().Setup(x => x.GetAccount(buyerAccountUuid)).Returns(Task.FromResult(buyerAccount));
Mock.Mock <IUserService>().Setup(x => x.GetUsers(It.IsAny <UserQueryOptions>())).Returns(users.ToAsyncEnumerable());
// Act
var retVal = await Controller.Get(model);
// Assert
Assert.That(retVal, Is.Not.Null);
Assert.That(retVal, Is.TypeOf <OkNegotiatedContentResult <PagedListViewModel <UserListViewModel> > >());
var content = ((OkNegotiatedContentResult <PagedListViewModel <UserListViewModel> >)retVal).Content;
Assert.That(content.TotalItemCount, Is.EqualTo(1));
Assert.That(content.Data.ElementAt(0).UserId, Is.EqualTo(user.UserId));
}
public async Task <IHttpActionResult> Get([FromUri] UserQueryViewModel model)
{
model = model ?? new UserQueryViewModel(); // super/system admins can pass null to get all users
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.UserId.HasValue)
{
var user = await _userService.GetUser(model.UserId.Value).ConfigureAwait(false);
if (user == null)
{
return(BadRequest("The specified user was not found."));
}
}
if (model.BuyerAccountUuid.HasValue)
{
var buyerAccount = await _accountService.GetAccount(model.BuyerAccountUuid.Value).ConfigureAwait(false);
if (buyerAccount == null)
{
return(BadRequest("The specified buyer account was not found."));
}
}
var userQueryOptions = _mapping.Map <UserQueryOptions>(model);
var users = await _userService.GetUsers(userQueryOptions).ToPagedListAsync(model).ConfigureAwait(false);
var retVal = _mapping.Map <PagedListViewModel <UserListViewModel> >(users);
return(Ok(retVal));
}
