public async Task <ServiceResponse <UserDto, string> > Invite(InviteUserRequest request)
{
var response = new ServiceResponse <UserDto, string>();
// role configuration
if (request.Role == Role.Admin)
{
response.FailForbiden();
return(response);
}
var user = _mapper.Map <User>(request);
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
var userDto = _mapper.Map <UserDto>(user);
response.Extra = await _userManager.GenerateEmailConfirmationTokenAsync(user);
response.Data = userDto;
}
else
{
response.FailCreateUser(result);
}
return(response);
}
public async Task <InviteUserResponse> InviteUserInRoomAsync(string roomId, InviteUserRequest request)
{
string url = _baseApiAddress + $"rooms/{roomId}/invites";
var content = new StringContent(JsonConvert.SerializeObject(request));
return(await HttpClient.PostAsync <InviteUserResponse>(url, content));
}
public string Invite(User user)
{
string response = "";
var result = new InviteUserRequest(user).Execute(Api.Client);
if (result.Status == 200)
{
response = result.Data;
user.Clean();
}
return(response);
}
public async Task <IActionResult> InviteUser(int libraryId, [FromBody] InviteUserRequest model, CancellationToken cancellationToken)
{
var command = new InviteUserCommand()
{
Email = model.Email,
Name = model.Name,
LibraryId = libraryId,
Role = model.Role
};
await _commandProcessor.SendAsync(command, cancellationToken : cancellationToken);
return(Ok());
}
public async Task <IActionResult> OnPostInviteUserAsync(InviteUserRequest request)
{
await SetUp();
if (!ModelState.IsValid)
{
return(Page());
}
var create = new CreateInvitation(request.RoleId, Member.Id, request.ExpiresAt);
await _mediator.Send(create);
return(RedirectToPage());
}
public override async Task <BaseRemoteResponse> InviteUser(InviteUserRequest request, ServerCallContext context)
{
Log.Information("InviteUser called via gRPC remote service {@request}", request);
//Use AutoMapper instance to transform GrpcRequest into MediatR Request (Configured in Startup)
var inviteUserCommand = _mapper.Map <InviteUserCommand>(request);
var result = await _mediator.Send(inviteUserCommand);
//Use AutoMapper instance to transform CommandResponse into GrpcResponse (Configured in Startup)
var response = _mapper.Map <BaseRemoteResponse>(result);
return(response);
}
public PetWhizzResponse InviteUser(InviteUserRequest InviteUserRequest)
{
PetWhizzResponse _oResponse;
try
{
userServices.InviteUser(InviteUserRequest);
_oResponse = Utils.CreateSuccessResponse(null);
}
catch (Exception ex)
{
_oResponse = Utils.CreateErrorResponse(ex);
}
return(_oResponse);
}
public async Task <IActionResult> Invite(InviteUserRequest request)
{
var response = await _authRepo.Invite(request);
if (response.Succeeded())
{
var url = Url.Action(nameof(ConfirmInvitation), ControllerContext.ActionDescriptor.ControllerName,
new { Token = response.Extra, Email = request.Email }
, Request.Scheme);
var message = new Message(new string[] { response.Data.Email }, "Invitation email link", url);
_emailService.SendEmail(message);
}
return(HandleServiceResponse(response));
}
internal void InviteUser(InviteUserRequest InviteUserRequest)
{
logger.Debug("Recived Invite user request");
try
{
if (String.IsNullOrEmpty(InviteUserRequest.email))
{
logger.Error("User Invite required an email");
throw new CustomException("User Invite required an email", (int)ErrorCode.VALIDATIONFAILED);
}
CurrentUser currentUser = (CurrentUser)HttpContext.Current.User;
SendInvitationEmail(currentUser.username, InviteUserRequest.email, InviteUserRequest.message);
}
catch (CustomException) { throw; }
catch (Exception ex)
{
logger.Error(MethodBase.GetCurrentMethod().Name + ": exception: " + ex.Message + ", " + ex.InnerException);
throw new CustomException("SystemError", ex, (int)ErrorCode.PROCEESINGERROR); throw;
}
}
public HttpResponseMessage inviteUser(InviteUserRequest model)
{
if (!ModelState.IsValid)
{
Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
bool success = false;
ApplicationUser thisRole = UserService.GetUser(model.Email);
if (thisRole == null)
{
//- Create the link
string link = "/Account/Register/";
link = HttpContext.Current.Request.Url.GetComponents(UriComponents.SchemeAndServer, UriFormat.SafeUnescaped) + link;
//- Send Link to user email
EmailRequest confirm = new EmailRequest();
confirm.UserEmail = thisRole.Email;
confirm.Subject = "Hello, You've been invited to join QuoteMule! Please sign up now";
confirm.Content = link;
// confirm.html =
_UserEmailService.SendEmail(confirm);
success = true;
}
ItemResponse <bool> response = new ItemResponse <bool>();
response.Item = success;
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public InviteUserCommand(InviteUserRequest request, HttpContext httpContext)
{
InvitedUserEmailAddress = request.InvitedUserEmailAddress;
InviteRedirectUrl = request.InviteRedirectUrl;
IdentityId = httpContext.GetUserId();
}
public async Task <IActionResult> Invite([FromBody] InviteUserRequest request) => await Mediator .Send(new InviteUserCommand(request, HttpContext)) .ToOkResult();
public IObservable <InviteUserResponse> InviteUserInRoom(string roomId, InviteUserRequest request)
{
return(_apiService.InviteUserInRoomAsync(roomId, request).ToObservable());
}
public Task <WebApiResponse> Invite(InviteUserRequest request)
{
return(_client.MakeJsonCall("admin.users.invite", request));
}
