public CandidateController(UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, RoleManager <IdentityRole> roleManager, ITestRepository testRepository)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.roleManager = roleManager;
this.testRepository = testRepository;
}
public CreateSiteCommandHandler(ISiteRepository siteRepository, ITestRepository testRepository, ICapPublisher capPublisher
)
{
_siteRepository = siteRepository;
_testRepository = testRepository;
_capPublisher = capPublisher;
}
public DataValidationService(IDataValidationRepository repo, IEmailConfigService emailConfigService, IEmailService emailService, ITestRepository testRepository)
{
this.repo = repo;
_emailConfigService = emailConfigService;
_emailService = emailService;
_testRepository = testRepository;
}
public void DeleteTest(int testId)
{
using (Repo = new TestRepository())
{
try
{
Repo.DeleteTest(testId);
}
catch (NullReferenceException ex)
{
throw;
}
catch (NotSupportedException ex)
{
}
catch (ObjectDisposedException ex)
{
}
catch (InvalidOperationException ex)
{
}
catch (Exception ex)
{
}
}
}
protected override void SetUp()
{
base.SetUp();
_mockedMapper = _mocks.StrictMock <IMapper <Test, TestEntity> >();
_testRepository = new TestRepository(_mockedMapper);
_uniqueItemRepository = new TestRepository(_mockedMapper);
}
public TestBusiness GetTestById(int testId)
{
Repo = new TestRepository();
Test test = null;
try
{
test = Repo.GetTest(testId);
}
catch (NullReferenceException ex)
{
throw;
}
catch (InvalidOperationException ex)
{
//TODO
}
catch (Exception ex)
{
//TODO
}
TestBusiness testBusiness = TestMapper.MapDalToBiz(test);
return(testBusiness);
}
public List <TestBusiness> GetTests()
{
Repo = new TestRepository();
var tests = Repo.GetTests();
return(tests);
}
public UserController(IUserRepository <User> userRepository, IUserService userService, IUsersListModelRepository usersListModelRepository, ITestRepository testRepository, IPodRepository podRepository, ISessionContext sessionContext,
IUniqueItemRepository <Core.Application.Domain.File> fileRepository, IMediaRepository mediaRepository, IUserLoginRepository userLoginRepository, IOrganizationRoleUserRepository organizationRoleUserRepository,
IPhysicianRepository physicianRepository, IEventStaffAssignmentRepository eventStaffAssignmentRepository, IPasswordChangelogService passwordChangelogService, IConfigurationSettingRepository configurationSettingRepository,
IMedicareApiService medicareApiService, IMedicareService medicareService, IRoleRepository roleRepository, ILogManager logManager,
IUserNpiInfoRepository userNpiInfoRepository, ISystemUserInfoRepository systemUserInfoRepository, IPinChangeLogService pinChangelogService)
{
_userRepository = userRepository;
_userService = userService;
_usersListModelRepository = usersListModelRepository;
_testRepository = testRepository;
_podRepository = podRepository;
_sessionContext = sessionContext;
_fileRepository = fileRepository;
_mediaRepository = mediaRepository;
_userLoginRepository = userLoginRepository;
_organizationRoleUserRepository = organizationRoleUserRepository;
_physicianRepository = physicianRepository;
_eventStaffAssignmentRepository = eventStaffAssignmentRepository;
_passwordChangelogService = passwordChangelogService;
_configurationSettingRepository = configurationSettingRepository;
_medicareApiService = medicareApiService;
_medicareService = medicareService;
_roleRepository = roleRepository;
_logger = logManager.GetLogger <UserController>();
_userNpiInfoRepository = userNpiInfoRepository;
_systemUserInfoRepository = systemUserInfoRepository;
_pinChangelogService = pinChangelogService;
}
public QuestionProvider(IQuestionRepository questionRepository, IModuleRepository moduleRepository, IAnswerRepository answerRepository, ITestRepository testRepository)
{
_testRepository = testRepository;
_questionRepository = questionRepository;
_moduleRepository = moduleRepository;
_answerRepository = answerRepository;
}
private static void Main(string[] args)
{
// instantiate the Test Repo
_testRepository = new TestRepository();
/*
* Object Model redesign and implementation tasks
*
* 1. Read through the object model and data used to create our test repository
* 2. Write an abstract class from which IrishCompany, SoleTrader and ForeignCompany will inherit
* 3. Write an Interface for the Address Class, implement it and refactor
* all classes which require an address to use the new interface instead.
* 4. Implement FindAllCompanies method in Test Repository
* 5. Implement NumberOfYearsEmployed property on Employment.
*/
/*
* Linq queries and Algorithms
*
* 1. Get Count of all Companies(Sole traders, Irish and Foreign Companies) in the "Database"
* 2. Write a linq query to find all Employees still employed by Company "Irish1" and write out their names
* 3. Write a query to find the total number of years that all employees (still employed or not) have worked.
*
* 4. Implement the FizzBuzz method below exactly to requirements
* 5. Implement ReverseWords to requirements, taking care that it
* doesn't fail for any of the cases in TestAlgorithms
*
*/
TestAlgorithms();
TestLinqQueries();
}
public TestGroupFactory(ITestRepository testRepository, ITestGroupRepository testGroupRepository,
TestFactory testFactory)
{
_testRepository = testRepository;
_testGroupRepository = testGroupRepository;
_testFactory = testFactory;
}
/// <summary>
/// æž„é€ å‡½æ•°è‡ªåŠ¨æ³¨å…¥
/// </summary>
/// <param name="testRepository"></param>
/// <param name="objectMapper"></param>
public TestService(ITestRepository testRepository, IObjectMapper objectMapper, ISystemSmtpSender emailSender, ILogger logger)
{
_testRepository = testRepository;
_objectMapper = objectMapper;
_emailSender = emailSender;
_logger = logger;
}
static RepositoryFactory()
{
// Is there a SQL Server database connection string?
var mysql = Environment.GetEnvironmentVariable("MYSQL_DATABASE");
if (mysql != null)
{
Console.WriteLine("Using MySQL database " + mysql.Substring(0, 50) + "...");
_testRepository = CreateMySqlRepository(mysql);
}
else
{
var sqlServer = Environment.GetEnvironmentVariable("SQLSERVER_DATABASE");
if (sqlServer != null)
{
Console.WriteLine("Using SQL Server database " + sqlServer.Substring(0, 50) + "...");
_testRepository = CreateSqlServerRepository(sqlServer);
}
else
{
// Has a sqlite database been defined? Use that.
var sqliteDb = Environment.GetEnvironmentVariable("SQLITE_DATABASE") ?? "sqlite.db";
Console.WriteLine("Using SQLite database " + sqliteDb);
_testRepository = CreateSqliteRepository(sqliteDb);
}
}
}
//private readonly ITestService _testService;
public AnswerService(IAnswerRepository answerRepository, ICandidatRepositories candidatRepositories, ITestRepository testRepository, IPositionRepository positionRepository)
{
_answerRepository = answerRepository;
_candidatRepositories = candidatRepositories;
_testRepository = testRepository;
_positionRepository = positionRepository;
}
public ResultService(ICandidateExamQuestionLogRepository candidateExamQuestionLogRepository, ICandidateExamRepository candidateExamRepository, ICandidateRepository candidateRepository, ITestRepository testRepository)
{
_candidateExamRepository = candidateExamRepository;
_candidateRepository = candidateRepository;
_testRepository = testRepository;
_candidateExamQuestionLogRepository = candidateExamQuestionLogRepository;
}
public void Setup()
{
_databaseLayer = Isolate.Fake.Instance <IDatabaseLayer>();
Isolate.Swap.NextInstance <IDatabaseLayer>().With(_databaseLayer);
_testRepository = new TestRepository(_databaseLayer);
_testService = new TestService(_testRepository);
}
public TestService(ITestRepository testRepository, IUnitOfWork unitOfWork, IMapper mapper, IStoreProcedureRepository storeProcedureRepository)
{
_testRepository = testRepository;
_unitOfWork = unitOfWork;
_mapper = mapper;
_storeProcedureRepository = storeProcedureRepository;
}
public AdminService(IQuestionRepository questionRepository, ICategoryRepository categoryRepository, ITestRepository testRepository, IMapper mapper)
{
_quesitonRepository = questionRepository;
_categoryRepository = categoryRepository;
_testRepository = testRepository;
_mapper = mapper;
}
private async Task RunTest(ITestRepository repository)
{
var result1 = repository.GetBool(1);
var result2 = await repository.GetBoolAsync(1);
var result3 = repository.GetDateTime(1);
var result4 = await repository.GetDateTimeAsync(1);
var result5 = repository.GetInt(1);
var result6 = await repository.GetIntAsync(1);
var result7 = repository.GetListObject(new ParamQuery()
{
Page = 1, Records = 2
});
var result8 = await repository.GetListObjectAsync(new ParamQuery()
{
Page = 2, Records = 4
});
var result9 = repository.GetObject(1);
var result10 = await repository.GetObjectAsync(1);
var result11 = repository.GetString(1);
var result12 = await repository.GetStringAsync(1);
}
public TestsService(ITestRepository <Test> testRepository, IUserService userService, IQuestionRepository questionRepository, ICourseRepository courseRepository)
{
this.testRepository = testRepository;
this.userService = userService;
this.questionRepository = questionRepository;
this.courseRepository = courseRepository;
}
public TestQuestionsService(IAnswersRepository answersRepository,
ITestQuestionRepository testQuestionRepository, ITestRepository testRepository)
{
this.answersRepository = answersRepository;
this.testQuestionRepository = testQuestionRepository;
this.testRepository = testRepository;
}
public TestService(
ITestRepository testRepository,
IUnitOfWork unitOfWork)
{
this.testRepository = testRepository;
this.unitOfWork = unitOfWork;
}
public static RunHistory IncludeTest(this RunHistory runHistory, ITestRepository testRepository)
{
if (runHistory.Test != null) return runHistory;
if (runHistory.TestId != null)
runHistory.Test = testRepository.GetDataById((int) runHistory.TestId).ToList().First();
return runHistory;
}
public FirstViewModel(
INavigationService navigationService,
ILogger logger,
ITestRepository testRepository,
IPlatformService platformService,
IMessagingService messagingService,
IConnectivityHelper connectivityHelper,
IDialogService dialogService,
IAppAnalyticsProvider appAnalyticProvider) : base(navigationService, logger)
{
_testRepository = testRepository;
_platformService = platformService;
_messagingService = messagingService;
_connectivityHelper = connectivityHelper;
_dialogService = dialogService;
_appAnalyticsProvider = appAnalyticProvider;
OkCancelAlertResponse = false;
OSVersion = $"{_platformService.OsVersion.Major}.{_platformService.OsVersion.Minor}.{_platformService.OsVersion.Build}";
IsConnected = connectivityHelper.IsConnected;
logger.Verbose("First ViewModel", null, new[] { LoggerConstants.UiAction });
logger.Verbose("OS Version", new { OSVersion }, new[] { LoggerConstants.UiAction });
ShowDialog = new Command(DisplayProgressDialog);
DisplayCancelAlert = new Command(DisplayAlertWithCancleButton);
DisplayOkCancelAlert = new Command(DisplayAlertWithOkCancleButton);
ShowModalPopupDialog = new Command(ShowModalPopup);
CrashAppCommand = new Command(() => { throw new Exception("Test Exception to crash app"); });
}
public MainWindow()
{
InitializeComponent();
// Review TK: Please try to avoid tight coupling.
generator = new WindowGenerator(this);
string connectionString = ConfigurationManager.ConnectionStrings["EnglishJediConnection"].ConnectionString;
try
{
_testRepository = new TestRepository(connectionString);
// Review TK: Please use {} with if statement.
if (_testRepository == null)
{
throw new NoConnectionToDBException();
}
_markRepository = new MarkRepository(connectionString);
if (_markRepository == null)
{
throw new NoConnectionToDBException();
}
}
catch (NoConnectionToDBException e)
{
MessageBox.Show("Lost connection to DB! " + e.Message);
}
}
public TestGroupFactory(ITestRepository testRepository, ITestGroupRepository testGroupRepository,
TestFactory testFactory)
{
_testRepository = testRepository;
_testGroupRepository = testGroupRepository;
_testFactory = testFactory;
}
public TestService(ITestRepository testRepository, IRoomRepository roomRespository, IAttemptRepository attemptRepository, IWorkContext workContext)
{
_testRepository = testRepository;
_roomRepository = roomRespository;
_attemptRepository = attemptRepository;
_workContext = workContext;
}
public ExaminerController(ITestRepository testRepository, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, RoleManager <IdentityRole> roleManager)
{
this.testRepository = testRepository;
this.userManager = userManager;
this.signInManager = signInManager;
this.roleManager = roleManager;
}
public DefensiveCacheImplemented(
ITestRepository repository,
IDistributedCache distributedCache)
{
_testRepository = repository;
_distributedCache = distributedCache;
}
public TestService(IOptions <PaginationOptions> options, ITestRepository testRepository,
ITestRepositoryVal testRepositoryVal)
{
_paginationOptions = options.Value;
_testRepository = testRepository;
_testRepositoryVal = testRepositoryVal;
}
public TestService(ITestRepository testRepositpry, IAccountService accountService, IWorkTestRepository workTestRepository)
{
this.testRepository = testRepositpry;
this.accountService = accountService;
this.workTestRepository = workTestRepository;
this.random = new Random((int)DateTime.Now.Ticks);
}
public StudentGetAllTestsQueryHandler(ITestRepository testRepository, IEnrolementRepository enrolementRepository, IMapper mapper)
{
_testRepository = testRepository ?? throw new ArgumentNullException(nameof(testRepository));
_enrolementRepository = enrolementRepository ?? throw new ArgumentNullException(nameof(enrolementRepository));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public CustomerCheckListService(ICustomerRepository customerRepository, IEventCustomerRepository eventCustomerRepository, IEventCustomerPreApprovedTestRepository eventCustomerPreApprovedTestRepository,
ICheckListQuestionRepository checkListQuestionRepository, ICheckListAnswerRepository checkListAnswerRepository, ICheckListQuestionAnswerEditModelFactory checkListQuestionAnswerEditModelFactory,
IEventCustomerResultRepository eventCustomerResultRepository, ICheckListTemplateRepository checkListTemplateRepository, ICorporateAccountRepository corporateAccountRepository,
ICheckListGroupRepository checkListGroupRepository, IMedicareApiService medicareApiService, ILogManager logManager, ISettings settings,
IOrderRepository orderRepository, IOrderController orderController, IEventPackageRepository eventPackageRepository, IEventTestRepository eventTestRepository,
ITestRepository testRepository, IAccountNotReviewableTestRepository accountNotReviewableTestRepository, IEventRepository eventRepository, IEventPodRepository eventPodRepository, IEventPodRoomRepository eventPodRoomRepository)
{
_customerRepository = customerRepository;
_eventCustomerRepository = eventCustomerRepository;
_eventCustomerPreApprovedTestRepository = eventCustomerPreApprovedTestRepository;
_checkListQuestionRepository = checkListQuestionRepository;
_checkListAnswerRepository = checkListAnswerRepository;
_checkListQuestionAnswerEditModelFactory = checkListQuestionAnswerEditModelFactory;
_eventCustomerResultRepository = eventCustomerResultRepository;
_checkListTemplateRepository = checkListTemplateRepository;
_corporateAccountRepository = corporateAccountRepository;
_checkListGroupRepository = checkListGroupRepository;
_medicareApiService = medicareApiService;
_settings = settings;
_orderRepository = orderRepository;
_orderController = orderController;
_eventPackageRepository = eventPackageRepository;
_eventTestRepository = eventTestRepository;
_testRepository = testRepository;
_accountNotReviewableTestRepository = accountNotReviewableTestRepository;
_eventRepository = eventRepository;
_eventPodRepository = eventPodRepository;
_eventPodRoomRepository = eventPodRoomRepository;
_logger = logManager.GetLogger <CustomerCheckListService>();
}
public TestController(ITestRepository dbTestRepository, ITestTypeRepository dbTestTypeRepository,
IProjectRepository dbProjectRepository, ITestGroupRepository dbTestGroupRepository)
{
_dbTestRepository = dbTestRepository;
_dbTestTypeRepository = dbTestTypeRepository;
_dbProjectRepository = dbProjectRepository;
_dbTestGroupRepository = dbTestGroupRepository;
}
public ProjectFactory(IProjectRepository projectRepository, ITestRepository testRepository,
ITestGroupRepository testGroupRepository, TestFactory testFactory)
{
_projectRepository = projectRepository;
_testRepository = testRepository;
_testGroupRepository = testGroupRepository;
_testFactory = testFactory;
}
public HomeController(IUnitOfWork unitOfWork, ITestRepository testRepository, ITodoRepository repository, ITestService testService)
{
_repository = repository;
_testService = testService;
_testRepository = testRepository;
_unitOfWork = unitOfWork;
}
public TestFactory(ITestRepository testRepository, ITestTypeRepository testTypeRepository,
IExpectedResultRepository expectedResultRepository, IAssertTypeRepository assertTypeRepository)
{
_testRepository = testRepository;
_testTypeRepository = testTypeRepository;
_expectedResultRepository = expectedResultRepository;
_assertTypeRepository = assertTypeRepository;
}
public ExpectedResultController(IExpectedResultRepository dbExpectedResultRepository,
ITestRepository dbTestRepository, IExpectedResultTypeRepository dbExpectedResultTypeRepository,
IAssertTypeRepository dbAssertTypeRepository)
{
_dbExpectedResultRepository = dbExpectedResultRepository;
_dbTestRepository = dbTestRepository;
_dbExpectedResultTypeRepository = dbExpectedResultTypeRepository;
_dbAssertTypeRepository = dbAssertTypeRepository;
}
public TestService(ITestRepository testRepository, ICardRepository cardRepository,
IFeedbackRepository feedbackRepository, IUnitOfWork unitOfWork,ILogger logger,
IUserProfileRepository userProfileRepository)
{
_testRepository = testRepository;
_cardRepository = cardRepository;
_unitOfWork = unitOfWork;
_logger = logger;
_feedbackRepository = feedbackRepository;
_userProfileRepository = userProfileRepository;
}
public CardService(ICardRepository cardRepository, IUserProfileRepository userProfileRepository, IUnitOfWork unitOfWork, ILogger logger, IActivityHelperService activityHelperService, ISpecialNoteRepository specialNoteRepository, IFeedbackRepository feedbackRepository, IInterviewRepository interviewRepository, ITestRepository testRepository)
{
_cardRepository = cardRepository;
_userProfileRepository = userProfileRepository;
_unitOfWork = unitOfWork;
_logger = logger;
_activityHelperService = activityHelperService;
_specialNoteRepository = specialNoteRepository;
_feedbackRepository = feedbackRepository;
_interviewRepository = interviewRepository;
_testRepository = testRepository;
}
public TestResultService()
{
var context = new StudyItContext();
this.testResultRepo = new TestResultRepository(context);
this.testRepo = new TestRepository(context);
}
public TestResultService(ITestResultRepository testResultRepo, ITestRepository testRepo)
{
this.testResultRepo = testResultRepo;
this.testRepo = testRepo;
}
public TestPlanRepository(RedisClient client, string baseDir, string dbKey)
{
repo = new RedisTestRepository(client, baseDir, dbKey);
planInfos = new RedisInfoCollection<TestPlanInfo>(client, () => new TestPlanInfo());
}
public TestService(ITestRepository testRepo)
{
this.testRepo = testRepo;
}
public DefaultTestService(ITestRepository repository)
{
Repository = repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="TestService"/> class.
/// </summary>
/// <param name="testRepository">The test repository.</param>
public TestService(ITestRepository testRepository)
{
_testRepository = testRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="TestRepositoryCommands"/> class.
/// </summary>
public TestRepositoryCommands()
{
_repository = new TestRepository();
}
public HomeController(ITestRepository repository)
{
this.repository = repository;
}
public ArrayInjectionService(ITestRepository[] repositories)
{
_repositories = repositories;
}
public static TestValueType IncludeTests(this TestValueType testValueType, ITestRepository testRepository)
{
if (testValueType.Tests != null) return testValueType;
testValueType.Tests = (TestList)testRepository.GetDataByTestValueTypeId(testValueType.Id);
return testValueType;
}
public ClassScheduleController(IAddDropRepository addDropRepository, ITestRepository testRepository)
{
repository = addDropRepository;
repo = testRepository;
}
public TestService1(ITestRepository repository)
{
Repository = repository;
}
public TestFacade(ITestRepository testRepository)
{
_testRepository = testRepository;
}
public TestService(ITestRepository testRepository,
IAdmintypeRepository admintypeRepository)
{
this._testRepository = testRepository;
this._admintypeRepository = admintypeRepository;
}
public TestService(ITestRepository repository)
{
_repository = repository;
}
public RunHistoryController(IRunHistoryRepository dbRunHistoryRepository, ITestRepository dbTestRepository)
{
_dbRunHistoryRepository = dbRunHistoryRepository;
_dbTestRepository = dbTestRepository;
}
public TestService2(ITestRepository repository)
{
this.Repository = repository;
}
public TestFacadeTest()
{
_testRepository = Substitute.For<ITestRepository>();
_testFacade = new TestFacade(_testRepository);
}
public TestApiController(ITestRepository dbRepository)
{
_dbRepository = dbRepository;
}
public TestService()
{
this.testRepo = new TestRepository(new StudyItContext());
}
