public void SetUpTests()
{
//setup surveys
_surveyMock = new Mock <ISurvey>();
_surveyMock.Setup(s => s.Name).Returns(_instrumentName);
_surveyMock.Setup(s => s.InstrumentID).Returns(_instrumentId);
var surveyItems = new List <ISurvey> {
_surveyMock.Object
};
_surveyCollectionMock = new Mock <ISurveyCollection>();
_surveyCollectionMock.Setup(s => s.GetEnumerator()).Returns(() => surveyItems.GetEnumerator());
//setup server parks
_serverParkMock = new Mock <IServerPark>();
_serverParkMock.Setup(s => s.Name).Returns("TestServerParkName");
_serverParkMock.Setup(s => s.Surveys).Returns(_surveyCollectionMock.Object);
_parkServiceMock = new Mock <IServerParkService>();
_parkServiceMock.Setup(p => p.GetServerPark(_connectionModel, _serverParkName)).Returns(_serverParkMock.Object);
_parkServiceMock.Setup(p => p.GetServerParkNames(_connectionModel)).Returns(new List <string> {
_serverParkName
});
_sut = new SurveyService(_parkServiceMock.Object);
}
public void Different_appointment_id()
{
SurveyService service = new SurveyService(CreateQuestionStubRepository(), CreateSurveyStubRepository());
bool b = service.CheckIfExistsById(4);
b.ShouldBeTrue();
}
public void Create_Survey_Successfuly()
{
SurveyService service = new SurveyService(CreateStubRepository());
Survey survay = service.Create(new SurveyDto(1, 1, 4, 5, 4, 5, 4, 5, 4, 5, 5, 5, 5, 4, 3, 3, 2, 2, 5));
survay.ShouldNotBeNull();
}
public void Same_appointment_id()
{
SurveyService service = new SurveyService(CreateQuestionStubRepository(), CreateSurveyStubRepository());
bool b = service.CheckIfExistsById(2);
b.ShouldBeFalse();
}
public void EditAsync_CoOwnerIncludesMysteryPerson_ThrowsException()
{
var tyler = new ApplicationUser()
{
UserName = "******"
};
var survey = new Survey()
{
Owner = tyler
};
var newValues = new SurveyEditViewModel()
{
SharedUsers = new[] { "Shannon", "Bill" }
};
var dbMock = new Mock <IApplicationDBContext>();
var surveyDataMock = new Mock <DbSet <Survey> >().SetupData(new[] { survey });
dbMock.SetupGet(d => d.Surveys).Returns(surveyDataMock.Object);
var usersMock = new Mock <DbSet <ApplicationUser> >().SetupData(new[] { tyler });
dbMock.SetupGet(d => d.Users).Returns(usersMock.Object);
var subject = new SurveyService(dbMock.Object);
var ex = Helpers.Catch <SurveyException>(() => {
subject.EditAsync(survey, newValues).Wait();
});
Assert.AreEqual("Unknown users: Shannon, Bill. Please make sure these users have signed into Mood before.", ex.Message);
Assert.AreEqual(0, survey.SharedUsers.Count);
dbMock.Verify(d => d.SaveChangesAsync(), Times.Never);
}
public ActionResult AssignUsersToSurvey(UserSurveyAssign userSurveyAssign, string assignType)
{
UserService userService = new UserService();
SurveyService surveyService = new SurveyService();
List <ApplicationUser> selectedUsers = new List <ApplicationUser>();
switch (assignType.ToUpper())
{
case "USER":
selectedUsers = userService.GetUserByIdRange(userSurveyAssign.UserIds);
break;
case "DEPARTMENT":
selectedUsers = userService.GetUsersByDepartment(userSurveyAssign.DepartmentId);
break;
case "JOBTITLE":
selectedUsers = userService.GetUsersByJobTitle(userSurveyAssign.JobTitleId);
break;
}
// Create UserSurvey records for each user in selectedUsers
foreach (var user in selectedUsers)
{
surveyService.CreateUserSurvey(new UserSurveyCreate
{
SurveyId = userSurveyAssign.SurveyId,
UserId = Guid.Parse(user.Id)
});
}
return(RedirectToAction("Index"));
}
public SingleResponeMessage <SurveyDetailInfo> Get(int id, string _userID)
{
SingleResponeMessage <SurveyDetailInfo> ret = new SingleResponeMessage <SurveyDetailInfo>();
try
{
SurveyDetailInfo item = SurveyService.GetInstance().GetDetailSurvey(id, _userID);
if (item == null)
{
ret.isSuccess = false;
ret.err.msgCode = "001";
ret.err.msgString = "no Survey found";
return(ret);
}
ret.item = item;
ret.isSuccess = true;
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.err.msgCode = "Internal Error !!!";
ret.err.msgString = ex.ToString();
}
return(ret);
}
protected void Page_Load(object sender, EventArgs e)
{
String key = Request.Params["key"];
survey = SurveyService.getSurveyByKey(key);
this.code = key;
}
public void Get_Rates_Successfuly()
{
SurveyService service = new SurveyService(CreateStubRepository());
SurveyAverageDto foundSurvey = service.GetAllAverageRates();
foundSurvey.ShouldNotBeNull();
}
public void Get_Doctors_Rates_Successfuly()
{
SurveyService service = new SurveyService(CreateStubRepository());
List <SurveyDoctorAverageDto> foundSurveys = service.GetAllDoctorAverageRates();
foundSurveys.ShouldNotBeNull();
}
public void EditAsync_CoOwnerIncludesPerson_AddsPerson()
{
var tyler = new ApplicationUser()
{
UserName = "******"
};
var shannon = new ApplicationUser()
{
UserName = "******"
};
var survey = new Survey()
{
Owner = tyler
};
var newValues = new SurveyEditViewModel()
{
SharedUsers = new[] { "Shannon" }
};
var dbMock = new Mock <IApplicationDBContext>();
var surveyDataMock = new Mock <DbSet <Survey> >().SetupData(new[] { survey });
dbMock.SetupGet(d => d.Surveys).Returns(surveyDataMock.Object);
var usersMock = new Mock <DbSet <ApplicationUser> >().SetupData(new[] { tyler, shannon });
dbMock.SetupGet(d => d.Users).Returns(usersMock.Object);
var subject = new SurveyService(dbMock.Object);
subject.EditAsync(survey, newValues).Wait();
Assert.AreEqual(1, survey.SharedUsers.Count);
dbMock.Verify(d => d.SaveChangesAsync());
}
public void EditAsync_NewNameIsWhitespace_ThrowsException()
{
var survey = new Survey()
{
Name = "oldName"
};
var newValues = new SurveyEditViewModel()
{
Name = "\n \t"
};
var dbMock = new Mock <IApplicationDBContext>();
var surveyDataMock = new Mock <DbSet <Survey> >().SetupData(new[] { survey });
dbMock.SetupGet(d => d.Surveys).Returns(surveyDataMock.Object);
var subject = new SurveyService(dbMock.Object);
var ex = Helpers.Catch <SurveyException>(() => {
subject.EditAsync(survey, newValues).Wait();
});
Assert.AreEqual("Name must not be whitespace", ex.Message);
Assert.AreEqual("oldName", survey.Name);
dbMock.Verify(d => d.SaveChangesAsync(), Times.Never);
}
public void EditAsync_CoOwnerIncludesOwner_ThrowsException()
{
var tyler = new ApplicationUser()
{
UserName = "******"
};
var survey = new Survey()
{
Owner = tyler
};
var newValues = new SurveyEditViewModel()
{
SharedUsers = new[] { "Tyler" }
};
var dbMock = new Mock <IApplicationDBContext>();
var surveyDataMock = new Mock <DbSet <Survey> >().SetupData(new[] { survey });
dbMock.SetupGet(d => d.Surveys).Returns(surveyDataMock.Object);
var usersMock = new Mock <DbSet <ApplicationUser> >().SetupData(new[] { tyler });
dbMock.SetupGet(d => d.Users).Returns(usersMock.Object);
var subject = new SurveyService(dbMock.Object);
var ex = Helpers.Catch <SurveyException>(() => {
subject.EditAsync(survey, newValues).Wait();
});
Assert.AreEqual("You cannot be a co-admin on a survey you own.", ex.Message);
Assert.AreEqual(0, survey.SharedUsers.Count);
dbMock.Verify(d => d.SaveChangesAsync(), Times.Never);
}
public ActionResult Edit(Survey dto)
{
try
{
if (dto.Id == 0)
{
SurveyService.AddEntitySaved(dto);
}
else
{
var edit = SurveyService.GetById(dto.Id);
edit.SurveyName = dto.SurveyName;
edit.CopyRight = dto.CopyRight;
edit.Description = dto.Description;
edit.CreateTime = DateTime.Now;
dto.SurveyStatus = SurveyStatus.Creating;
SurveyService.UpdateEntitySaved(edit);
}
}
catch (Exception ex)
{
LogManager.Error(GetType(), ex);
return No(ex.Message);
}
return Ok();
}
public void DeleteAsync_SurveyHasNoAnswers_DeletesSurvey()
{
var survey = new Survey()
{
Id = Guid.NewGuid()
};
var dbMock = new Mock <IApplicationDBContext>();
var surveyDataMock = new Mock <DbSet <Survey> >().SetupData(new List <Survey>()
{
survey
});
dbMock.SetupGet(d => d.Surveys).Returns(surveyDataMock.Object);
var answerDataMock = new Mock <DbSet <Answer> >().SetupData();
dbMock.SetupGet(d => d.Answers).Returns(answerDataMock.Object);
var subject = new SurveyService(dbMock.Object);
subject.DeleteAsync(survey).Wait();
surveyDataMock.Verify(d => d.Remove(survey));
dbMock.Verify(d => d.SaveChangesAsync());
}
public ActionResult Save(long id, List<long> topics)
{
if (IsIllegalId(id)) return ParamsError();
try
{
if (topics == null || !topics.Any())
{
SurveyQuestionService.Delete(l => l.SurveyId == id);
SurveyService.Update(l=>l.Id == id,o=> new Survey{ SurveyStatus = SurveyStatus.Creating });
}
else
{
var sq = new List<SurveyQuestion>();
foreach (var t in topics)
sq.Add(new SurveyQuestion() { SurveyId = id, QuestionId = t });
SurveyQuestionService.AddOrUpdateSaved(s => s.SurveyId, sq.ToArray());
SurveyService.Update(l=>l.Id == id,o=> new Survey{ SurveyStatus = SurveyStatus.Waiting });
}
}
catch (Exception e)
{
LogManager.Error(GetType(), e);
return No(e.Message);
}
return Ok();
}
async void Handle_Clicked(object sender, System.EventArgs e)
{
svm.surveyModel.Other_Interests = OtherInterests.SelectedItem;
svm.surveyModel.Favourite_Spot = SportPicker.SelectedItem;
svm.surveyModel.How_Did_You_hear = HowDidYou.SelectedItem;
if (!CheckValidity())
{
await DisplayAlert("Info", "Please enter all fields", "OK");
return;
}
using (Acr.UserDialogs.UserDialogs.Instance.Loading(""))
{
await Task.Delay(1000);
await LogService.LogErrorsNew(activity : "User clicked on submit on Survey two");
SurveyService.SubmitSurvey(svm);
await Navigation.PopModalAsync(true);
//ShowSurVeyThree();
};
Application.Current.Properties["SurveyTwo"] = true;
}
public ResearchController(MovimDbContext context, IOptions <AppSettings> appSettings, IHostingEnvironment env)
{
_context = context;
_appSettings = appSettings.Value;
_service = new SurveyService();
_env = env;
}
public async Task AddSurveyShouldAddOneObject()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "SurveyTest").Options;
var dbContext = new ApplicationDbContext(options);
var surveyRepo = new EfDeletableEntityRepository <Survey>(dbContext);
var opinionsRepo = new EfDeletableEntityRepository <Opinion>(dbContext);
var userOpRepo = new EfDeletableEntityRepository <UserOpinion>(dbContext);
var usersSurveys = new EfRepository <UserSurvey>(dbContext);
var service = new SurveyService(surveyRepo, opinionsRepo, userOpRepo, usersSurveys);
dbContext.Users.Add(new ApplicationUser {
Id = "123"
});
await service.AddSurveyAsync("test");
await service.AddQuestionToSurveyAsync("testQuestion", "test");
await service.AddOpinionToQuestionAsync("testQuestion", "testAnswer");
Assert.Equal(1, await dbContext.Surveys.CountAsync());
Assert.Single(service.GetAllQuestions("test"));
Assert.Equal(1, await dbContext.UserOpinions.CountAsync());
Assert.Single(service.GetAll("123"));
await service.AddSurveyToUser("123", "test");
Assert.Empty(service.GetAll("123"));
}
public ActionResult GetSurveys(SearchModel request)
{
Expression<Func<Survey, bool>> where = l => true;
if (!string.IsNullOrEmpty(request.Keyword))
where = where.And(l => l.SurveyName.Contains(request.Keyword));
var result = SurveyService.LoadPageEntities<DateTime, SurveyDto>(request.PageIndex, request.PageSize, out request.TotalCount, where, s => s.CreateTime, true).ToList();
return Table(result, request);
}
public void Post_survey()
{
SurveyService surveyService = new SurveyService(CreateSurveyStubRepository(), null, null);
Survey survey = surveyService.AddEntity(new Survey(1, "Naslov ankete 1", new DateTime(2020, 11, 6, 8, 30, 0), "Komentar ankete 1", new List <Answer>()));
Assert.NotNull(survey);
}
public IActionResult Create(SurveyDto surveyDto)
{
if (SurveyService.Create(surveyDto) == null)
{
return(BadRequest());
}
return(Ok());
}
private static Survey CreateSurvey()
{
SurveyService surveyService = new SurveyService();
Survey survey = CreateNewSurvey();
surveyService.Create(ref survey);
return(survey);
}
public void WhenIViewTheHospitalList()
{
var ratingsProcessingService = new RatingsProcessingService();
var ratingsRepository = new RatingsRepository();
var surveyService = new SurveyService(ratingsRepository, ratingsProcessingService);
var controller = new HospitalsController(surveyService);
_actionResult = controller.Index();
}
public void Get_survey_ids_for_doctor_ids()
{
MedicalExaminationService medicalExaminationService = new MedicalExaminationService(CreateMedicalExaminationStubRepository());
SurveyService surveyService = new SurveyService(CreateSurveyStubRepository(), medicalExaminationService, null);
Dictionary <int, List <int> > results = surveyService.GetSurveyIdsForDoctorIds();
Assert.Equal(2, results.Keys.Count);
}
public SurveyController()
{
this.Client.BaseAddress = new Uri("http://localhost:9080/PIDEV-web/");
this.Client.DefaultRequestHeaders.Accept.
Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
surveyservice = new SurveyService();
surquestservice = new SurveyQuestionService();
surveyquestempservice = new SurveyQuestEmpService();
}
public void Gets_survey_for_patient()
{
SetupRepositories();
SurveyService service = new SurveyService(_mockSurveyRepository.Object);
Survey survey = service.GetById(1);
Assert.NotNull(survey);
}
private void SendCurrentSurveysToNewHost(Guid targetId)
{
if (targetId != App.AppId)
{
var service = new SurveyService();
var currentSurveys = service.GetCurrentSurveys(App.AppId);
currentSurveys.Target = targetId;
Channel.CurrentSurveys(currentSurveys);
}
}
public IActionResult GetDoctorRates()
{
List <SurveyDoctorAverageDto> surveyDoctorAverage = SurveyService.GetAllDoctorAverageRates();
if (surveyDoctorAverage == null)
{
return(BadRequest());
}
return(Ok(surveyDoctorAverage));
}
public IActionResult GetRates()
{
SurveyAverageDto surveyAverage = SurveyService.GetAllAverageRates();
if (surveyAverage == null)
{
return(BadRequest());
}
return(Ok(surveyAverage));
}
