public GetUserResponse Get(GetUserRequest request)
{
var query = repository
.AsQueryable<Models.User>();
if (request.UserId.HasValue)
{
query = query.Where(user => user.Id == request.UserId);
}
else
{
query = query.Where(user => user.UserName == request.UserName);
}
var model = query
.Select(user => new UserModel
{
Id = user.Id,
Version = user.Version,
CreatedBy = user.CreatedByUser,
CreatedOn = user.CreatedOn,
LastModifiedBy = user.ModifiedByUser,
LastModifiedOn = user.ModifiedOn,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
ImageId = user.Image != null && !user.Image.IsDeleted ? user.Image.Id : (System.Guid?)null,
ImageCaption = user.Image != null && !user.Image.IsDeleted ? user.Image.Caption : null,
ImageThumbnailUrl = user.Image != null && !user.Image.IsDeleted ? fileUrlResolver.EnsureFullPathUrl(user.Image.PublicThumbnailUrl) : null,
ImageUrl = user.Image != null && !user.Image.IsDeleted ? fileUrlResolver.EnsureFullPathUrl(user.Image.PublicUrl) : null
})
.FirstOne();
var response = new GetUserResponse { Data = model };
if (request.Data.IncludeRoles)
{
response.Roles = repository
.AsQueryable<Models.UserRole>(userRole => userRole.User.Id == model.Id && !userRole.Role.IsDeleted)
.OrderBy(role => role.Role.Name)
.Select(role => new RoleModel
{
Id = role.Role.Id,
Version = role.Role.Version,
CreatedBy = role.Role.CreatedByUser,
CreatedOn = role.Role.CreatedOn,
LastModifiedBy = role.Role.ModifiedByUser,
LastModifiedOn = role.Role.ModifiedOn,
Name = role.Role.Name,
Description = role.Role.Description ?? string.Empty,
IsSystematic = role.Role.IsSystematic
})
.ToList();
}
return response;
}
public async Task<UserPreviewDto> GetUser([FromUri] int id)
{
var request = new GetUserRequest()
{
Id = id
};
return await _mediator.ExecuteAsync(request).ConfigureAwait(false);
}
public async Task<UserDto> Details(string username)
{
var request = new GetUserRequest
{
Username = username
};
return await _mediator.ExecuteAsync(request).ConfigureAwait(false);
}
/// <summary>
/// Gets a User object by the specified Bing Ads user identifier.
/// </summary>
/// <param name="userId">The identifier of the user to get. If null, this operation returns the User object
/// corresponding to the current authenticated user of the global customer management ServiceClient.</param>
/// <returns>The User object corresponding to the specified Bing Ads user identifier.</returns>
private async Task <User> GetUserAsync(long?userId)
{
var request = new GetUserRequest
{
UserId = userId
};
return((await _customerService.CallAsync((s, r) => s.GetUserAsync(r), request)).User);
}
/// <summary>
/// 通过条件获取用户
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public List <User> GetUserListByName(GetUserRequest request)
{
string sql = "select * from User where name=" + request.UserName;
using (var context = new EntityContext())
{
return(context.Database.SqlQuery <User>(sql));
}
}
public async Task <User> GetUserAsync(string userId)
{
var request = new GetUserRequest
{
Id = userId
};
return(await this.client.RequestUserAsync(request));
}
public GetUserResponse Get(GetUserRequest request)
{
GetUserResponse response = new GetUserResponse();
User result = _brainManager.GetUser(request.Uid);
response.User = result ?? throw HttpError.NotFound($"User {request.Uid} does not exist");
return(response);
}
/// <summary>
/// Gets the user and user role corresponding to the specified user identifier.
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
private async Task <GetUserResponse> GetUserAsync(long userId)
{
var request = new GetUserRequest
{
UserId = userId
};
return(await Service.CallAsync((s, r) => s.GetUserAsync(r), request));
}
public async Task <UserResponse> GetUserAsync(GetUserRequest request,
CancellationToken cancellationToken = default)
{
var response = await _userRepository.GetByEmailAsync(request.Email, cancellationToken);
return(new UserResponse {
Name = response.Name, Email = response.Email
});
}
public Task <UserViewModel> Get(int id)
{
var request = new GetUserRequest
{
UserId = id
};
return(this.mediator.Send(request));
}
public GetUserResponse GetUser(GetUserRequest request) =>
new GetUserResponse
{
UserId = request.Id,
Success = true,
Firstname = "Test",
Lastname = "User",
Email = "*****@*****.**"
};
/// <summary>
/// Initiates the asynchronous execution of the GetUser operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetUser operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/chime-2018-05-01/GetUser">REST API Reference for GetUser Operation</seealso>
public virtual Task <GetUserResponse> GetUserAsync(GetUserRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetUserResponseUnmarshaller.Instance;
return(InvokeAsync <GetUserResponse>(request, options, cancellationToken));
}
internal virtual GetUserResponse GetUser(GetUserRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetUserResponseUnmarshaller.Instance;
return(Invoke <GetUserResponse>(request, options));
}
public override Task <GetUserResponse> GetUser(GetUserRequest request, ServerCallContext context)
{
_logger.LogInformation($"Received request with Id : {request.Id}");
return(Task.FromResult(new GetUserResponse
{
Id = request.Id,
Name = Guid.NewGuid().ToString()
}));
}
/// <summary>
/// Gets a User object by the specified Bing Ads user identifier.
/// </summary>
/// <param name="userId">The identifier of the user to get. If null, this operation returns the User object
/// corresponding to the current authenticated user of the global customer management ServiceClient.</param>
/// <returns>The User object corresponding to the specified Bing Ads user identifier.</returns>
private async Task<User> GetUserAsync(long? userId)
{
var request = new GetUserRequest
{
UserId = userId
};
return (await Service.CallAsync((s, r) => s.GetUserAsync(r), request)).User;
}
public void Delete()
{
System.Console.WriteLine("---Delete user---");
System.Console.Write("Id:");
int id = int.Parse(System.Console.ReadLine());
GetUserRequest requestGet = new GetUserRequest
{
UserId = id
};
GetUserResponse responseGet = _client.GetUser(requestGet);
if (responseGet == null)
{
System.Console.WriteLine("Error: response is null");
return;
}
if (!responseGet.Success)
{
System.Console.WriteLine($"Error: {responseGet.Message}");
return;
}
System.Console.WriteLine("Success: User found");
System.Console.WriteLine("Do you want to delete the user?[Y/n]");
if (System.Console.ReadKey(true).Key == System.ConsoleKey.Y)
{
DeleteUserRequest requestDelete = new DeleteUserRequest
{
UserId = id
};
DeleteUserResponse responseDelete = _client.DeleteUser(requestDelete);
if (responseDelete == null)
{
System.Console.WriteLine("Error: response is null");
}
else
if (!responseDelete.Success)
{
System.Console.WriteLine($"Error: {responseDelete.Message}");
}
else
{
System.Console.WriteLine($"Success: User deleted");
}
}
System.Console.WriteLine("------------------");
}
private User FindUser(string email)
{
GetUserRequest request = new GetUserRequest
{
Email = email,
CustomerId = Customer.CustomerId
};
return(_userService.GetUser(request));
}
public override Task <UserResponse> GetUser(GetUserRequest request, ServerCallContext context)
{
var user = _adminUserBusinessLogic.GetById(request.Id).Value;
return(Task.FromResult(new UserResponse
{
Email = user?.Email,
Name = user?.Name
}));
}
public override Task <GetUserResponse> GetUser(GetUserRequest request, ServerCallContext context)
{
var user = Users.FirstOrDefault(x => x.Item1.Equals(request.Name));
return(Task.FromResult(new GetUserResponse()
{
Name = user.Item1,
UserId = user.Item2.ToString()
}));
}
internal async Task <GetUserResponse> getAttributes(CognitoUser user)
{
AmazonCognitoIdentityProviderClient provider = new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials());
GetUserRequest req = new GetUserRequest();
req.AccessToken = user.SessionTokens.AccessToken;
var res = provider.GetUser(req);
return(res);
}
/// <summary>
/// 通过ID获取用户信息
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ResponseBase> ProcessAction(GetUserRequest request)
{
var user = await _sysUserBll.GetSysUser(request.UserId);
if (user == null)
{
return(new ResponseBase().GetResponseError(StatusCode.User40001, "用户不存在"));
}
return(ResponseBase.Success(new UserView(user.UserId, user.UserRoleId, user.NickName, user.Account, user.StatusFlag)));
}
public async Task <GetUserResponse> GetUserAsync(
long?userId)
{
var request = new GetUserRequest
{
UserId = userId
};
return(await CustomerManagementService.CallAsync((s, r) => s.GetUserAsync(r), request));
}
public GetUserResponse GetUser(GetUserRequest request)
{
return(Execute <GetUserRequest, GetUserResponse>(
request, response =>
{
response.User = request.UserId > 0
? _userFacade.GetUser(request.UserId)
: _userFacade.GetUser(request.UserName);
}));
}
public void TestGetUserImplicit()
{
GetUserRequest request = new GetUserRequest();
GetUserResponse response = Client.GetUser(request);
Assert.IsFalse(string.IsNullOrEmpty(response.User.Arn));
// The assert will succeed if you run with root credentials.
//Assert.AreEqual(string.Format("arn:aws:iam::{0}:root", response.User.UserId), response.User.Arn);
}
/// <summary>
/// Gets the details for the current user using an asynchronous call
/// </summary>
/// <returns>Returns a tuple containing the user attributes and settings, in that order</returns>
public void GetUserDetailsAsync(AsyncCallback <GetUserResponse> callback = null)
{
EnsureUserAuthenticated();
GetUserRequest getUserRequest = new GetUserRequest()
{
AccessToken = SessionTokens.AccessToken
};
Provider.GetUserAsync(getUserRequest, r => callback?.Invoke(new AsyncResult <GetUserResponse>(r.Response, r.Exception)));
}
public object Get(GetUserRequest Request)
{
User User = Request.GetEntity(((NHibernate.ISession)base.Request.Items["hibernateSession"]));
if (User == null)
{
User = base.GetAuthenticatedUser(((NHibernate.ISession)base.Request.Items["hibernateSession"]));
}
return(new GetUserResponse(User, ((NHibernate.ISession)base.Request.Items["hibernateSession"])));
}
/// <summary>
/// Gets the details for the current user using an asynchronous call
/// </summary>
/// <returns>Returns a tuple containing the user attributes and settings, in that order</returns>
public virtual Task <GetUserResponse> GetUserDetailsAsync()
{
EnsureUserAuthenticated();
GetUserRequest getUserRequest = new GetUserRequest()
{
AccessToken = SessionTokens.AccessToken
};
return(Provider.GetUserAsync(getUserRequest));
}
public object Get(GetUserRequest request)
{
IDocumentStore store = DocumentStoreHolder.Store;
using (var storeSession = store.OpenSession())
{
return(new UserResponse {
Result = storeSession.Load <User>(request.UserId)
});
}
}
public IActionResult Authenticate([FromBody] GetUserRequest request)
{
var resp = _service.Authenticate(request);
if (resp.Success)
{
return(Ok(resp.User));
}
return(BadRequest(resp.Message));
}
public GetUserResponse GetUser(GetUserRequest request)
{
var response = new GetUserResponse();
response.Success = true;
response.Firstname = "Test";
response.Lastname = "User";
response.Email = "*****@*****.**";
return(response);
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetUserRequest, GetUserResponse> ForUser(GetUserRequest request, WaiterConfiguration config, params User.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetUserRequest, GetUserResponse>(
request,
request => client.GetUser(request),
response => targetStates.Contains(response.User.LifecycleState.Value),
targetStates.Contains(User.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetUserRequest, GetUserResponse>(config, agent));
}
public GetUserResponse Get(GetUserRequest request)
{
using (var client = new OrmClient())
{
var q = client.Select <SysUser>(u => u.UserName == request.UserName).FirstOrDefault();
return(new GetUserResponse
{
data = q
});
}
}
protected override void LoadComplete()
{
base.LoadComplete();
AddStep("online user (Angelsim)", () =>
{
var request = new GetUserRequest(1777162);
request.Success += user => this.user.Value = user;
api.Queue(request);
});
}
public GetUserResponse GetUserById(GetUserRequest request)
{
GetUserResponse response = new GetUserResponse();
SecurityBusinessComponent bc = DependencyInjectionHelper.GetSecurityBusinessComponent();
User user = bc.GetUserById(request.Id);
response.User = SecurityAdapter.UserToDTO(user);
return(response);
}
public UserModel Get(GetUserRequest request) => GetUser.Execute(request);
private IEnumerable<StashUser> GetStashUsers()
{
var list = new List<StashUser>();
var getUser = new GetUserRequest(_settings);
var result = getUser.Send();
if (result.Success)
{
foreach (var value in result.Result["values"])
{
list.Add(new StashUser { Slug = value["slug"].ToString() });
}
}
return list;
}
/// <summary>
/// Get user.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// Get user response object.
/// </returns>
public GetUserResponse GetUser(GetUserRequest request)
{
return new GetUserResponse();
}
private void run()
{
while (true)
{
switch (State)
{
case APIState.Failing:
//todo: replace this with a ping request.
log.Add($@"In a failing state, waiting a bit before we try again...");
Thread.Sleep(5000);
if (queue.Count == 0)
{
log.Add($@"Queueing a ping request");
Queue(new ListChannelsRequest() { Timeout = 5000 });
}
break;
case APIState.Offline:
//work to restore a connection...
if (!HasLogin)
{
//OsuGame.Scheduler.Add(() => { OsuGame.ShowLogin(); });
State = APIState.Offline;
Thread.Sleep(500);
continue;
}
if (State < APIState.Connecting)
State = APIState.Connecting;
if (!authentication.HasValidAccessToken && !authentication.AuthenticateWithLogin(Username, Password))
{
//todo: this fails even on network-related issues. we should probably handle those differently.
//NotificationManager.ShowMessage("Login failed!");
log.Add(@"Login failed!");
ClearCredentials();
continue;
}
var userReq = new GetUserRequest();
userReq.Success += (u) => {
LocalUser.Value = u;
};
if (!handleRequest(userReq))
{
State = APIState.Failing;
continue;
}
//we're connected!
State = APIState.Online;
failureCount = 0;
break;
}
//hard bail if we can't get a valid access token.
if (authentication.RequestAccessToken() == null)
{
State = APIState.Offline;
continue;
}
//process the request queue.
APIRequest req;
while (queue.TryPeek(out req))
{
if (handleRequest(req))
{
//we have succeeded, so let's unqueue.
queue.TryDequeue(out req);
}
}
Thread.Sleep(1);
}
}
public CommandResult<User> GetUser(GetUserRequest getUserRequest)
{
return _getUserCommand.ExecuteRequest(getUserRequest);
}
//================================================================================
// DO NOT ADD ANY MORE REQUESTS HERE. PLACE IN "Requests" subnamespace.
//================================================================================
//
// Authenticated Requests
//
public GetUserResponse GetUser(GetUserRequest requestData)
{
var apiClientRequest = new ApiClientRequest(ApiUrl, ApiKey, PrivateKeyPem);
return apiClientRequest.PerformRequest<GetUserResponse>("get_user", requestData);
}
public GetUserResponse Get(GetUserRequest request)
{
throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
}
/// <summary>
/// Gets the user.
/// </summary>
/// <param name="userName">The username.</param>
/// <returns>
/// The manager response where the user is returned in the response.
/// </returns>
public virtual ManagerResponse<GetUserResult, CommerceUser> GetUser(string userName)
{
Assert.ArgumentNotNullOrEmpty(userName, "userName");
var request = new GetUserRequest(userName);
var result = this.CustomerServiceProvider.GetUser(request);
if (!result.Success || result.CommerceUser == null)
{
var message = StorefrontManager.GetSystemMessage("UserNotFoundError");
result.SystemMessages.Add(new SystemMessage { Message = message });
}
Helpers.LogSystemMessages(result.SystemMessages, result);
return new ManagerResponse<GetUserResult, CommerceUser>(result, result.CommerceUser);
}
