public QuestionnaireControllerTests()
{
#warning hard-coded behaviours of entities in the database
repository = new QuestionnaireRepository(null);
service = new QuestionnaireService(repository);
controller = new QuestionnaireController(service);
}
public QuestionnaireService(ILogger <QuestionnaireService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IAnswerRepository answerRepository,
IBadgeRepository badgeRepository,
INotificationRepository notificationRepository,
IQuestionRepository questionRepository,
IQuestionnaireRepository questionnaireRepository,
IRequiredQuestionnaireRepository requiredQuestionnaireRepository,
IUserLogRepository userLogRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
SetManagementPermission(Permission.ManageQuestionnaires);
_answerRepository = answerRepository
?? throw new ArgumentNullException(nameof(answerRepository));
_badgeRepository = badgeRepository
?? throw new ArgumentNullException(nameof(badgeRepository));
_notificationRepository = notificationRepository
?? throw new ArgumentNullException(nameof(notificationRepository));
_questionRepository = questionRepository
?? throw new ArgumentNullException(nameof(questionRepository));
_questionnaireRepository = questionnaireRepository
?? throw new ArgumentNullException(nameof(questionnaireRepository));
_requiredQuestionnaireRepository = requiredQuestionnaireRepository
?? throw new ArgumentNullException(nameof(requiredQuestionnaireRepository));
_userLogRepository = userLogRepository
?? throw new ArgumentNullException(nameof(userLogRepository));
}
public PhysicalExamService(
IQuestionnaireRepository questionnaireRepository,
IPatientAdmissionRepository patientAdmissionRepository)
{
_questionnaireRepository = questionnaireRepository;
_patientAdmissionRepository = patientAdmissionRepository;
}
private HomeController InitializeHomeController(out IQuestionnaireRepository repository,
out MockQuestionnaireDbContext context)
{
context = new MockQuestionnaireDbContext();
repository = new MockQuestionnaireRepository(context);
return(new HomeController(repository));
}
public UpsertQuestionnaireCommandHandler(
IQuestionnaireRepository questionnaireRepository,
IApplicationRepository applicationRepository, IAuditClient auditClient)
{
this._questionnaireRepository = questionnaireRepository;
this._applicationRepository = applicationRepository;
_auditClient = auditClient;
}
public VitalSignsService(
IObservationRepository observationRepository,
IQuestionnaireRepository questionnaireRepository
)
{
_observationRepository = observationRepository;
_questionnaireRepository = questionnaireRepository;
}
public QuestionnaireManager(IQuestionRepository questionRepository, IAnswerRepository answerRepository, IOptionRepository optionRepository, IQuestionnaireRepository questionnaireRepository, IProjectManager projectManager)
{
_questionRepository = questionRepository;
_answerRepository = answerRepository;
_optionRepository = optionRepository;
_questionnaireRepository = questionnaireRepository;
_projectManager = projectManager;
}
/// <summary>
/// BURO = Batch Update Review Outcomes
/// </summary>
/// <returns></returns>
public BuroViewModel Execute(BuroViewModel vm
, IUploadRepository uploadRepository
, IQuestionnaireRepository questionnaireRepository
, IAuditService auditService
, IReviewRepository reviewRepository)
{
var uploadList = uploadRepository.GetAll();
foreach (var upload in uploadList)
{
if (upload.AcceptedFlag)
{
continue; // once upload is accepted its over
}
var uploadId = upload.UploadId;
var reviewList = reviewRepository.GetAllByUploadId(uploadId);
foreach (var review in reviewList)
{
vm.ReviewsRead++;
IsDirty = false;
// get the questionaire data
var q = questionnaireRepository.GetReviewQuestionnaireByReviewId(review.ReviewId);
if (q == null)
{
continue;
}
var oldVals = review;
CheckForQuestionaireAssessmentOutcome(q, review);
CheckForQuestionaireRecoveryReason(q, review);
CheckForQuestionaireAssessmentAction(q, review);
CheckForQuestionaireFinalOutcome(q, review);
if (!IsDirty)
{
continue;
}
var errors = new List <IntegrityError>();
ApplyReviewModelValidations(review, errors);
if (errors.Count > 0)
{
AuditErrors(auditService, errors);
vm.ValidationErrors += errors.Count;
}
else
{
review.UpdatedBy = BuroUser;
review.UpdatedOn = DateTime.Now;
reviewRepository.Update(review);
auditService.AuditActivity(UpdateMessage(review, oldVals), BuroUser);
vm.ReviewsUpdated++;
}
}
}
return(vm);
}
public QuestionnaireUnitOfWork(
IQuestionnaireRepository repository,
IEventSender eventSender,
IDistributedCache cache,
DistributedCacheEntryOptions options,
JsonSerializerSettings serializerSettings)
: base(repository, eventSender, cache, options, serializerSettings)
{
}
/// <summary>
/// Конструктор для отправки данных на форму
/// </summary>
/// <param name="questionnaireRepo"></param>
/// <param name="respondentId"></param>
/// <param name="questionId"></param>
public QuestionnaireViewModel(IQuestionnaireRepository questionnaireRepo, int respondentId, int questionId)
{
_questionnaireRepo = questionnaireRepo;
RespondentId = respondentId;
QuestionId = questionId;
CurrentQuestion = questionnaireRepo.CalculateQuestion(QuestionId).Result;
IsThisLastQuestion = questionnaireRepo.IsLastQuestion(QuestionId).Result;
AnswerContent = questionnaireRepo.GetAnswerContent(respondentId, questionId).Result;
}
public QuestionnairesController(
IMediator mediator,
IQuestionnaireRepository questionnaireRepository,
ILogger <InvolvedPartyController> logger)
{
this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
this._questionnaireRepository = questionnaireRepository;
this._mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
}
public static HttpResponseMessage Run([HttpTrigger(AuthorizationLevel.Function, "get", Route = "sperrov1/pendingquestionnaire/{id}")] HttpRequestMessage req,
[Inject(typeof(IQuestionnaireRepository))] IQuestionnaireRepository questionnaireRepository,
int id,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
// Fetching the name from the path parameter in the request URL
return(req.CreateResponse(HttpStatusCode.OK, JsonConvert.SerializeObject(questionnaireRepository.GetById(id))));
}
public QuestionnaireListViewModel(IQuestionnaireRepository repo, FestiMSClient client, IMapper mapper, [Named("ListEv")] IEditViewModel <EventViewModel> eventVm, INetStatusService netService)
: base(client, mapper)
{
_repo = repo;
_eventVm = eventVm;
OpenPlanCommand = new RelayCommand(OpenPlan, CanPlanInspectorIn);
// ReSharper disable once VirtualMemberCallInConstructor
Refresh();
NetService = netService;
}
public CustomerDingCommandHandler(IAnswerRepository answerRepository,
ICustomerAssistDingRepository customerAssistDingRepository,
IQuestionnaireRepository questionnaireRepository,
IQuestionRepository questionRepository,
IUnitOfWork uow,
IMediatorHandler bus,
IMemoryCache cache
) : base(uow, bus, cache)
{
_answerRepository = answerRepository;
_customerAssistDingRepository = customerAssistDingRepository;
_questionnaireRepository = questionnaireRepository;
_questionRepository = questionRepository;
Bus = bus;
Cache = cache;
}
public static HttpResponseMessage Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = "sperrov1/updatedquestionnaire")] HttpRequestMessage req,
[Inject(typeof(IQuestionnaireRepository))] IQuestionnaireRepository questionnaireRepository,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
//questionnaireRepository.UpdateQuestionnaire(questionnaire);
string jsonContent = req.Content.ReadAsStringAsync().Result;
Questionnaire questionnaire = JsonConvert.DeserializeObject <Questionnaire>(jsonContent);
questionnaireRepository.Update(questionnaire);
// Fetching the name from the path parameter in the request URL
return(req.CreateResponse(HttpStatusCode.OK));
}
public HomeController(ILogger <HomeController> logger,
UserManager <IdentityUser> userManager,
IAnswerRepository answerRepository,
IQuestionnaireRepository questionnaireRepository,
IQuestionRepository questionRepository,
ICommentRepository commentRepository,
IUnitOfWork unitOfWork
)
{
_logger = logger;
this.userManager = userManager;
this.answerRepository = answerRepository;
this.questionnaireRepository = questionnaireRepository;
this.questionRepository = questionRepository;
this.commentRepository = commentRepository;
this.unitOfWork = unitOfWork;
}
public AIMAdminUnitOfWork(IAIM_DBContext context,
IApplicantQuestionAnswerRepository applicantQuestionAnswerRepository,
IApplicantRepository applicantRepository,
IApplicationRepository applicationRepository,
IAspNetRoleRepository aspNetRoleRepository,
IAspNetUserClaimRepository aspNetUserClaimRepository,
IAspNetUserLoginRepository aspNetUserLoginRepository,
IAspNetUserRepository aspNetUserRepository,
IEducationRepository educationRepository,
IEmployeeRepository employeeRepository,
IHourRepository hourRepositor,
IInterviewQuestionRepository interviewQuestionRepository,
IJobHistoryRepository jobHistoryRepository,
IJobRepository jobRepository,
IOpenJobRepository openJobRepository,
IPersonalInfoRepository personalInfoRepository,
IQuestionnaireRepository questionnaireRepository,
IQuestionRepository questionRepository,
IReferenceRepository referenceRepository,
IRegionRepository regionRepository,
IStoreRepository storeRepository,
IUserRepository userRepository) :
base(context as DbContext)
{
_applicantQuestionAnswerRepository = applicantQuestionAnswerRepository;
_applicantRepository = applicantRepository;
_applicationRepository = applicationRepository;
_aspNetRoleRepository = aspNetRoleRepository;
_aspNetUserClaimRepository = aspNetUserClaimRepository;
_aspNetUserLoginRepository = aspNetUserLoginRepository;
_aspNetUserRepository = aspNetUserRepository;
_educationRepository = educationRepository;
_employeeRepository = employeeRepository;
_hourRepository = hourRepositor;
_interviewQuestionRepository = interviewQuestionRepository;
_jobHistoryRepository = jobHistoryRepository;
_jobRepository = jobRepository;
_openJobRepository = openJobRepository;
_personalInfoRepository = personalInfoRepository;
_questionnaireRepository = questionnaireRepository;
_questionRepository = questionRepository;
_referenceRepository = referenceRepository;
_regionRepository = regionRepository;
_storeRepository = storeRepository;
_userRepository = userRepository;
}
public QuestionnaireService(ILogger <QuestionnaireService> logger,
IUserContextProvider userContextProvider,
IAnswerRepository answerRepository,
IQuestionRepository questionRepository,
IQuestionnaireRepository questionnaireRepository,
IRequiredQuestionnaireRepository requiredQuestionnaireRepository)
: base(logger, userContextProvider)
{
SetManagementPermission(Permission.ManageQuestionnaires);
_answerRepository = Require.IsNotNull(answerRepository, nameof(answerRepository));
_questionRepository = Require.IsNotNull(questionRepository,
nameof(questionRepository));
_questionnaireRepository = Require.IsNotNull(questionnaireRepository,
nameof(questionnaireRepository));
_requiredQuestionnaireRepository = Require.IsNotNull(requiredQuestionnaireRepository,
nameof(requiredQuestionnaireRepository));
}
public SupporterAppService(
ISupporterRepository supporterRepository,
ICustomerRepository customerRepository,
IServiceRepository serviceRepository,
IAnswerRepository answerRepository,
IQuestionnaireRepository questionnaireRepository,
IMapper mapper,
IMediatorHandler bus
)
{
_supporterRepository = supporterRepository;
_customerRepository = customerRepository;
_serviceRepository = serviceRepository;
_answerRepository = answerRepository;
_questionnaireRepository = questionnaireRepository;
_mapper = mapper;
Bus = bus;
}
public AvailableQuestionnaireTemplatesListViewModel(IQuestionnaireRepository questionnaireRepository, ISingleViewUIService uiService)
{
this.QuestionnaireTemplates = new ObservableCollection <QuestionnaireTemplate>();
this.questionnaireRepository = questionnaireRepository;
this.uiService = uiService;
this.QuestionnaireTemplates = new ObservableCollection <QuestionnaireTemplate>();
this.TakeSurveyCommand = new ActionCommand(o => this.TakeSurvey((QuestionnaireTemplate)o));
this.QuestionnaireTemplateSummary = new QuestionnaireTemplateSummaryViewModel(this.questionnaireRepository);
this.questionnaireRepository.GetQuestionnaireTemplatesAsync(
(result) =>
{
RefreshQuestionnaireTemplates(result.Result);
});
}
public AvailableQuestionnaireTemplatesListViewModel(IQuestionnaireRepository questionnaireRepository, ISingleViewUIService uiService)
{
this.QuestionnaireTemplates = new ObservableCollection<QuestionnaireTemplate>();
this.questionnaireRepository = questionnaireRepository;
this.uiService = uiService;
this.QuestionnaireTemplates = new ObservableCollection<QuestionnaireTemplate>();
this.TakeSurveyCommand = new ActionCommand(o => this.TakeSurvey((QuestionnaireTemplate)o));
this.QuestionnaireTemplateSummary = new QuestionnaireTemplateSummaryViewModel(this.questionnaireRepository);
this.questionnaireRepository.GetQuestionnaireTemplatesAsync(
(result) =>
{
RefreshQuestionnaireTemplates(result.Result);
});
}
private QuestionnaireService Create()
{
_userValidation = Substitute.For <IUserValidation>();
_respondentsRepository = Substitute.For <IRespondentsRepository>();
_vksocialNetworkGrabber = Substitute.For <GatheringManager <SocialNetworkDataVkontakte> >();
_fbsocialNetworkGrabber = Substitute.For <GatheringManager <SocialNetworkDataFacebook> >();
_questionnaireRepository = Substitute.For <IQuestionnaireRepository>();
_log = Substitute.For <ILogger>();
_outcomputer = Substitute.For <IOutcomeComputer>();
_congruenceOutcomeComputer = Substitute.For <CongruenceOutcomeComputer>();
return(new QuestionnaireService(_userValidation,
_respondentsRepository,
_questionnaireRepository,
_fbsocialNetworkGrabber,
_vksocialNetworkGrabber,
_log,
_outcomputer,
_congruenceOutcomeComputer
));
}
public QuestionnaireService(IUserValidation userValidation,
IRespondentsRepository respondentsRepository,
IQuestionnaireRepository questionnaireRepository,
GatheringManager <SocialNetworkDataFacebook> gfb,
GatheringManager <SocialNetworkDataVkontakte> gvk,
ILogger log,
IOutcomeComputer outcomeComputer,
CongruenceOutcomeComputer congruenceOutcomeComputer)
{
OperationContext.Current.InstanceContext.Closed += InstanceContextClosed;
_userValidation = userValidation;
_respondentsRepository = respondentsRepository;
_questionnaireRepository = questionnaireRepository;
_log = log;
_gfb = gfb;
_gvk = gvk;
_outcomeComputer = outcomeComputer;
_congruenceOutcomeComputer = congruenceOutcomeComputer;
}
public QuestionnaireViewModel(
IState <QuestionnaireTemplate> questionnaireTemplate,
IQuestionnaireRepository questionnaireRepository,
ISingleViewUIService uiService)
{
this.questionnaireRepository = questionnaireRepository;
this.uiService = uiService;
this.submitErrorInteractionRequest = new InteractionRequest <Notification>();
this.cancelConfirmationInteractionRequest = new InteractionRequest <Confirmation>();
this.Questions = new ObservableCollection <QuestionViewModel>();
this.currentState = "Normal";
this.Questionnaire = new Questionnaire(questionnaireTemplate.Value);
this.Questionnaire.PropertyChanged += this.OnQuestionnairePropertyChanged;
foreach (var question in this.Questionnaire.Questions)
{
this.Questions.Add(this.CreateQuestionViewModel(question));
}
}
public QuestionnaireViewModel(
IState<QuestionnaireTemplate> questionnaireTemplate,
IQuestionnaireRepository questionnaireRepository,
ISingleViewUIService uiService)
{
this.questionnaireRepository = questionnaireRepository;
this.uiService = uiService;
this.submitErrorInteractionRequest = new InteractionRequest<Notification>();
this.cancelConfirmationInteractionRequest = new InteractionRequest<Confirmation>();
this.Questions = new ObservableCollection<QuestionViewModel>();
this.currentState = "Normal";
this.Questionnaire = new Questionnaire(questionnaireTemplate.Value);
this.Questionnaire.PropertyChanged += this.OnQuestionnairePropertyChanged;
foreach (var question in this.Questionnaire.Questions)
{
this.Questions.Add(this.CreateQuestionViewModel(question));
}
}
public ExerciseService(IQuestionnaireRepository questionnaireRepository)
{
_questionnaireRepository = questionnaireRepository;
}
public QuestionnaireViewModel(IQuestionnaireRepository questionnaireRepository)
{
this.questionnaireRepository = questionnaireRepository;
this.Questions = new ObservableCollection<QuestionViewModel>();
this.GetNewQuestionnaireInstance();
}
public QuestionnnaireService(IQuestionnaireRepository questionnaireRepository, IMapper mapper, IUnitOfWork unitOfWork)
{
_questionnaireRepository = questionnaireRepository;
_mapper = mapper;
_unitOfWork = unitOfWork;
}
public QuestionnaireManager(IQuestionnaireRepository questionnaireRepository)
{
_questionnaireRepository = questionnaireRepository;
}
public void Setup()
{
questionnaireRepository = new QuestionnaireRepository(new ERXDBContext(db), TestHelper.InitConfiguration());
//controller = new ReservationsController(new PrimeDbContext(dbContextOptions));
}
public QuestionnaireController(IQuestionnaireRepository questionnaireRepository)
{
_questionnaireRepository = questionnaireRepository;
}
public QuestionnairesController(IQuestionnaireRepository questionnaireRepo, ILogger <Controller> logger)
{
_QuestionnaireRepo = questionnaireRepo;
_Logger = logger;
}
public QuestionnaireController()
{
_repository = new QuestionnaireRepository();
}
public QuestionnaireService(IMapper mapper, IQuestionnaireRepository questionnaireRepository)
{
_mapper = mapper;
_questionnaireRepository = questionnaireRepository;
}
public QuestionnairesQueryHandler(IQuestionnaireRepository questionnaireRepository)
{
_questionnaireRepository = questionnaireRepository;
}
public QuestionnaireTemplateSummaryViewModel(IQuestionnaireRepository questionnaireRepository)
{
this.questionnaireRepository = questionnaireRepository;
this.currentState = "Normal";
}
