public async Task <List <UserViewModel> > SearchUser(SearchUserRequest request)
{
var query = _context.Users.Where(x => x.displayname != "Admin").AsQueryable();
if (!string.IsNullOrEmpty(request.keyWord))
{
query = query.Where(x => x.displayname.ToLower().Contains(request.keyWord.ToLower()));
}
if (request.status != null)
{
query = query.Where(x => x.status == request.status);
}
return(await query.Select(y => new UserViewModel
{
id = y.Id,
address = y.address,
avatar = y.avatar,
birthDay = y.birthDay,
displayname = y.displayname,
email = y.Email,
gender = y.gender,
Orders = y.Orders,
phone = y.phone,
status = y.status,
userType = y.UserName.Contains("facebook") ? "Facebook User" : "User"
}).ToListAsync());
}
public async Task <List <SearchUserResult> > Search(SearchUserRequest request)
{
var users = await _repository.FindUsersAsync(request.Query);
var result = new List <SearchUserResult>();
foreach (var user in users)
{
if (user.Email.Equals(User.Identity.Name))
{
continue;
}
result.Add
(
new SearchUserResult
{
Id = user.Id,
Name = $"{user.UserName} <{user.Email}>"
}
);
}
return(result);
}
public async Task <IActionResult> SearchUser([FromBody] SearchUserRequest request)
{
string method = nameof(SearchUser);
LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method, request);
PagedResponse <object> response = new PagedResponse <object>();
try
{
var query = await DbContext.GetUsers(request).Paging(response, request.page_start, request.page_size)
// .Include(x=>x.fund)
.ToListAsync();
var entity_list = query
.Select(x => new
{
x.id,
x.first_name,
x.last_name,
x.mobile
});
response.Model = entity_list;
response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
}
catch (Exception ex)
{
LogHandler.LogError(Logger, response, method, ex);
}
return(response.ToHttpResponse(Logger, method));
}
/// <summary>
/// 列表数据
/// </summary>
/// <param name="search"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <LayerTableJson> LayuiTableListAsync(SearchUserRequest search, CancellationToken cancellationToken)
{
var response = new LayerTableJson();
var entity = _userStore.IQueryableListAsync().Where(y => !y.IsDeleted);
if (!string.IsNullOrWhiteSpace(search.RoleName))
{
// entity = entity.Where(y=>y.listRole.Contains(search.RoleName));
}
if (!string.IsNullOrWhiteSpace(search.PhoneNumber))
{
entity = entity.Where(y => y.PhoneNumber.Contains(search.PhoneNumber));
}
if (!string.IsNullOrWhiteSpace(search.TrueName))
{
entity = entity.Where(y => y.TrueName.Contains(search.TrueName));
}
if (!string.IsNullOrWhiteSpace(search.UserName))
{
entity = entity.Where(y => y.UserName.Contains(search.UserName));
}
response.Count = await entity.CountAsync(y => y.Id != null, cancellationToken);
var list = await entity.Skip(((search.Page ?? 0) - 1) *search.Limit ?? 0).Take(search.Limit ?? 0).ToListAsync(cancellationToken);
var result = _mapper.Map <List <UserListResponse> >(list);
result.ForEach(y =>
{
// 改成同步方法才不会报错
y.RoleName = GetRoleName(y.Id);
});
response.Data = result;
return(response);
}
public IActionResult SearchUserByEmail([FromBody] SearchUserRequest request)
{
var response = _userService.SearchUserByEmail(request.Email, this.User?.Identity?.Name);
var result = _mapper.Map <IList <Model.UserModel> >(response);
return(base.Ok(result));
}
public SearchUserResponse Get(SearchUserRequest request)
{
SearchUserResponse response = new SearchUserResponse();
response.Users = PlacesToVisitRepository.SearchUsersByUserDetails(request.SearchQuery);
return(response);
}
public async Task <IActionResult> SearchUsers(SearchUserRequest model)
{
if (!this.IsAuthenticationRight("administrator"))
{
return(Unauthorized());
}
return(Ok(this.dbaf.SearchUsers(model)));
}
public IHttpActionResult SearchUser(SearchUserRequest request)
{
request.ValidateNotNull();
return(Ok(new SearchUserResponse()
{
Data = _userManipulation.SearchUsers(request.Paging, request.FilterCriteria, request.SortCriteria),
Success = Common.Enumerations.ResponseStatus.Succeeded
}));
}
public async Task <ActionResult <List <UserSearchResponse> > > PostSearchAsync(
[FromServices] NaheulbookExecutionContext executionContext,
SearchUserRequest request
)
{
try
{
var users = await _userService.SearchUserAsync(executionContext, request.Filter);
return(_mapper.Map <List <UserSearchResponse> >(users));
}
catch (ForbiddenAccessException ex)
{
throw new HttpErrorException(StatusCodes.Status403Forbidden, ex);
}
}
public async Task <IActionResult> SearchUsers([FromQuery] SearchUserRequest searchUserRequest)
{
var result = await _operationFactory.Create <SearchUsersQuery>(x =>
{
x.SearchText = searchUserRequest.SearchUserNameText;
x.CurrentUserId = HttpContext.GetUserId();
x.Skip = searchUserRequest.Skip;
x.Take = searchUserRequest.Take;
}).HandleAsync();
if (result.HasFailed())
{
return(BadRequest(result.Errors));
}
return(Ok(result.Data));
}
public async Task <List <UserProfileResponse> > SearchUsers(SearchUserRequest searchUserRequest)
{
var client = _httpClientFactoryService.GetHttpClient();
var request = new RestRequest(ApiRoutes.Search.SearchUsers)
{
Method = Method.GET
};
request.AddQueryParameter("searchUserNameText", searchUserRequest.SearchUserNameText);
request.AddQueryParameter("take", searchUserRequest.Take.ToString());
request.AddQueryParameter("skip", searchUserRequest.Skip.ToString());
var response = await client.ExecuteAsync <List <UserProfileResponse> >(request);
return(response.ResponseData);
}
public async Task SearchUser()
{
using (var transaction = Fixture.Connection.BeginTransaction())
{
using (var context = Fixture.CreateContext(transaction))
{
TypeaheadService typeaheadService = new TypeaheadService(context);
SearchUserRequest request = new SearchUserRequest
{
SearchParameter = "Test User",
};
SearchUserReply actualReply = await typeaheadService.SearchUser(request, TestServerCallContext.Create("fooMethod", "test.example.com", DateTime.UtcNow.AddHours(1), new Metadata(), CancellationToken.None, "127.0.0.1", null, null, (metadata) => TaskUtils.CompletedTask, () => new WriteOptions(), (writeOptions) => { }));
Assert.Equal(2, actualReply.Entries.Count);
}
}
}
public async Task <LayerTableJson> LayuiTableList([FromBody] SearchUserRequest search)
{
var response = new LayerTableJson();
if (search.Page == 0)
{
throw new ZCustomizeException(ResponseCodeEnum.ModelStateInvalid, "本接口仅支持页数从1开始");
}
try
{
response = await _userManager.LayuiTableListAsync(search, HttpContext.RequestAborted);
}
catch (Exception e)
{
response.Code = 500;
response.Msg = "用户列表查询失败，请重试";
_logger.LogInformation($"用户列表查询失败异常:{JsonHelper.ToJson(e)}");
}
return(response);
}
public async Task PostSearchTest()
{
// Arrange
var query = string.Empty;
var request = new SearchUserRequest {
Query = query
};
var users = new List <UserModel>();
this.userService.SearchAsync(query).Returns(users);
// Act
var resultRaw = await this.searchUserController.PostSearch(request);
var result = resultRaw as OkNegotiatedContentResult <IEnumerable <UserModel> >;
// Assert
Assert.NotNull(result);
Assert.NotNull(result.Content);
Assert.Equal(users, result.Content);
}
public override async Task <SearchUserReply> SearchUser(SearchUserRequest request, ServerCallContext context)
{
List <AppUser> users = await _authDbContext.Users
.AsNoTracking()
.Where(u => u.UserName.Contains(request.SearchParameter))
.ToListAsync();
SearchUserReply reply = new SearchUserReply();
foreach (AppUser user in users)
{
SearchUserEntry entry = new SearchUserEntry
{
Id = user.Id.ToString(),
Name = user.UserName,
};
reply.Entries.Add(entry);
}
return(reply);
}
public SearchUserResponse[] SearchUsers(SearchUserRequest model)
{
var conn = this.OpenConnection();
List <SearchUserResponse> result = new List <SearchUserResponse>();
try
{
using (conn)
{
var rdr = conn.ExecuteReader("select * from Admin.SearchUsers(@top, @rowCount, @ss::citext)", new { top = model.Top, rowCount = model.RowCount, ss = model.SS ?? "" });
while (rdr.Read())
{
result.Add(ConvertToObject <SearchUserResponse>(rdr));
}
rdr.Close();
}
}
finally
{
conn.Close();
}
return(result.ToArray());
}
public async Task <IActionResult> SearchUser(SearchUserRequest request)
{
var data = await _manageUserService.SearchUser(request);
return(Ok(data));
}
public ActionResult <SearchUserResponse> Search([FromBody] SearchUserRequest request)
{
var result = _userService.Search(request);
return(result);
}
public async Task <IHttpActionResult> PostSearch(SearchUserRequest request)
{
var users = await this.userService.SearchAsync(request.Query);
return(Ok(users));
}
public async Task <ActionResult <User> > SearchUsers(SearchUserRequest searchUserRequest)
{
var users = await _userManager.SearchUsersAsync(searchUserRequest.Username, searchUserRequest.Id);
return(Ok(users));
}
public async Task <IActionResult> GetProfile(SearchUserRequest request, [FromServices] IHandler <SearchUserRequest, ObjectResult> handler)
{
return(await handler.Handle(request));
}
