public async Task <Response> CreateResponseAsync()
{
UserVm resultUser;
VerificationCodeInfo verificationCode = await verificationCodesService
.GetUserVerificationCodeAsync(request.Value, clientConnection.UserId).ConfigureAwait(false);
if (isPhoneEditing)
{
if (await loadUsersService.IsPhoneExistsAsync(request.Value).ConfigureAwait(false))
{
var errorObject = new
{
Phone = $"Phone number {request.Value} already exists"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ObjectsLibrary.Enums.ErrorCode.WrongArgumentError));
}
if (verificationCode != null && verificationCode.VCode == request.VCode && request.Value == verificationCode.Id)
{
resultUser = await updateUsersService.UpdateUserPhoneAsync(clientConnection.UserId.Value, request.Value).ConfigureAwait(false);
}
else
{
return(new ResultResponse(request.RequestId, "Wrong verification code.", ObjectsLibrary.Enums.ErrorCode.WrongVerificationCode));
}
}
else
{
if (await loadUsersService.IsEmailExistsAsync(request.Value).ConfigureAwait(false))
{
var errorObject = new
{
Email = $"Email {request.Value} already exists"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ObjectsLibrary.Enums.ErrorCode.WrongArgumentError));
}
if (verificationCode != null && verificationCode.VCode == request.VCode && request.Value == verificationCode.Id)
{
resultUser = await updateUsersService.UpdateUserEmailAsync(clientConnection.UserId.Value, request.Value).ConfigureAwait(false);
}
else
{
return(new ResultResponse(request.RequestId, "Wrong verification code.", ObjectsLibrary.Enums.ErrorCode.WrongVerificationCode));
}
}
return(new UsersResponse(request.RequestId, resultUser));
}
public async Task <Response> CreateResponseAsync()
{
if (!NodeSettings.Configs.Node.UserRegistrationAllowed)
{
return(new ResultResponse(request.RequestId, "User registration is not allowed.", ErrorCode.PermissionDenied));
}
UserVm user = request.User;
try
{
VerificationCodeInfo verificationCode = null;
if (!request.User.Phones.IsNullOrEmpty() && request.User.Emails.IsNullOrEmpty())
{
if (NodeSettings.Configs.Node.RegistrationMethod == RegistrationMethod.EmailRequired)
{
var errorObject = new
{
Email = "Email required"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
if (await loadUsersService.IsPhoneExistsAsync(request.User.Phones.FirstOrDefault().FullNumber).ConfigureAwait(false))
{
var errorObject = new
{
Phone = "Phone already exists"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
verificationCode = await verificationCodesService.GetUserVerificationCodeAsync(request.User.Phones.FirstOrDefault().FullNumber).ConfigureAwait(false);
}
else if (request.User.Phones.IsNullOrEmpty() && !request.User.Emails.IsNullOrEmpty())
{
if (NodeSettings.Configs.Node.RegistrationMethod == RegistrationMethod.PhoneRequired)
{
var errorObject = new
{
Email = "Phone required"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
if (await loadUsersService.IsEmailExistsAsync(request.User.Emails.FirstOrDefault()).ConfigureAwait(false))
{
var errorObject = new
{
Email = "Email already exists."
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
verificationCode = await verificationCodesService.GetUserVerificationCodeAsync(request.User.Emails.FirstOrDefault()).ConfigureAwait(false);
}
else
{
if (NodeSettings.Configs.Node.RegistrationMethod != RegistrationMethod.NothingRequired)
{
var errorObject = new
{
Email = "Email only or phone only",
Phone = "Email only or phone only"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
}
if (verificationCode != null &&
verificationCode.VCode != request.VCode &&
(!request.User.Emails.IsNullOrEmpty() || !request.User.Phones.IsNullOrEmpty()))
{
var errorObject = new
{
VCode = "Wrong verification code"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongVerificationCode));
}
ValuePair <UserVm, string> userPasswordPair = await createUsersService.CreateNewUserAsync(user, NodeSettings.Configs.Node.Id, NodeSettings.Configs.ConfirmUsers).ConfigureAwait(false);
TokenVm tempTokens = await tokensService.CreateTokenPairByUserIdAsync(userPasswordPair.FirstValue.Id.GetValueOrDefault(), false, 30 * 60).ConfigureAwait(false);
clientConn.FileAccessToken = RandomExtensions.NextString(64);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateNewUserSegmentAsync(
userPasswordPair.FirstValue,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
ShortUser shortUser = new ShortUser
{
UserId = userPasswordPair.FirstValue.Id.GetValueOrDefault(),
PrivateData = segment.PrivateData
};
nodeNoticeService.SendNewUsersNodeNoticeAsync(shortUser, segment);
return(new TokensResponse(
request.RequestId,
userPasswordPair.FirstValue,
tempTokens.AccessToken,
tempTokens.RefreshToken,
clientConn.FileAccessToken,
userPasswordPair.SecondValue));
}
catch (CreateNewUserException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, ex.Message, ErrorCode.UnknownError));
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
object errorObject = null;
if (request.IsRegistration)
{
if (ValidationHelper.IsEmailValid(request.Uid))
{
if (await loadUsersService.IsEmailExistsAsync(request.Uid).ConfigureAwait(false))
{
errorObject = new
{
Email = $"Email {request.Uid} already exists."
};
}
}
else if (ValidationHelper.IsPhoneNumberValid(request.Uid))
{
if (await loadUsersService.IsPhoneExistsAsync(request.Uid).ConfigureAwait(false))
{
errorObject = new
{
Phone = $"Phone number {request.Uid} already exists."
};
}
}
}
else
{
if (ValidationHelper.IsEmailValid(request.Uid))
{
if (!await loadUsersService.IsEmailExistsAsync(request.Uid).ConfigureAwait(false))
{
errorObject = new
{
Email = $"Email {request.Uid} does not exists."
};
}
}
else if (ValidationHelper.IsPhoneNumberValid(request.Uid))
{
if (!await loadUsersService.IsPhoneExistsAsync(request.Uid).ConfigureAwait(false))
{
errorObject = new
{
Phone = $"Phone number {request.Uid} does not exists."
};
}
}
}
if (errorObject != null)
{
return(new ResultResponse(request.RequestId, errorObject.ToJson(), ErrorCode.WrongArgumentError));
}
short vCode = 0;
switch (request.VerificationType)
{
case VerificationType.Phone:
{
if (!NodeSettings.Configs.SmsServiceConfiguration.IsValid())
{
var error = new
{
VerificationType = "Server does not support the specified type of verification"
};
return(new ResultResponse(request.RequestId, error.ToJson(), ErrorCode.PermissionDenied));
}
if (await verificationCodesService.CanRequestSmsCodeAsync(DateTime.UtcNow.ToUnixTime(), request.Uid, clientConnection.UserId).ConfigureAwait(false))
{
vCode = await updateUsersService.CreateVCodeAsync(new UserPhoneVm()
{
FullNumber = request.Uid
}, request.RequestType, clientConnection.UserId).ConfigureAwait(false);
bool messageResult = await smsService.SendAsync(request.Uid, $"Verification code: {vCode.ToString()}").ConfigureAwait(false);
if (!messageResult)
{
throw new SendSmsException("Failed to send SMS.");
}
}
else
{
throw new SendingSmsIntervalNotExpired("The new SMS sending interval has not expired.");
}
}
break;
case VerificationType.Email:
{
if (NodeSettings.Configs.SmtpClient == null ||
string.IsNullOrWhiteSpace(NodeSettings.Configs.SmtpClient.Email) ||
string.IsNullOrWhiteSpace(NodeSettings.Configs.SmtpClient.Port) ||
string.IsNullOrWhiteSpace(NodeSettings.Configs.SmtpClient.Host) ||
string.IsNullOrWhiteSpace(NodeSettings.Configs.SmtpClient.Password))
{
var error = new
{
VerificationType = "Server does not support the specified type of verification"
};
return(new ResultResponse(request.RequestId, error.ToJson(), ErrorCode.PermissionDenied));
}
vCode = await updateUsersService.CreateVCodeAsync(request.Uid, clientConnection.UserId).ConfigureAwait(false);
EmailHandler.SendEmailAsync(request.Uid, vCode.ToString());
}
break;
default:
{
throw new UnknownVerificationTypeException($"Unknown verification type:{request.VerificationType}.");
}
}
return(new ResultResponse(request.RequestId));
}
catch (CreateVerificationCodeException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Phone, Email or UserID does not found.", ErrorCode.CreateVerificationCodeProblem));
}
catch (UserNotFoundException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "User not found.", ErrorCode.UserNotFound));
}
catch (SendSmsException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Failed to send SMS.", ErrorCode.SendVerificationCodeProblem));
}
catch (SendingSmsIntervalNotExpired ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "The new SMS sending interval has not expired.", ErrorCode.SendVerificationCodeProblem));
}
catch (UnknownVerificationTypeException ex)
{
Logger.WriteLog(ex, request);
var errorObject = new
{
VerificationType = "Wrong verification type"
};
return(new ResultResponse(request.RequestId, errorObject.ToJson(), ErrorCode.WrongArgumentError));
}
catch (Exception ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, "Internal server error.", ErrorCode.UnknownError));
}
}
