public static void SurveyMap(this SurveyDTO dbSurvey, SurveyDTO survey)
{
dbSurvey.UserID = survey.UserID;
dbSurvey.IsActive = survey.IsActive;
dbSurvey.Language = survey.Language;
dbSurvey.Questions = survey.Questions;
}
private SurveyDTO GetSurveyDTO(int categoryId)
{
var survey = this.modelContext
.Surveys
.Include("Category")
.Include("Questions")
.Where(x => x.Category.Id == categoryId)
.OrderByDescending(x => x.Id)
.FirstOrDefault();
var questions = survey.Questions
.Select(question => new SurveyQuestionDTO
{
QuestionId = question.Id,
Question = question.DemandQuestion
})
.ToList();
var surveyDTO = new SurveyDTO
{
CategoryId = survey.Category.Id,
SurveyId = survey.Id,
SurveyQuestionDTOs = questions,
QuestionCount = questions.Count()
};
return(surveyDTO);
}
public async void ChangeSurvey_ValidObjectPassed_ReturnsOk()
{
// Arrange
var mock = new Mock <ISurveyService>();
mock.Setup(s => s.UpdateAsync(It.IsAny <int>(), It.IsAny <SurveyDTO>())).Returns((int id, SurveyDTO s) => FakeServicesMethods.ChangeSurvey(id, s));
var controller = new SurveyController(mock.Object);
// Act
var survey = new SurveyDTO
{
Id = 1,
Creator = "John",
Date = DateTime.Now,
Views = 3,
Title = "Survey 1",
Questions = new List <QuestionDTO>()
};
var result = await controller.ChangeSurvey(1, survey);
var okResult = result as OkObjectResult;
// Assert
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
}
public async void ChangeSurvey_ValidObjectPassed_ReturnedResponseHaUpdatedItem()
{
// Arrange
var mock = new Mock <ISurveyService>();
mock.Setup(s => s.UpdateAsync(It.IsAny <int>(), It.IsAny <SurveyDTO>())).Returns((int id, SurveyDTO s) => FakeServicesMethods.ChangeSurvey(id, s));
var controller = new SurveyController(mock.Object);
// Act
var survey = new SurveyDTO
{
Id = 1,
Creator = "John",
Date = DateTime.Now,
Views = 3,
Title = "Survey 1",
Questions = new List <QuestionDTO>()
};
var result = await controller.ChangeSurvey(1, survey);
var okResult = result as OkObjectResult;
// Assert
var item = Assert.IsAssignableFrom <SurveyDTO>(okResult.Value);
Assert.Equal(1, (okResult.Value as SurveyDTO)?.Id);
}
public void MakeCorrections(SurveyDTO surveyDTO)
{
var survey = this.GetSurvey();
if (survey == null)
{
throw new InvalidOperationException();
}
survey.Title = surveyDTO.Title;
survey.Description = surveyDTO.Description;
foreach (QuestionDTO question in surveyDTO.Questions)
{
var originalQuestion = survey.Questions.FirstOrDefault(q => q.Id == question.Id);
if (originalQuestion == null)
{
continue;
}
originalQuestion.Text = question.Text;
foreach (AnswerDTO answer in question.Answers)
{
var originalAnswer = originalQuestion.Answers.FirstOrDefault(a => a.Id == answer.Id);
if (originalAnswer == null)
{
continue;
}
originalAnswer.Text = answer.Text;
}
}
this.Context.SaveChanges();
}
public IHttpActionResult Post([FromBody] SurveyDTO surveyDTO)
{
if (surveyDTO == null)
{
return(BadRequest("Request is null"));
}
Survey entity = new Survey
{
Title = surveyDTO.Title,
Description = surveyDTO.Description,
CreatedDate = surveyDTO.CreatedDate,
ModifiedDate = null,
IsActive = true,
StatusId = surveyDTO.StatusId,
//Status = surveyDTO.Status
};
int id = _service.Create(entity);
if (id <= 0)
{
return(BadRequest("unable to create entity."));
}
var payload = new { Id = id };
return(Ok(payload));
}
public async Task <IActionResult> Update(int id, [FromBody] SurveyDTO item)
{
if (item == null || item.Id != id)
{
return(HttpBadRequest());
}
if (!ModelState.IsValid)
{
return(HttpBadRequest(ModelState));
}
var survey = await _surveyStore.GetSurveyAsync(id);
if (survey == null)
{
return(HttpNotFound());
}
// Validate that the current user has Update permissions to this survey.
if (!await _authorizationService.AuthorizeAsync(User, survey, Operations.Update))
{
return(new HttpStatusCodeResult((int)HttpStatusCode.Forbidden));
}
// Apply update
survey.Title = item.Title;
survey.Published = item.Published;
await _surveyStore.UpdateSurveyAsync(survey);
return(new ObjectResult(DataMapping._surveyToDto(survey)));
}
public void AddSurvey(SurveyDTO survey)
{
var id = GetSurveys().Max(m => m.Id) + 1;
survey.Id = id;
MockSurveyData.Current.Surveys.Add(survey);
}
public async Task <Survey> SaveToDB(SurveyDTO model)
{
Survey s = mapper.Map <Survey>(model);
await _surveysRepository.Add(s);
return(s);
}
//note that SurveyDTO is being passed in for HTTP POST
public async Task <int> AddSurveyQuestionDetail(SurveyDTO survey)
{
var proc = "[test].[usp_SurveyDetail_Add] @p0;";
var results = await _context.Database
.ExecuteSqlCommandAsync(proc, survey.Id);
return(results);
}
public async static Task <SurveyDTO> ChangeSurvey(int id, SurveyDTO survey)
{
if (survey != null)
{
survey.Id = id;
}
return(survey);
}
private SurveyDTO ConvertQuizAndGetServiceResponse(
SurveyDTO surveyDTO,
Survey survey,
SurveyModel model)
{
survey = ConvertDto(surveyDTO, survey);
model.RegisterSave(survey, true);
return(new SurveyDTO(survey));
}
public ValidateSurveyDTO Validate(SurveyDTO survey)
{
if (survey == null)
{
throw new ArgumentNullException("survey");
}
return(new SurveyValidator(survey, this.surveyRepository.GetSurvey(), this.userAnswerRepository.HasAnyoneCompleted(survey.Id)).Validate());
}
public HttpResponseMessage Validate(SurveyDTO survey)
{
if (surveyService == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
return(Request.CreateResponse(HttpStatusCode.OK, this.surveyService.Validate(survey)));
}
public async Task <ApiResult <SurveyDTO> > UpdateSurveyAsync(SurveyDTO survey)
{
var path = $"/surveys/{survey.Id}";
var response = await _httpClient.SendRequestWithBearerTokenAsync(HttpMethod.Put, path, survey,
await _surveysTokenService.GetTokenForWebApiAsync(_httpContextAccessor.HttpContext.User)
.ConfigureAwait(false), _cancellationToken);
return(await ApiResult <SurveyDTO> .FromResponseAsync(response).ConfigureAwait(false));
}
public void tblSurvey_insert(SurveyDTO dt)
{
SqlCommand cmd = new SqlCommand("INSERT INTO tblSurvey(Name, Description, MailConfigID) VALUES(@Name, @Description, @MailConfigID)", ConnectionData._MyConnection);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("@Name", SqlDbType.NVarChar).Value = dt.Name;
cmd.Parameters.Add("@Description", SqlDbType.NVarChar).Value = dt.Description;
cmd.Parameters.Add("@MailConfigID", SqlDbType.Int).Value = dt.MailConfigID;
cmd.ExecuteNonQuery();
cmd.Dispose();
}
public HttpResponseMessage UpdateSurvey(SurveyDTO survey)
{
if (survey == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
this.surveyService.Save(survey);
return(Request.CreateResponse(HttpStatusCode.OK, this.surveyService.GetSurvey(base.AuthenticatedUser.Id)));
}
public async Task <IActionResult> AddSurvey([FromBody] SurveyDTO survey)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var result = await service.AddAsync(survey);
return(result != null?Ok(result) as IActionResult : BadRequest() as IActionResult);
}
public void DeleteSurvey(SurveyDTO survey)
{
var surveyToDelete = _db.Survey.FirstOrDefault(p =>
p.Id.Equals(survey.Id));
if (surveyToDelete != null)
{
_db.Survey.Remove(surveyToDelete);
}
}
public void tblSurvey_Update(SurveyDTO dt)
{
SqlCommand cmd = new SqlCommand("UPDATE tblSurvey SET Name = @Name, Description = @Description, MailConfigID=@MailConfigID WHERE Id = @Id", ConnectionData._MyConnection);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("@Id", SqlDbType.Int).Value = dt.Id;
cmd.Parameters.Add("@Name", SqlDbType.NVarChar).Value = dt.Name;
cmd.Parameters.Add("@Description", SqlDbType.NVarChar).Value = dt.Description;
cmd.Parameters.Add("@MailConfigID", SqlDbType.Int).Value = dt.MailConfigID;
cmd.ExecuteNonQuery();
cmd.Dispose();
}
public async Task <IActionResult> ChangeSurvey(int id, [FromBody] SurveyDTO survey)
{
if (!ModelState.IsValid)
{
return(BadRequest() as IActionResult);
}
var result = await service.UpdateAsync(id, survey);
return(result != null?Ok(result) as IActionResult : BadRequest() as IActionResult);
}
//Get surveys for study coordinator
public IList <SurveyDTO> GetSurveysForStudyCoordinator(string coordinatorId)
{
List <SurveyDTO> surveys = new List <SurveyDTO>();
var surveysForCoordinator = from survey_group in db.X_Survey_Groups.Include("Survey")
join coordinator_group in db.X_Coordinator_Groups.Include("Coordinator") on survey_group.StudyGroupId equals coordinator_group.StudyGroupId
join studyGroup in db.StudyGroups on survey_group.StudyGroupId equals studyGroup.Id
where coordinator_group.CoordinatorId.Equals(coordinatorId) && survey_group.Survey.SurveyType == SurveyType.Survey
select new { survey_group, coordinator_group, studyGroup, Survey = survey_group.Survey, Coordinator = coordinator_group.Coordinator };
/* var surveysForCoordinator = db.X_Survey_Groups
* .Include(s => s.Survey)
* .Join(db.X_Coordinator_Groups
* .Include(g => g.Coordinator)
* .Where(g => g.CoordinatorId.Equals(coordinatorId)),
* survey_group => survey_group.StudyGroupId,
* group => group.Id,
* (survey_group, group) => new { survey_group, group });*/
foreach (var s in surveysForCoordinator.ToList())
{
var questionsInSurvey = db.X_Survey_Questions
.Include(q => q.Question)
.Where(q => q.SurveyId == s.survey_group.SurveyId)
.Select(q => new QuestionDTO
{
Id = q.QuestionId,
QuestionText = q.Question.QuestionText,
QuestionType = q.Question.QuestionType,
Maximum = q.Question.Maximum,
Minimum = q.Question.Minimum,
StepSize = q.Question.StepSize,
Options = q.Question.Options
})
.ToList();
var survey = new SurveyDTO
{
SurveyId = s.survey_group.Id,
StudyGroupId = s.survey_group.StudyGroupId,
StudyGroupName = s.studyGroup.StudyGroupName,
SurveyName = s.Survey.SurveyName,
StudyCoordinatorId = s.Coordinator.Id,
StudyCoordinatorName = s.Coordinator.UserName,
SurveyType = s.survey_group.Survey.SurveyType,
Questions = questionsInSurvey.ToList()
};
surveys.Add(survey);
}
return(surveys);
}
//Get stored surveys
// GET: api/Surveys
public IList <SurveyDTO> GetSurveys()
{
List <SurveyDTO> surveysSaved = new List <SurveyDTO>();
var surveysInDb = db.Surveys.Where(s => s.SurveyType == SurveyType.Survey).ToList();
foreach (var s in surveysInDb)
{
var questionsInSurvey = db.X_Survey_Questions
.Include(q => q.Question)
.Where(q => q.SurveyId == s.Id)
.Select(q => new QuestionDTO
{
Id = q.Id,
QuestionText = q.Question.QuestionText,
QuestionType = q.Question.QuestionType,
Maximum = q.Question.Maximum,
Minimum = q.Question.Minimum,
StepSize = q.Question.StepSize,
Options = q.Question.Options
});
var survey = new SurveyDTO
{
SurveyId = s.Id,
SurveyName = s.SurveyName,
SurveyType = s.SurveyType,
Questions = questionsInSurvey.ToList()
};
surveysSaved.Add(survey);
}
return(surveysSaved);
/*return db.Surveys.Include(s => s.StudyGroup).Include(s => s.Question).Select(s => new SurveyDTO
* {
* SurveyId = s.SurveyId,
* SurveyCreatedTime = s.SurveyCreatedTime,
* QuestionText = s.Question.QuestionText,
* StudyGroupId = s.StudyGroupId,
* StudyGroupName = s.StudyGroup.StudyName,
* QuestionId = s.QuestionId,
* QuestionType = s.Question.QuestionType,
* Options = s.Question.Options,
* QuestionFrequency = ((Frequency)s.FrequencyOfNotifications).ToString(),
* Time1 = s.Time1,
* Time2 = s.Time2
*
* }).ToList();*/
}
public async Task DeleteSurveyAsync(SurveyDTO survey)
{
Delete(new Survey()
{
UserID = survey.UserID,
SurveyName = survey.SurveyName,
Description = survey.Description,
IsActive = survey.IsActive,
CreationDate = survey.CreationDate,
Language = survey.Language
});
await SaveAsync();
}
public IHttpActionResult GetSurvey(int id)
{
Survey survey = db.Surveys.Find(id);
if (survey == null)
{
return(NotFound());
}
List <SurveyDTO> surveysSaved = new List <SurveyDTO>();
var surveysInStudyGroup = from survey_group in db.X_Survey_Groups.Include("Survey")
join coordinator_group in db.X_Coordinator_Groups.Include("Coordinator") on survey_group.StudyGroupId equals coordinator_group.StudyGroupId
where survey_group.SurveyId == id
select new { survey_group, coordinator_group, Survey = survey_group.Survey, Coordinator = coordinator_group.Coordinator };
foreach (var s in surveysInStudyGroup.ToList())
{
var questionsInSurvey = db.X_Survey_Questions
.Include(q => q.Question)
.Where(q => q.SurveyId == s.survey_group.SurveyId)
.Select(q => new QuestionDTO
{
Id = q.Question.Id,
QuestionText = q.Question.QuestionText,
QuestionType = q.Question.QuestionType,
Maximum = q.Question.Maximum,
Minimum = q.Question.Minimum,
StepSize = q.Question.StepSize,
Options = q.Question.Options
})
.ToList();
var surveyDTO = new SurveyDTO
{
SurveyId = s.survey_group.Id,
StudyGroupId = s.survey_group.StudyGroupId,
SurveyName = s.Survey.SurveyName,
StudyCoordinatorId = s.Coordinator.Id,
StudyCoordinatorName = s.Coordinator.UserName,
SurveyType = s.survey_group.Survey.SurveyType,
Questions = questionsInSurvey.ToList()
};
surveysSaved.Add(surveyDTO);
}
return(Ok(surveysSaved[0]));
}
public async Task <IActionResult> UnPublish([Bind("Id")] SurveyDTO model)
{
try
{
var surveyResult = await _surveyService.GetSurveyAsync(model.Id);
if (surveyResult.Succeeded)
{
if (!surveyResult.Item.Published)
{
ModelState.AddModelError(string.Empty, $"The survey is already unpublished");
return(View("UnPublishResult", surveyResult.Item));
}
else
{
var unpublishResult = await _surveyService.UnPublishSurveyAsync(model.Id);
if (unpublishResult.Succeeded)
{
ViewBag.Message = "The following survey has been unpublished.";
return(View("UnPublishResult", unpublishResult.Item));
}
else
{
ModelState.AddModelError(string.Empty, $"Cannot unpublish survey. (HTTP {unpublishResult.StatusCode})");
switch (unpublishResult.StatusCode)
{
case (int)HttpStatusCode.Unauthorized:
return(ReAuthenticateUser());
case (int)HttpStatusCode.Forbidden:
ViewBag.Forbidden = true;
break;
}
return(View(surveyResult.Item));
}
}
}
}
catch (AuthenticationException)
{
return(ReAuthenticateUser());
}
catch
{
ViewBag.Message = "Unexpected Error";
}
return(View("~/Views/Shared/Error.cshtml"));
}
public IActionResult Post([FromBody] SurveyCreateDTO survey)
{
if (survey == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// map dto to entity
var surveyToAdd = new SurveyDTO
{
Name = survey.Name,
Description = survey.Description,
SurveyTypeCode = survey.SurveyTypeCode,
Instructions = survey.Instructions,
IsLocked = survey.IsLocked,
CloseDate = survey.CloseDate,
CreateDate = survey.CreateDate,
CreatedBy = survey.CreatedBy,
UpdateDate = survey.UpdateDate,
UpdatedBy = survey.UpdatedBy,
SchoolYear = survey.SchoolYear,
LeaverYear = survey.LeaverYear,
IsReported = survey.IsReported,
OpenDate = survey.OpenDate
};
try
{
// save
_rep.AddSurvey(surveyToAdd);
_rep.Save();
return(CreatedAtRoute("GetSurvey", new { id = surveyToAdd.Id }, surveyToAdd));
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(ex.Message));
}
}
private Survey ConvertDto(SurveyDTO itemDTO, Survey instance)
{
instance = instance ?? new Survey();
instance.SurveyName = itemDTO.surveyName;
instance.Description = itemDTO.description;
instance.SubModuleItem = itemDTO.subModuleItemId.HasValue ? this.SubModuleItemModel.GetOneById(itemDTO.subModuleItemId.Value).Value : null;
instance.SurveyGroupingType = this.SurveyGroupingTypeModel.GetOneById(itemDTO.surveyGroupingTypeId).Value;
if (instance.SubModuleItem != null)
{
instance.SubModuleItem.DateModified = DateTime.Now;
this.SubModuleItemModel.RegisterSave(instance.SubModuleItem);
}
return(instance);
}
public SurveyDTO Save(SurveyDTO surveyDTO)
{
if (IsValid(surveyDTO, out ValidationResult validationResult))
{
var model = SurveyModel;
var isTransient = surveyDTO.surveyId == 0;
var survey = isTransient ? null : model.GetOneById(surveyDTO.surveyId).Value;
return(ConvertQuizAndGetServiceResponse(surveyDTO, survey, model));
}
var error = GenerateValidationError(validationResult);
LogError("Survey.Create", error);
throw new FaultException <Error>(error, error.errorMessage);
}
public SurveyValidator(SurveyDTO survey, Survey original, bool hasAnyoneCompleted)
{
if (survey == null)
{
throw new ArgumentNullException("survey");
}
if (original == null)
{
throw new ArgumentNullException("original");
}
this.survey = survey;
this.original = original;
this.hasAnyoneCompleted = hasAnyoneCompleted;
}
public IActionResult Post([FromBody] SurveyDTO survey)
{
if (survey == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_adminManager.AddSurveyQuestionDetail(survey);
return(NoContent());
}
public async Task <IActionResult> Delete([Bind("Id")] SurveyDTO model)
{
try
{
var surveyResult = await _surveyService.GetSurveyAsync(model.Id);
if (surveyResult.Succeeded)
{
var result = await _surveyService.DeleteSurveyAsync(model.Id);
if (result.Succeeded)
{
ViewBag.Message = "The following survey has been deleted.";
return(View("DeleteResult", result.Item));
}
else
{
ModelState.AddModelError(string.Empty, $"Unable to delete survey. (HTTP {result.StatusCode})");
switch (result.StatusCode)
{
case (int)HttpStatusCode.Unauthorized:
return(ReAuthenticateUser());
case (int)HttpStatusCode.Forbidden:
ViewBag.Forbidden = true;
break;
}
return(View(surveyResult.Item));
}
}
if (surveyResult.StatusCode == (int)HttpStatusCode.NotFound)
{
ModelState.AddModelError(string.Empty, $"The survey can not be found, It may have already been deleted");
ViewBag.Message = $"The survey can not be found, It may have already been deleted";
return(View("~/Views/Shared/Error.cshtml"));
}
}
catch (AuthenticationException)
{
return(ReAuthenticateUser());
}
catch
{
ViewBag.Message = "Unexpected Error";
}
return(View("~/Views/Shared/Error.cshtml"));
}
public void tblSurvey_Update(SurveyDTO dt)
{
sv.tblSurvey_Update(dt);
}
public void tblSurvey_insert(SurveyDTO dt)
{
sv.tblSurvey_insert(dt);
}
