public async void ShouldValidateEmailWithEmailNotFound()
{
PrimitiveRequestResult <bool> primitiveRequestResult = new PrimitiveRequestResult <bool>()
{
ResourcePayload = false,
ResultStatus = ResultType.Error,
ResultError = null
};
Mock <IUserEmailService> emailServiceMock = new Mock <IUserEmailService>();
emailServiceMock.Setup(s => s.ValidateEmail(It.IsAny <string>(), It.IsAny <Guid>())).Returns(primitiveRequestResult);
Mock <IHttpContextAccessor> httpContextAccessorMock = CreateValidHttpContext(token, userId, hdid);
UserProfileController controller = new UserProfileController(
new Mock <ILogger <UserProfileController> >().Object,
null,
httpContextAccessorMock.Object,
emailServiceMock.Object,
null
);
IActionResult actualResult = await controller.ValidateEmail(hdid, Guid.NewGuid());
var result = ((JsonResult)actualResult).Value as PrimitiveRequestResult <bool>;
Assert.Equal(ResultType.Error, result.ResultStatus);
}
public async Task ShouldValidateAge()
{
string hdid = "1234567890123456789012345678901234567890123456789012";
string token = "Fake Access Token";
string userId = "1001";
UserProfile userProfile = new UserProfile
{
HdId = hdid,
AcceptedTermsOfService = true
};
PrimitiveRequestResult <bool> expected = new PrimitiveRequestResult <bool>()
{
ResultStatus = ResultType.Success, ResourcePayload = true
};
Mock <IHttpContextAccessor> httpContextAccessorMock = CreateValidHttpContext(token, userId, hdid);
Mock <IUserProfileService> userProfileServiceMock = new Mock <IUserProfileService>();
userProfileServiceMock.Setup(s => s.ValidateMinimumAge(hdid)).ReturnsAsync(expected);
UserProfileController controller = new UserProfileController(
new Mock <ILogger <UserProfileController> >().Object,
userProfileServiceMock.Object,
httpContextAccessorMock.Object,
new Mock <IUserEmailService>().Object,
new Mock <IUserSMSService>().Object
);
IActionResult actualResult = await controller.Validate(hdid);
Assert.IsType <JsonResult>(actualResult);
Assert.Equal(expected, ((JsonResult)actualResult).Value);
}
public async System.Threading.Tasks.Task ShouldValidateAgeAsync()
{
string hdid = "1234567890123456789012345678901234567890123456789012";
Mock <IConfigurationService> configServiceMock = new Mock <IConfigurationService>();
configServiceMock.Setup(s => s.GetConfiguration()).Returns(new ExternalConfiguration()
{
WebClient = new WebClientConfiguration()
{
MinPatientAge = 19
}
});
PatientModel patientModel = new PatientModel()
{
Birthdate = DateTime.Now.AddYears(-15)
};
Mock <IPatientService> patientServiceMock = new Mock <IPatientService>();
patientServiceMock
.Setup(s => s.GetPatient(hdid, PatientIdentifierType.HDID))
.ReturnsAsync(new RequestResult <PatientModel>
{
ResultStatus = ResultType.Success,
ResourcePayload = patientModel
});
IUserProfileService service = new UserProfileService(
new Mock <ILogger <UserProfileService> >().Object,
patientServiceMock.Object,
new Mock <IUserEmailService>().Object,
new Mock <IUserSMSService>().Object,
configServiceMock.Object,
new Mock <IEmailQueueService>().Object,
new Mock <INotificationSettingsService>().Object,
new Mock <IUserProfileDelegate>().Object,
new Mock <IUserPreferenceDelegate>().Object,
new Mock <ILegalAgreementDelegate>().Object,
new Mock <IMessagingVerificationDelegate>().Object,
new Mock <ICryptoDelegate>().Object,
new Mock <IHttpContextAccessor>().Object
);
PrimitiveRequestResult <bool> expected = new PrimitiveRequestResult <bool>()
{
ResultStatus = ResultType.Success, ResourcePayload = false
};
PrimitiveRequestResult <bool> actualResult = await service.ValidateMinimumAge(hdid);
Assert.Equal(ResultType.Success, actualResult.ResultStatus);
Assert.Equal(expected.ResourcePayload, actualResult.ResourcePayload);
}
public async Task <IActionResult> ValidateEmail(string hdid, Guid verificationKey)
{
HttpContext?httpContext = this.httpContextAccessor.HttpContext;
if (httpContext != null)
{
string?accessToken = await httpContext.GetTokenAsync("access_token").ConfigureAwait(true);
if (accessToken != null)
{
PrimitiveRequestResult <bool> result = this.userEmailService.ValidateEmail(hdid, verificationKey);
return(new JsonResult(result));
}
}
return(this.Unauthorized());
}
/// <inheritdoc />
public async Task <RequestResult <UserProfileModel> > CreateUserProfile(CreateUserRequest createProfileRequest, Uri hostUri, string bearerToken)
{
this.logger.LogTrace($"Creating user profile... {JsonSerializer.Serialize(createProfileRequest)}");
string registrationStatus = this.configurationService.GetConfiguration().WebClient.RegistrationStatus;
RequestResult <UserProfileModel> requestResult = new RequestResult <UserProfileModel>();
if (registrationStatus == RegistrationStatus.Closed)
{
requestResult.ResultStatus = ResultType.Error;
requestResult.ResultError = new RequestResultError()
{
ResultMessage = "Registration is closed", ErrorCode = ErrorTranslator.InternalError(ErrorType.InvalidState)
};
this.logger.LogWarning($"Registration is closed. {JsonSerializer.Serialize(createProfileRequest)}");
return(requestResult);
}
string hdid = createProfileRequest.Profile.HdId;
MessagingVerification?emailInvite = null;
if (registrationStatus == RegistrationStatus.InviteOnly)
{
if (!Guid.TryParse(createProfileRequest.InviteCode, out Guid inviteKey))
{
requestResult.ResultStatus = ResultType.Error;
requestResult.ResultError = new RequestResultError()
{
ResultMessage = "Invalid email invite", ErrorCode = ErrorTranslator.InternalError(ErrorType.InvalidState)
};
this.logger.LogWarning($"Invalid email invite code. {JsonSerializer.Serialize(createProfileRequest)}");
return(requestResult);
}
emailInvite = this.emailInviteDelegate.GetByInviteKey(inviteKey);
bool hdidIsValid = string.IsNullOrEmpty(emailInvite?.HdId) || (emailInvite?.HdId == createProfileRequest.Profile.HdId);
// Fails if...
// Email invite not found or
// Email invite was already validated or
// Email's recipient is not found
// Email invite must have a blank/null HDID or be the same as the one in the request
// Email address doesn't match the invite
if (emailInvite == null || (emailInvite.Email == null || emailInvite.Email.To == null ||
emailInvite.Validated || !hdidIsValid ||
!emailInvite.Email.To.Equals(createProfileRequest.Profile.Email, StringComparison.OrdinalIgnoreCase)))
{
requestResult.ResultStatus = ResultType.Error;
requestResult.ResultError = new RequestResultError()
{
ResultMessage = "Invalid email invite", ErrorCode = ErrorTranslator.InternalError(ErrorType.InvalidState)
};
this.logger.LogWarning($"Invalid email invite. {JsonSerializer.Serialize(createProfileRequest)}");
return(requestResult);
}
}
PrimitiveRequestResult <bool> isMimimunAgeResult = await this.ValidateMinimumAge(hdid).ConfigureAwait(true);
if (isMimimunAgeResult.ResultStatus != ResultType.Success)
{
requestResult.ResultStatus = isMimimunAgeResult.ResultStatus;
requestResult.ResultError = isMimimunAgeResult.ResultError;
return(requestResult);
}
else if (!isMimimunAgeResult.ResourcePayload)
{
requestResult.ResultStatus = ResultType.Error;
requestResult.ResultError = new RequestResultError()
{
ResultMessage = "Patient under minimum age", ErrorCode = ErrorTranslator.InternalError(ErrorType.InvalidState)
};
this.logger.LogWarning($"Patient under minimum age. {JsonSerializer.Serialize(createProfileRequest)}");
return(requestResult);
}
string? requestedSMSNumber = createProfileRequest.Profile.SMSNumber;
string? requestedEmail = createProfileRequest.Profile.Email;
UserProfile newProfile = createProfileRequest.Profile;
newProfile.Email = string.Empty;
newProfile.SMSNumber = null;
newProfile.CreatedBy = hdid;
newProfile.UpdatedBy = hdid;
newProfile.EncryptionKey = this.cryptoDelegate.GenerateKey();
DBResult <UserProfile> insertResult = this.userProfileDelegate.InsertUserProfile(newProfile);
if (insertResult.Status == DBStatusCode.Created)
{
// Update the notification settings
NotificationSettingsRequest notificationRequest = this.UpdateNotificationSettings(newProfile, requestedSMSNumber);
if (emailInvite != null)
{
// Validates the invite email
emailInvite.Validated = true;
emailInvite.HdId = hdid;
this.emailInviteDelegate.Update(emailInvite);
}
if (!string.IsNullOrWhiteSpace(requestedEmail))
{
this.emailQueueService.QueueNewInviteEmail(hdid, requestedEmail, hostUri);
}
if (!string.IsNullOrWhiteSpace(requestedSMSNumber))
{
this.logger.LogInformation($"Sending sms invite for user ${hdid}");
MessagingVerification messagingVerification = new MessagingVerification();
messagingVerification.HdId = hdid;
messagingVerification.SMSNumber = requestedSMSNumber;
messagingVerification.SMSValidationCode = notificationRequest.SMSVerificationCode;
messagingVerification.VerificationType = MessagingVerificationType.SMS;
messagingVerification.ExpireDate = DateTime.MaxValue;
this.messageVerificationDelegate.Insert(messagingVerification);
}
requestResult.ResourcePayload = UserProfileModel.CreateFromDbModel(insertResult.Payload);
requestResult.ResultStatus = ResultType.Success;
}
this.logger.LogDebug($"Finished creating user profile. {JsonSerializer.Serialize(insertResult)}");
return(requestResult);
}
public async Task <IActionResult> Validate(string hdid)
{
PrimitiveRequestResult <bool> result = await this.userProfileService.ValidateMinimumAge(hdid).ConfigureAwait(true);
return(new JsonResult(result));
}
/// <inheritdoc />
public async Task <RequestResult <UserProfileModel> > CreateUserProfile(CreateUserRequest createProfileRequest, DateTime jwtAuthTime)
{
this.logger.LogTrace($"Creating user profile... {JsonSerializer.Serialize(createProfileRequest)}");
string registrationStatus = this.configurationService.GetConfiguration().WebClient.RegistrationStatus;
if (registrationStatus == RegistrationStatus.Closed)
{
this.logger.LogWarning($"Registration is closed. {JsonSerializer.Serialize(createProfileRequest)}");
return(new RequestResult <UserProfileModel>()
{
ResultStatus = ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = "Registration is closed",
ErrorCode = ErrorTranslator.InternalError(ErrorType.InvalidState),
},
});
}
// Validate registration age
string hdid = createProfileRequest.Profile.HdId;
PrimitiveRequestResult <bool> isMimimunAgeResult = await this.ValidateMinimumAge(hdid).ConfigureAwait(true);
if (isMimimunAgeResult.ResultStatus != ResultType.Success)
{
return(new RequestResult <UserProfileModel>()
{
ResultStatus = isMimimunAgeResult.ResultStatus,
ResultError = isMimimunAgeResult.ResultError,
});
}
else if (!isMimimunAgeResult.ResourcePayload)
{
this.logger.LogWarning($"Patient under minimum age. {JsonSerializer.Serialize(createProfileRequest)}");
return(new RequestResult <UserProfileModel>()
{
ResultStatus = ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = "Patient under minimum age",
ErrorCode = ErrorTranslator.InternalError(ErrorType.InvalidState),
},
});
}
// Create profile
UserProfile newProfile = new ()
{
HdId = hdid,
IdentityManagementId = createProfileRequest.Profile.IdentityManagementId,
AcceptedTermsOfService = createProfileRequest.Profile.AcceptedTermsOfService,
Email = string.Empty,
SMSNumber = null,
CreatedBy = hdid,
UpdatedBy = hdid,
LastLoginDateTime = jwtAuthTime,
EncryptionKey = this.cryptoDelegate.GenerateKey(),
};
DBResult <UserProfile> insertResult = this.userProfileDelegate.InsertUserProfile(newProfile);
if (insertResult.Status == DBStatusCode.Created)
{
UserProfile createdProfile = insertResult.Payload;
string? requestedSMSNumber = createProfileRequest.Profile.SMSNumber;
string? requestedEmail = createProfileRequest.Profile.Email;
// Add email verification
if (!string.IsNullOrWhiteSpace(requestedEmail))
{
this.userEmailService.CreateUserEmail(hdid, requestedEmail);
}
// Add SMS verification
if (!string.IsNullOrWhiteSpace(requestedSMSNumber))
{
this.userSMSService.CreateUserSMS(hdid, requestedSMSNumber);
}
this.notificationSettingsService.QueueNotificationSettings(new NotificationSettingsRequest(createdProfile, requestedEmail, requestedSMSNumber));
this.logger.LogDebug($"Finished creating user profile. {JsonSerializer.Serialize(insertResult)}");
return(new RequestResult <UserProfileModel>()
{
ResourcePayload = UserProfileModel.CreateFromDbModel(insertResult.Payload),
ResultStatus = ResultType.Success,
});
}
else
{
this.logger.LogError($"Error creating user profile. {JsonSerializer.Serialize(insertResult)}");
return(new RequestResult <UserProfileModel>()
{
ResultStatus = ResultType.Error,
ResultError = new RequestResultError()
{
ResultMessage = insertResult.Message,
ErrorCode = ErrorTranslator.ServiceError(ErrorType.CommunicationInternal, ServiceType.Database),
},
});
}
}
