public IActionResult Create(Ticket ticket)
{
ticket.CreateDate = DateTime.Now;
_context.Tickets.Add(ticket);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
public IActionResult Delete(string id)
{
var user = _context.Users.FirstOrDefault(x => x.Id == id);
_context.Remove(user);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
public void ShouldReturnAnErrorMessageWhenNoNameProvided()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentSurveys = context.Surveys.Count();
var questionGroups = EfTestData.CreateQuestionGroupDtos();
var surveyDto = new SurveyDto
{
QuestionGroupsDtos = questionGroups,
};
var service = new AddSurveyService(context, new MapQuestionsToGroupService());
var result = service.AddSurvey(surveyDto);
result.ShouldNotBeNull();
context.SaveChanges();
result.First().ErrorMessage.ShouldEqual("A name has not been provided for this survey.");
context.Surveys.Count().ShouldEqual(currentSurveys);
}
}
public IImmutableList <ValidationResult> AddSurvey(SurveyDto surveyDto)
{
if (surveyDto.QuestionGroupsDtos == null)
{
Status.AddError("No question groups have been submitted with this survey.");
return(Status.Errors);
}
if (string.IsNullOrWhiteSpace(surveyDto.Name))
{
Status.AddError("A name has not been provided for this survey.");
return(Status.Errors);
}
var questionGroups = _questionMapper.Map(surveyDto.QuestionGroupsDtos, _context);
var survey = new Survey(surveyDto.Name, questionGroups);
if (Status.HasErrors)
{
return(Status.Errors);
}
_context.Add(survey);
_context.SaveChanges();
return(null);
}
public void ShouldReturnAnErrorMessageIfNewNameNotProvided()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentName = context.Surveys.First(m => m.SurveyId == 1).Name;
var surveyDto = new SurveyDto
{
Id = 1,
NewName = ""
};
var service = new RenameSurveyService(context);
var result = service.RenameSurvey(surveyDto);
result.ShouldNotBeNull();
result.First().ErrorMessage.ShouldEqual("No new name has been provided for this survey.");
context.SaveChanges();
context.Surveys.First(m => m.SurveyId == surveyDto.Id).Name.ShouldEqual(currentName);
}
}
public void TestSaveSurveyNoQuestions()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentCompletedSurveys = context.CompletedSurveys.Count();
var completedQuestionsDto = EfTestData.CreateCompletedQuestionsDto();
var completedSurveyDto = new CompletedSurveyDto
{
Name = "Test Completed Survey",
CaseNo = 999
};
var service = new SaveCompletedSurveysService(context, new MapCompletedQuestionsFromDtoService());
var result = service.SaveCompletedSurvey(completedSurveyDto);
context.SaveChanges();
result.ShouldNotBeNull();
result.First().ErrorMessage.ShouldEqual("No Questions have been submitted with this completed survey.");
context.CompletedSurveys.Count().ShouldEqual(currentCompletedSurveys);
}
}
public void TestSaveSurveyNoName()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentCompletedSurveys = context.CompletedSurveys.Count();
var completedQuestionsDto = EfTestData.CreateCompletedQuestionsDto();
var completedSurveyDto = new CompletedSurveyDto
{
CaseNo = 999,
Questions = completedQuestionsDto
};
var service = new SaveCompletedSurveysService(context, new MapCompletedQuestionsFromDtoService());
var result = service.SaveCompletedSurvey(completedSurveyDto);
context.SaveChanges();
result.ShouldNotBeNull();
service.Errors.Count.ShouldEqual(1);
service.Errors.First().ErrorMessage.ShouldEqual("A survey name has not been supplied.");
context.CompletedSurveys.Count().ShouldEqual(currentCompletedSurveys);
}
}
public void TestSaveSurveyOk()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentCompletedSurveys = context.CompletedSurveys.Count();
var completedQuestionsDto = EfTestData.CreateCompletedQuestionsDto();
var completedSurveyDto = new CompletedSurveyDto
{
Name = "Test Completed Survey",
CaseNo = 999,
Questions = completedQuestionsDto
};
var service = new SaveCompletedSurveysService(context, new MapCompletedQuestionsFromDtoService());
var result = service.SaveCompletedSurvey(completedSurveyDto);
result.ShouldBeNull();
context.SaveChanges();
service.Errors.Count.ShouldEqual(0);
context.CompletedSurveys.Count().ShouldEqual(currentCompletedSurveys + 1);
}
}
public void ShouldReturnErrorMessageWhenQuestionGroupNotFound()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var questionGroupId = -1;
var currentQuestions = context.Questions.Count();
var questionDtos = new List <QuestionDto>
{
new QuestionDto
{
Text = "How well have you been sleeping?",
Type = 1
}
};
var surveyDto = new SurveyDto
{
Id = 1,
QuestionGroupId = questionGroupId,
QuestionsDtos = questionDtos
};
var service = new AddQuestionService(context, new MapQuestionDtoToQuestionsService());
var result = service.AddQuestion(surveyDto);
result.ShouldNotBeNull();
result.First().ErrorMessage.ShouldEqual($"Could not find QuestionGroup with an Id of {questionGroupId}");
context.SaveChanges();
context.Questions.Count().ShouldEqual(currentQuestions);
}
}
public void ShouldReturnErrorMessageWhenQuestionTextNotSpecified()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentQuestions = context.Questions.Count();
var questionDtos = new List <QuestionDto>
{
new QuestionDto
{
Type = 1
}
};
var surveyDto = new SurveyDto
{
Id = 1,
QuestionGroupId = 1,
QuestionsDtos = questionDtos
};
var service = new AddQuestionService(context, new MapQuestionDtoToQuestionsService());
var result = service.AddQuestion(surveyDto);
result.ShouldNotBeNull();
result.First().ErrorMessage.ShouldEqual("A question has been submitted without any text.");
context.SaveChanges();
context.Questions.Count().ShouldEqual(currentQuestions);
}
}
public void ShouldAddAQuestion()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentQuestions = context.Questions.Count();
var questionDtos = new List <QuestionDto>
{
new QuestionDto
{
Text = "How well have you been sleeping?",
Type = 1
}
};
var surveyDto = new SurveyDto
{
Id = 1,
QuestionGroupId = 1,
QuestionsDtos = questionDtos
};
var service = new AddQuestionService(context, new MapQuestionDtoToQuestionsService());
var result = service.AddQuestion(surveyDto);
result.ShouldBeNull();
context.SaveChanges();
context.Questions.Count().ShouldEqual(currentQuestions + 1);
}
}
public ActionResult Register(LoginAndRegisterModel register)
{
if (ModelState.IsValid && register.Nick.Length >= 8)
{
using (SurveyDbContext entities = new SurveyDbContext())
{
if (entities.Users.Any(X => X.Nick == register.Nick))
{
return(View());
}
else
{
User surveyTaker = new User();
Random random = new Random();
surveyTaker.UserId = random.Next();
surveyTaker.Nick = register.Nick;
surveyTaker.Password = register.Pass;
entities.Users.Add(surveyTaker);
entities.SaveChanges();
entities.Dispose();
return(RedirectToAction("Login", "Home"));
}
}
}
else
{
return(View());
}
}
public bool AddVote(VoteContract vote)
{
try
{
using (var db = new SurveyDbContext())
{
if (!db.Vote.Any(a => a.IdVote == vote.IdVote))
{
db.Vote.Add(new Data.Entities.Vote {
IdVote = vote.IdVote, IdAnswer = vote.IdAnswer
});
if (vote.SenderId == App.AppId)
{
db.MyVotes.Add(new Data.Entities.MyVotes {
IdAnswer = vote.IdAnswer, IdSurvey = vote.IdSurvey
});
}
db.SaveChanges();
return(true);
}
return(false);
}
}
catch (Exception e)
{
Logger.Log(e);
return(false);
}
}
public bool AddSurvey(SurveyContract survey)
{
try
{
using (var db = new SurveyDbContext())
{
if (!db.Survey.Any(a => a.IdSurvey == survey.IdSurvey))
{
db.Survey.Add(new Data.Entities.Survey
{
IdSurvey = survey.IdSurvey,
Description = survey.Description,
Name = survey.Name,
StartDateUTC = DateTime.Now.ToUniversalTime(),
EndDateUTC = survey.EndDateUTC
});
var answers = survey.Answers.Select(s => new Data.Entities.Answer {
IdAnswer = s.IdAnswer, IdSurvey = survey.IdSurvey, Text = s.Text
});
db.Answer.AddRange(answers);
db.SaveChanges();
return(true);
}
return(false);
}
}
catch (Exception e)
{
Logger.Log(e);
return(false);
}
}
public void ShouldReturnErrorMessageIfSurveyNotFound()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentSurveys = context.Surveys.Count();
var surveyDto = new SurveyDto
{
Id = -1
};
var service = new RemoveSurveyService(context);
var result = service.RemoveSurvey(surveyDto);
result.ShouldNotBeNull();
result.First().ErrorMessage.ShouldEqual($"A survey with the ID of {surveyDto.Id} was not found.");
context.SaveChanges();
context.Surveys.Count().ShouldEqual(currentSurveys);
}
}
public void ShouldReturnErrorMessageWhenSurveyNotFound()
{
var options = SqliteInMemory.CreateOptions<SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentCompletedQuestions = context.CompletedQuestions.Count();
var completedSurveyId = -1;
var completedSurveyDto = new CompletedSurveyDto
{
CompletedSurveyId = completedSurveyId,
Name = "Test Completed Survey",
CaseNo = 999,
Questions = completedQuestionsDto
};
var service = new SaveCompletedQuestionToCompletedSurveyService(context, new MapCompletedQuestionsFromDtoService());
var result = service.SaveCompletedQuestion(completedSurveyDto);
result.ShouldNotBeNull();
context.SaveChanges();
result.First().ErrorMessage.ShouldEqual($"Could not find Survey with an Id of {completedSurveyId}");
context.CompletedQuestions.Count().ShouldEqual(currentCompletedQuestions);
}
}
public static void SeedDataBaseWithSurveys(this SurveyDbContext context)
{
context.Surveys.AddRange(CreateSurveys());
context.CompletedSurveys.AddRange(CreateCompletedSurveys());
context.QuestionTypes.AddRange(CreateQuestionTypes());
context.SaveChanges();
}
public ActionResult Taking(ModelTest test)
{
if (test.Questions.All(x => x.Seçim != null))
{
SurveyDbContext surveyEntities = new SurveyDbContext();
int surveytakerid = (int)Session["CurrentUser"];
int aı = surveyEntities.Answers.Count() + 1;
int i = 0;
foreach (var item in test.Questions)
{
Answer answer = new Answer();
answer.AnswerId = aı;
while (surveyEntities.Answers.Any(x => x.AnswerId == answer.AnswerId))
{
answer.AnswerId = new Random().Next();
}
answer.QuestionId = item.Question.QuestionId;
answer.UserId = surveytakerid;
answer.Seçim = item.Seçim;
surveyEntities.Answers.Add(answer);
aı++;
i++;
}
surveyEntities.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
else
{
TempData["Error"] = "Tüm Sorulara Cevap Vermelisiniz";
return(RedirectToAction("Taking", "TakingSurvey", new { id = test.id }));
}
}
public IImmutableList <ValidationResult> SaveCompletedQuestion(CompletedSurveyDto dto)
{
if (dto.Questions == null)
{
Status.AddError("No Questions have been submitted with this completed survey.");
return(Status.Errors);
}
var completedSurvey = _context.Find <CompletedSurvey>(dto.CompletedSurveyId);
if (completedSurvey == null)
{
Status.AddError($"Could not find Survey with an Id of {dto.CompletedSurveyId}");
return(Status.Errors);
}
var completedQuestions = _mapper.MapQuestionsFromDto(dto.Questions, _context);
foreach (var question in completedQuestions)
{
Status = completedSurvey.AddQuestion(question, _context);
}
if (Status.HasErrors)
{
return(Status.Errors);
}
_context.SaveChanges();
return(null);
}
public void ShouldReturnAnErrorMessageWhenGroupNoNameProvided()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentQuestionGroups = context.QuestionGroups.Count();
var questions = EfTestData.CreateQuestionsDtos();
var questionGroupsDto = new List <QuestionGroupDto>
{
new QuestionGroupDto
{
Questions = questions
}
};
var surveyDto = new SurveyDto
{
Id = 1,
QuestionGroupsDtos = questionGroupsDto
};
var service = new AddQuestionGroupService(context, new MapQuestionsToGroupService());
var result = service.AddQuestionGroup(surveyDto);
result.ShouldNotBeNull();
context.SaveChanges();
result.First().ErrorMessage.ShouldEqual("A name is needed when creating a new question group.");
context.QuestionGroups.Count().ShouldEqual(currentQuestionGroups);
}
}
public void ShouldAddQuestionGroup()
{
var options = SqliteInMemory.CreateOptions <SurveyDbContext>();
using (var context = new SurveyDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDataBaseWithSurveys();
var currentQuestionGroups = context.QuestionGroups.Count();
var questions = EfTestData.CreateQuestionsDtos();
var questionGroupsDto = new List <QuestionGroupDto>
{
new QuestionGroupDto
{
Name = "Test QuestionGroup Dto",
Questions = questions
}
};
var surveyDto = new SurveyDto
{
Id = 1,
QuestionGroupsDtos = questionGroupsDto
};
var service = new AddQuestionGroupService(context, new MapQuestionsToGroupService());
var result = service.AddQuestionGroup(surveyDto);
result.ShouldBeNull();
context.SaveChanges();
context.QuestionGroups.Count().ShouldEqual(currentQuestionGroups + 1);
}
}
public void AddUserSurvey(User user, Survey survey)
{
UserSurvey userSurvey = new UserSurvey();
userSurvey.SurveyId = survey.Id;
userSurvey.UserId = user.Id;
dbContext.UserSurveys.Add(userSurvey);
dbContext.SaveChanges();
}
public TOut RunAction(TIn dataIn)
{
var result = _actionClass.Action(dataIn);
if (!HasErrors)
{
_context.SaveChanges();
}
return(result);
}
public ActionResult CloseOpen(int id)
{
SurveyDbContext surveyEntities = new SurveyDbContext();
if (surveyEntities.Tests.Single(x => x.TestId == id).Open == true)
{
surveyEntities.Tests.Single(x => x.TestId == id).Open = false;
}
else
{
surveyEntities.Tests.Single(x => x.TestId == id).Open = true;
}
surveyEntities.SaveChanges();
return(RedirectToAction("ManageSurveys", "Admin"));
}
public ActionResult Delete(int id)
{
using (SurveyDbContext entities = new SurveyDbContext())
{
Test test = entities.Tests.Single(X => X.TestId == id);
foreach (var item in entities.Questions.Include(x => x.Choices).Include(x => x.Answers).Where(x => x.TestId == id))
{
entities.Choices.RemoveRange(item.Choices);
entities.Answers.RemoveRange(item.Answers);
entities.Questions.Remove(item);
}
entities.Tests.Remove(test);
entities.SaveChanges();
return(RedirectToAction("ManageSurveys", "Admin"));
}
}
public void CreateTest()
{
Test test = new Test();
test.Title = Title;
test.Open = false;
Random random = new Random();
test.TestId = random.Next();
SurveyDbContext surveyEntities = new SurveyDbContext();
foreach (var item in CreatingQuestionmodels.Where(x => x.Soru != null && x.Choices.Count > 1))
{
item.Addtodatabase(surveyEntities, test.TestId);
}
surveyEntities.Tests.Add(test);
surveyEntities.SaveChanges();
}
public IImmutableList <ValidationResult> RemoveSurvey(SurveyDto dto)
{
var survey = _context.Find <Survey>(dto.Id);
if (survey == null)
{
Status.AddError($"A survey with the ID of {dto.Id} was not found.");
return(Status.Errors);
}
Status = survey.RemoveSelf(_context);
if (Status.HasErrors)
{
return(Status.Errors);
}
_context.SaveChanges();
return(null);
}
public void AddResult(CalculatedResult result)
{
using (var db = new SurveyDbContext())
{
if (!db.CalculatedResult.Any(a => a.ClientIdentifier == result.ClientId && a.IdSurvey == result.IdSurvey))
{
var answersXml = result.Result.Serialize();
db.CalculatedResult.Add(new Data.Entities.CalculatedResult
{
IdSurvey = result.IdSurvey,
ClientIdentifier = result.ClientId,
IdCalculatedResult = Guid.NewGuid(),
Result = answersXml
});
db.SaveChanges();
}
}
}
public void EditTest(int testid)
{
SurveyDbContext surveyEntities = new SurveyDbContext();
Random random = new Random();
if (Title.Length > 5)
{
surveyEntities.Tests.Single(x => x.TestId == testid).Title = Title;
}
foreach (var item in EditQuestionModels)
{
item.UpdateDatabase(surveyEntities);
}
foreach (var item in CreatingQuestionmodels.Where(x => x.Soru != null && x.Choices.Count > 1))
{
item.Addtodatabase(surveyEntities, testid);
}
surveyEntities.SaveChanges();
}
public IImmutableList <ValidationResult> AddQuestion(SurveyDto surveyDto)
{
var survey = _context.Find <Survey>(surveyDto.Id);
if (survey == null)
{
Status.AddError($"Could not find Survey with an Id of {surveyDto.Id}");
return(Status.Errors);
}
var questionGroup = _context.Find <QuestionGroup>(surveyDto.QuestionGroupId);
if (questionGroup == null)
{
Status.AddError($"Could not find QuestionGroup with an Id of {surveyDto.QuestionGroupId}");
return(Status.Errors);
}
foreach (var question in surveyDto.QuestionsDtos)
{
if (question.Type == 0)
{
Status.AddError("A question has been submitted with an invalid question type.");
return(Status.Errors);
}
if (string.IsNullOrWhiteSpace(question.Text))
{
Status.AddError("A question has been submitted without any text.");
return(Status.Errors);
}
}
var questions = _questionMapper.Map(surveyDto.QuestionsDtos, _context);
Status = survey.AddQuestions(questions, questionGroup, _context);
if (Status.HasErrors)
{
return(Status.Errors);
}
_context.SaveChanges();
return(null);
}