public async Task Set_Failed_Invalid_QuestionId()
{
var questionnaire = await BL.GetQuestionnaireTemplate_ActiveByTypeAndGender(QuestionnaireTemplate.QuestionnaireType.OnBoarding, "m");
var userProfileId = await BL.GetCachedUserId_byExternalReferenceIdAsync(SeededUserExtRefId);
var userQuestionnaire = new UserQuestionnaire
{
UserprofileId = userProfileId,
QuestionnaireTemplateId = questionnaire.Id,
Answers = new List <UserQuestionnaire.Answer>
{
new UserQuestionnaire.Answer
{
QuestionId = "invalid question Id",// questionnaire.QuestionnaireSets.First().Questions.First().Id,
Value = "7"
}
}
};
var ex = await Assert.ThrowsAsync <BusinessLogicException>(async() => await BL.SetUserQuestionniareAsync(userQuestionnaire));
Assert.Equal(ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers, ex.ErrorCode);
Assert.Equal(userQuestionnaire.Id, ex.EntityIdInError);
Assert.StartsWith("Question Id:invalid question Id in UserQuestionnaire with Id: does not exist in QuestionnaireTemplate with Id", ex.DebugMessage);
}
public async Task <string> SetUserQuestionnaireAsync(UserQuestionnaire entity)
{
//assuming all data is Validated prior to calling this method
string idUpdatedOrCreated;
SetEntityType(entity);
if (string.IsNullOrEmpty(entity.Id))
{
//New item
var up = await client.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(_settings.DatabaseId, _settings.DefaultCollectionId), entity);
var newlyCreatedUserQuestionnaire = (UserQuestionnaire)(dynamic)up.Resource;
idUpdatedOrCreated = newlyCreatedUserQuestionnaire.Id;
}
else
{
//existing item
Document document = await client.ReadDocumentAsync(UriFactory.CreateDocumentUri(_settings.DatabaseId, _settings.DefaultCollectionId, entity.Id)); // will throw an exception if item not exists
var existingItem = (UserQuestionnaire)(dynamic)document;
document.LoadFromExisingEntity(entity);
Document updated = await client.ReplaceDocumentAsync(document);
idUpdatedOrCreated = existingItem.Id;
}
return(idUpdatedOrCreated);
}
public async Task Set_Failed_UserId()
{
var v = new Validator(phoneService);
var questionnaire = await BL.GetQuestionnaireTemplate_ActiveByTypeAndGender(QuestionnaireTemplate.QuestionnaireType.OnBoarding, "m");
var userProfileId = "123-invalidUserProfileId";
var userQuestionnaire = new UserQuestionnaire
{
QuestionnaireTemplateId = questionnaire.Id,
UserprofileId = userProfileId,
Answers = new List <UserQuestionnaire.Answer>
{
new UserQuestionnaire.Answer
{
QuestionId = questionnaire.QuestionnaireSets.First().Questions.First().Id,
Value = "7"
}
}
};
var ex = await Assert.ThrowsAsync <BusinessLogicException>(async() => await BL.SetUserQuestionniareAsync(userQuestionnaire));
Assert.Equal(ValidationErrorCode.UserProfileIdNotFound, ex.ErrorCode);
Assert.Equal(userProfileId, ex.EntityIdInError);
}
public async Task Set_Failed_Invalid_AnswerRange()
{
var questionnaire = await BL.GetQuestionnaireTemplate_ActiveByTypeAndGender(QuestionnaireTemplate.QuestionnaireType.OnBoarding, "m");
var userProfileId = await BL.GetCachedUserId_byExternalReferenceIdAsync(SeededUserExtRefId);
//Check so the fist question is of expected type
var firstQuestion = questionnaire.QuestionnaireSets.First().Questions.First();
Assert.Equal(Question.QuestionType.Range, firstQuestion.TypeOfQuestion);
var userQuestionnaire = new UserQuestionnaire
{
UserprofileId = userProfileId,
QuestionnaireTemplateId = questionnaire.Id,
Answers = new List <UserQuestionnaire.Answer>
{
new UserQuestionnaire.Answer
{
QuestionId = firstQuestion.Id,
Value = "99"
}
}
};
var ex = await Assert.ThrowsAsync <BusinessLogicException>(async() => await BL.SetUserQuestionniareAsync(userQuestionnaire));
Assert.Equal(ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers_InvalidValue, ex.ErrorCode);
Assert.Equal(userQuestionnaire.Id, ex.EntityIdInError);
Assert.StartsWith("The value '99' for Question Id", ex.DebugMessage);
Assert.EndsWith(" is out of range, valid range is '0' to '10'", ex.DebugMessage);
}
/// <summary>
/// to be used within web api controller(s)
/// </summary>
/// <param name="bL_QuestionnaireAnswers"></param>
/// <returns></returns>
public async Task <string> SetUserQuestionnaireAsync(BL_QuestionnaireAnswers bL_QuestionnaireAnswers)
{
var userQuestionnaire = new UserQuestionnaire
{
UserprofileId = bL_QuestionnaireAnswers.UserprofileId,
QuestionnaireTemplateId = bL_QuestionnaireAnswers.QuestionnaireTemplateId,
Answers = new List <UserQuestionnaire.Answer>()
};
foreach (var answer in bL_QuestionnaireAnswers.Answers)
{
if (answer.ChildAnswer != null)
{
throw new BusinessLogicException(ValidationErrorCode.ValidationCannotBeCompleted, bL_QuestionnaireAnswers.QuestionnaireTemplateId,
$"An Answer for Question id '{answer.QuestionId}' for QuestionnaireTemplate id '{bL_QuestionnaireAnswers.QuestionnaireTemplateId}' for user id '{bL_QuestionnaireAnswers.UserprofileId}' contains a Child answer, which is not yet supported.");
}
userQuestionnaire.Answers.Add(new UserQuestionnaire.Answer
{
QuestionId = answer.QuestionId,
Value = answer.Value
});
}
var result = await SetUserQuestionniareAsync(userQuestionnaire);
return(result);
}
public async Task Set_Failed_UserIdNull()
{
var questionnaireTemplateId = "123-invalidQuestionnaireId";
var userQuestionnaire = new UserQuestionnaire
{
QuestionnaireTemplateId = questionnaireTemplateId,
};
var ex = await Assert.ThrowsAsync <BusinessLogicException>(async() => await BL.SetUserQuestionniareAsync(userQuestionnaire));
Assert.Equal(ValidationErrorCode.IdIsNull_UserProfileId, ex.ErrorCode);
Assert.Equal(userQuestionnaire.Id, ex.EntityIdInError);
Assert.Equal("One or more Ids in instance of type 'LifeCouple.DAL.Entities.UserQuestionnaire' is null.", ex.DebugMessage);
Assert.Equal(ex.EntityJsonRepresentation, ex.Result.Failures.First().EntityJsonRepresentation);
}
private void SortQuestionsAccordingToQuestionnaireTemplate(UserQuestionnaire _userQ, QuestionnaireTemplate _questionnaireT)
{
var answers = new List <UserQuestionnaire.Answer>(_userQ.Answers);
_userQ.Answers.Clear();
foreach (var set in _questionnaireT.QuestionnaireSets)
{
foreach (var q in set.Questions)
{
if (answers.Exists(e => e.QuestionId == q.Id))
{
_userQ.Answers.Add(answers.Single(e1 => e1.QuestionId == q.Id));
}
}
}
answers.Clear();
}
public async Task Set_Failed_Validation_NoAnswers()
{
var v = new Validator(phoneService);
var questionnaireTemplateId = await BL.GetQuestionnaireTemplate_ActiveByTypeAndGender(QuestionnaireTemplate.QuestionnaireType.OnBoarding, "m");
var userProfileId = "123-invalidUserProfileId";
var userQuestionnaire = new UserQuestionnaire
{
QuestionnaireTemplateId = questionnaireTemplateId.Id,
UserprofileId = userProfileId,
};
var ex = await Assert.ThrowsAsync <BusinessLogicException>(async() => await BL.SetUserQuestionniareAsync(userQuestionnaire));
Assert.Equal(ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers, ex.ErrorCode);
Assert.Null(ex.EntityIdInError);
Assert.Equal("Need at least one Answer for instance of type 'LifeCouple.DAL.Entities.UserQuestionnaire'.", ex.DebugMessage);
}
public void ValidateUserQuestionnaire(UserQuestionnaire entity, ValidationResult validation)
{
var idIsNullMsg = $"One or more Ids in instance of type '{entity.GetType()}' is null.";
if (string.IsNullOrWhiteSpace(entity.UserprofileId))
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.IdIsNull_UserProfileId,
DebugMessage = idIsNullMsg,
EntityJsonRepresentation = GetJson(entity),
EntityIdInError = entity.Id,
});
}
if (string.IsNullOrWhiteSpace(entity.QuestionnaireTemplateId))
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.IdIsNull_QuestionnaireTemplateId,
DebugMessage = idIsNullMsg,
EntityJsonRepresentation = GetJson(entity),
EntityIdInError = entity.Id,
});
}
if (entity.Answers == null || entity.Answers.Count == 0)
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers,
DebugMessage = $"Need at least one Answer for instance of type '{entity.GetType()}'.",
EntityJsonRepresentation = GetJson(entity),
EntityIdInError = entity.Id,
});
}
}
public async Task <bool> Create(UserQuestionnaire entity)
{
await _context.UserQuestionnaires.AddAsync(entity);
return(await Save());
}
public void ValidateUserQuestionnaire(UserQuestionnaire entity, QuestionnaireTemplate questionnaireTemplate, ValidationResult validation)
{
if (validation.IsValid == false)
{
return;
}
if (questionnaireTemplate == null)
{
validation.Failures.Add(new ValidationFailure {
Code = ValidationErrorCode.QuestionnaireTemplateIdNotFound, EntityIdInError = entity.QuestionnaireTemplateId, EntityJsonRepresentation = Validator.GetJson(entity)
});
return;
}
if (entity.IsQuestionnaireTemplateComplete)
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationFailure_UserQuestionnaire,
EntityIdInError = entity.Id,
DebugMessage = $"UserQuestionnaire with Id:{entity.Id} for QuestionnaireTemplate with Id:{questionnaireTemplate.Id} can not be updated since it is already Completed",
EntityJsonRepresentation = Validator.GetJson(entity)
});
}
if (questionnaireTemplate.QuestionnaireSets.Count > 1)
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationCannotBeCompleted,
EntityIdInError = entity.Id,
DebugMessage = $"UserQuestionnaire with Id:{entity.Id} for QuestionnaireTemplate with Id:{questionnaireTemplate.Id} have more than 1 QuestionnaireSets and there is no validation implemented for that yet",
EntityJsonRepresentation = Validator.GetJson(entity)
});
}
if (entity.Answers != null)
{
foreach (var answer in entity.Answers)
{
var question = questionnaireTemplate.QuestionnaireSets.First().Questions.SingleOrDefault(e => e.Id == answer.QuestionId);
//check if questionid exists in template
if (question == null)
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers,
EntityIdInError = entity.Id,
DebugMessage = $"Question Id:{answer.QuestionId} in UserQuestionnaire with Id:{entity.Id} does not exist in QuestionnaireTemplate with Id:{questionnaireTemplate.Id}",
EntityJsonRepresentation = Validator.GetJson(entity)
});
}
//exists, so check if value is valid
else
{
switch (question.TypeOfQuestion)
{
case Question.QuestionType.Range:
int intValue;
if (int.TryParse(answer.Value, out intValue))
{
if (false == (intValue >= question.MinRange.Value && intValue <= question.MaxRange.Value))
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers_InvalidValue,
EntityIdInError = entity.Id,
DebugMessage = $"The value '{answer.Value}' for Question Id:{question.Id} in UserQuestionnaire with Id:{entity.Id} for QuestionnaireTemplate with Id:{questionnaireTemplate.Id} is out of range, valid range is '{question.MinRange}' to '{question.MaxRange}'",
EntityJsonRepresentation = Validator.GetJson(entity)
});
}
}
else
{
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationFailure_UserQuestionnaire_Answers_InvalidValue,
EntityIdInError = entity.Id,
DebugMessage = $"The value '{answer.Value}' for Question Id:{question.Id} in UserQuestionnaire with Id:{entity.Id} for QuestionnaireTemplate with Id:{questionnaireTemplate.Id} is invalid, valid range is '{question.MinRange}' to '{question.MaxRange}'",
EntityJsonRepresentation = Validator.GetJson(entity)
});
}
break;
default:
validation.Failures.Add(new ValidationFailure
{
Code = ValidationErrorCode.ValidationCannotBeCompleted,
EntityIdInError = entity.Id,
DebugMessage = $"Question Id:{question.Id} is of type '{question.TypeOfQuestion}' in QuestionnaireTemplate with Id:{questionnaireTemplate.Id} and there is no validation implemented for that yet",
EntityJsonRepresentation = Validator.GetJson(entity)
});
break;
}
}
}
}
}
public async Task Set()
{
var questionnaire = await BL.GetQuestionnaireTemplate_ActiveByTypeAndGender(QuestionnaireTemplate.QuestionnaireType.OnBoarding, "m");
var userProfileId = await BL.GetCachedUserId_byExternalReferenceIdAsync(SeededUserExtRefId);
var userQuestionnaire = new UserQuestionnaire
{
UserprofileId = userProfileId,
QuestionnaireTemplateId = questionnaire.Id,
Answers = new List <UserQuestionnaire.Answer>
{
new UserQuestionnaire.Answer
{
QuestionId = questionnaire.QuestionnaireSets.First().Questions.First().Id,
Value = "7"
}
}
};
var newlyCreatedId = await BL.SetUserQuestionniareAsync(userQuestionnaire);
//Update existing
userQuestionnaire.Id = newlyCreatedId;
userQuestionnaire.Answers.First().Value = "6";
userQuestionnaire.Answers.Add(new UserQuestionnaire.Answer
{
QuestionId = questionnaire.QuestionnaireSets.First().Questions.Skip(1).First().Id,
Value = "8"
});
var updatedId = await BL.SetUserQuestionniareAsync(userQuestionnaire);
Assert.Equal(newlyCreatedId, updatedId);
//Update existing again
userQuestionnaire.Id = newlyCreatedId;
userQuestionnaire.Answers.Clear();
userQuestionnaire.Answers.Add(new UserQuestionnaire.Answer
{
QuestionId = questionnaire.QuestionnaireSets.First().Questions.Skip(1).First().Id,
Value = "1"
});
userQuestionnaire.Answers.Add(new UserQuestionnaire.Answer
{
QuestionId = questionnaire.QuestionnaireSets.First().Questions.Skip(2).First().Id,
Value = "2"
});
updatedId = await BL.SetUserQuestionniareAsync(userQuestionnaire);
Assert.Equal(newlyCreatedId, updatedId);
var uq = await BL.GetUserQuestionnaire_ByUserIdAsync(userProfileId, QuestionnaireTemplate.QuestionnaireType.OnBoarding);
Assert.Equal(newlyCreatedId, uq.Id);
Assert.Equal(QuestionnaireTemplate.QuestionnaireType.OnBoarding, uq.QuestionnaireTemplateType);
Assert.Equal(userQuestionnaire.QuestionnaireTemplateId, uq.QuestionnaireTemplateId);
Assert.Equal(userQuestionnaire.Answers.Count + 1, uq.Answers.Count);
Assert.Equal(userQuestionnaire.Answers[0].QuestionId, uq.Answers[1].QuestionId);
Assert.Equal(userQuestionnaire.Answers[1].QuestionId, uq.Answers[2].QuestionId);
Assert.Equal(questionnaire.QuestionnaireSets[0].Questions[2].Id, uq.Answers[2].QuestionId);
Assert.Equal(questionnaire.Id, uq.QuestionnaireTemplateId);
var user = await BL.GetUserProfile_byExtRefIdAsync(SeededUserExtRefId);
}
public async Task <bool> Delete(UserQuestionnaire entity)
{
_context.UserQuestionnaires.Remove(entity);
return(await Save());
}
public Task <string> SetUserQuestionnaireAsync(UserQuestionnaire entity)
{
throw new NotImplementedException();
}
public async Task <QuestionnaireTemplate> GetQuestionnaireTemplate_ByUserQuestionnaire(UserQuestionnaire uq, QuestionnaireTemplate.QuestionnaireType questionnaireType, string gender)
{
QuestionnaireTemplate r;
if (uq == null)
{
r = await GetQuestionnaireTemplate_ActiveByTypeAndGender(questionnaireType, gender);
}
else
{
if (string.IsNullOrEmpty(uq.QuestionnaireTemplateId))
{
throw new BusinessLogicException(ValidationErrorCode.IdIsNull_QuestionnaireTemplateId, uq.Id, $"QuestionnaireTemplate Id in UserQuestionnaire with Id '{uq.Id}' is null");
}
else
{
r = await _repo.GetQuestionnaireTemplate_ByIdAsync(uq.QuestionnaireTemplateId);
if (r == null)
{
throw new BusinessLogicException(ValidationErrorCode.EntityIsNull, uq.Id, $"QuestionnaireTemplate Id '{uq.QuestionnaireTemplateId}' in UserQuestionnaire with Id '{uq.Id}' can not be found in repo.");
}
}
}
return(r);
}
/// <summary>
/// Return id updated or created
/// </summary>
/// <param name="userQuestionnaire"></param>
/// <returns></returns>
public async Task <string> SetUserQuestionniareAsync(UserQuestionnaire userQuestionnaire)
{
var userQ = DeepClone(userQuestionnaire); //Don't want to work with the passed in variable
var validationResult = validator.Validate(userQ);
UserQuestionnaire existingUserQ = null;
//Get existing template
var questionnaireTemplate = await _repo.GetQuestionnaireTemplate_ByIdAsync(userQ.QuestionnaireTemplateId);
validator.ValidateUserQuestionnaire(userQ, questionnaireTemplate, validationResult);
//Get existing user questionnaire since the incoming payload may only contain 1 question and there might already be a bunch saved, or this is the first one
if (validationResult.IsValid)
{
existingUserQ = await _repo.GetUserQuestionnaire_ByUserIdAsync(userQ.UserprofileId, questionnaireTemplate.TypeOfQuestionnaire, questionnaireTemplate.Id);
if (existingUserQ == null)
{
if (await _repo.GetUserProfile_byIdAsync(userQ.UserprofileId) == null)
{
validationResult.Failures.Add(new ValidationFailure {
Code = ValidationErrorCode.UserProfileIdNotFound, EntityIdInError = userQ.UserprofileId, EntityJsonRepresentation = Validator.GetJson(userQ)
});
}
}
else
{
validator.ValidateUserQuestionnaire(existingUserQ, questionnaireTemplate, validationResult);
}
}
//Merge existing item with incoming userQuestionnaire
if (validationResult.IsValid && existingUserQ != null)
{
foreach (var existingAnswer in existingUserQ.Answers)
{
if (userQ.Answers.FirstOrDefault(e => e.QuestionId == existingAnswer.QuestionId) == null)
{
userQ.Answers.Add(existingAnswer);
}
}
SortQuestionsAccordingToQuestionnaireTemplate(userQ, questionnaireTemplate);
}
//Set/replace/create existing in Repo
if (validationResult.IsValid)
{
//if all questions answered then mark as Complete, to not allow further updates
if (questionnaireTemplate.GetNrOfQuestionsEx() == userQ.Answers.Count)
{
userQ.IsQuestionnaireTemplateComplete = true;
}
userQ.Id = existingUserQ?.Id;
var utcNow = DateTimeOffset.UtcNow;
userQ.DTCreated = existingUserQ?.DTCreated ?? utcNow;
userQ.DTLastUpdated = utcNow;
userQ.QuestionnaireTemplateType = questionnaireTemplate.TypeOfQuestionnaire;
var idUpdatedOrCreated = await _repo.SetUserQuestionnaireAsync(userQ);
if (userQ.IsQuestionnaireTemplateComplete)
{
await SetUserIndexes(questionnaireTemplate, userQ.UserprofileId);
}
return(idUpdatedOrCreated);
}
else
{
throw new BusinessLogicException(validationResult);
}
}
public Task <bool> Update(UserQuestionnaire entity)
{
throw new NotImplementedException();
}
