public SchedulerService(IBus bus, IRawByteBus rawByteBus, ILog log, IScheduleRepository scheduleRepository)
{
this.bus = bus;
this.scheduleRepository = scheduleRepository;
this.rawByteBus = rawByteBus;
this.log = log;
}
public SchedulerService(IBus bus, IEasyNetQLogger log, IScheduleRepository scheduleRepository, ISchedulerServiceConfiguration configuration)
{
this.bus = bus;
this.log = log;
this.scheduleRepository = scheduleRepository;
this.configuration = configuration;
}
public ScheduleController(IPierRepository pierRepository, IRouteRepository routeRepository, IScheduleRepository scheduleRepository)
{
this.pierRepository = pierRepository;
this.routeRepository = routeRepository;
this.scheduleRepository = scheduleRepository;
ViewBag.Piers = pierRepository.List();
ViewBag.Routes = routeRepository.List();
}
public ProgramService(IProgramRepository iProgramRepository, IHelper iHelper,
IProductRepository iProductRepository,
ISaleRepository iSaleRepository,
IScheduleRepository iScheduleRepository)
{
_iProgramRepository = iProgramRepository;
_iHelper = iHelper;
_iProductRepository = iProductRepository;
_iSaleRepository = iSaleRepository;
_iScheduleRepository = iScheduleRepository;
}
public SchedulerService(
IBus bus,
IRawByteBus rawByteBus,
IEasyNetQLogger log,
IScheduleRepository scheduleRepository,
Func<DateTime> now)
{
this.bus = bus;
this.scheduleRepository = scheduleRepository;
this.now = now;
this.rawByteBus = rawByteBus;
this.log = log;
}
public PredictionService(IProgramRepository iProgramRepository,
IProductRepository iProductRepository,
IScheduleRepository iScheduleRepository,
ISaleRepository iSaleRepository,
ICategoryRepository iCategoryRepository)
{
_iProgramRepository = iProgramRepository;
_iScheduleRepository = iScheduleRepository;
_iSaleRepository = iSaleRepository;
_iCategoryRepository = iCategoryRepository;
_iProductRepository = iProductRepository;
allPrograms = _iProgramRepository.All.ToList();
allProducts = _iProductRepository.All.ToList();
allCategorys = _iCategoryRepository.All.ToList();
allSales = _iSaleRepository.All.ToList();
allSchedules = _iScheduleRepository.All.ToList();
}
public void SetUp()
{
bus = MockRepository.GenerateStub<IBus>();
advancedBus = MockRepository.GenerateStub<IAdvancedBus>();
bus.Stub(x => x.IsConnected).Return(true);
bus.Stub(x => x.Advanced).Return(advancedBus);
scheduleRepository = MockRepository.GenerateStub<IScheduleRepository>();
schedulerService = new SchedulerService(
bus,
MockRepository.GenerateStub<IEasyNetQLogger>(),
scheduleRepository,
new SchedulerServiceConfiguration
{
PublishIntervalSeconds = 1,
PurgeIntervalSeconds = 1
});
}
public void SetUp()
{
bus = MockRepository.GenerateStub<IBus>();
advancedBus = MockRepository.GenerateStub<IAdvancedBus>();
channel = MockRepository.GenerateStub<IAdvancedPublishChannel>();
bus.Stub(x => x.IsConnected).Return(true);
bus.Stub(x => x.Advanced).Return(advancedBus);
advancedBus.Stub(x => x.OpenPublishChannel()).Return(channel);
scheduleRepository = MockRepository.GenerateStub<IScheduleRepository>();
schedulerService = new SchedulerService(
bus,
new ConsoleLogger(),
scheduleRepository,
new SchedulerServiceConfiguration
{
PublishIntervalSeconds = 1,
PurgeIntervalSeconds = 1
});
}
public SchedulePoller(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IScheduleRepository scheduleRepository, IAzureSessionService azureSessionService, IUserRepository userRepository)
{
this.organizationRepository = organizationRepository ?? throw new ArgumentNullException(nameof(organizationRepository));
this.projectRepository = projectRepository ?? throw new ArgumentNullException(nameof(projectRepository));
this.scheduleRepository = scheduleRepository ?? throw new ArgumentNullException(nameof(scheduleRepository));
this.azureSessionService = azureSessionService ?? throw new ArgumentNullException(nameof(azureSessionService));
this.userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
}
public CreateScheduleCommandHandler(IScheduleRepository repository)
{
_repository = repository;
}
public ScheduleService(MedicalClinicDbContext context, IMapper mapper)
{
_repository = new ScheduleRepository(context);
_mapper = mapper;
}
public ScheduleService(IScheduleRepository scheduleRepository)
{
_scheduleRepository = scheduleRepository;
}
public void TestInitialize()
{
_scheduleRepository = new ScheduleRepository();
}
public SchedulesController(IScheduleRepository scheduleRepository, IConferenceRepository conferenceRepository)
{
_scheduleRepository = scheduleRepository;
_conferenceRepository = conferenceRepository;
}
public ScheduleService(IScheduleRepository iScheduleRepository, IHelper iHelper, ICycleRepository iCycleRepository)
{
_iScheduleRepository = iScheduleRepository;
_iHelper = iHelper;
_iCycleRepository = iCycleRepository;
}
public AddScheduleUseCase(IScheduleRepository scheduleRepository)
{
_scheduleRepository = scheduleRepository;
}
public ScheduleFetchUseCase(
IScheduleRepository scheduleRepository)
{
_scheduleRepository = scheduleRepository;
}
public ScheduleController(IScheduleRepository Schedules, ILogManager logger)
{
this.Schedules = Schedules;
this.logger = logger;
}
public CompleteItemCommandHandler(IScheduleRepository scheduleRepository)
{
_repository = scheduleRepository;
}
public ScheduleCreateCommandHandler(IScheduleRepository scheduleRepository, IMapper mapper)
{
_scheduleRepository = scheduleRepository;
_mapper = mapper;
}
public ScheduleService(IScheduleRepository repository)
{
this.repository = repository;
}
public ScheduleController(IScheduleRepository scheduleRepository)
{
this.scheduleRepository = scheduleRepository;
}
public SchedulesController(IScheduleRepository scheduleRepository, IMapper mapper)
{
_scheduleRepository = scheduleRepository;
_mapper = mapper;
}
public MyScheduleManager(IScheduleRepository scheduleRepository, List<Session> sessions)
{
_scheduleRepository = scheduleRepository;
_sessions = sessions;
}
public ScheduleLogic(ILoggerManager logger, IScheduleRepository scheduleRepository, IMapper mapper)
{
_logger = logger;
_repository = scheduleRepository;
_mapper = mapper;
}
public ScheduleController()
{
repository = new ScheduleRepository();
}
public SchedulesController(IScheduleRepository scheduleRepository, IAttendeeRepository attendeeRepository, IUserRepository userRepository)
{
_scheduleRepository = scheduleRepository;
_userRepository = userRepository;
_attendeeRepository = attendeeRepository;
}
public SchedulesController(IUserRepository _userRepository, IScheduleRepository _scheduleRepository, AppDbContext _db)
{
scheduleRepository = _scheduleRepository;
userRepository = _userRepository;
db = _db;
}
public ClassRepository(AppDbContext context, IScheduleRepository scheduleRepo)
{
_context = context;
_scheduleRepo = scheduleRepo;
}
public ScheduleController(IScheduleRepository scheduleRepository)
{
this.scheduleRepository = scheduleRepository;
}
public ScheduleService(ITelegramBotClient client)
{
_scheduleRepository = new EFScheduleRepository();
_client = client;
}
//private readonly DataContext _context;
//public SchedulesController(DataContext context)
//{
// _context = context;
//}
public SchedulesController(IScheduleRepository scheduleRepository)
{
_scheduleRepository = scheduleRepository;
}
public void Start()
{
Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof (Program))));
new ConnectionStringService().Approve();
_container.Register(Component.For<IDatabaseConnectionCache>()
.ImplementedBy<ThreadStaticDatabaseConnectionCache>());
_container.Register(Component.For<IDbConnectionConfiguration>()
.ImplementedBy<DbConnectionConfiguration>());
_container.Register(Component.For<IDbConnectionConfigurationProvider>()
.ImplementedBy<DbConnectionConfigurationProvider>());
_container.Register(Component.For<IDatabaseGateway>().ImplementedBy<DatabaseGateway>());
_container.Register(Component.For<IDatabaseConnectionFactory>().ImplementedBy<DatabaseConnectionFactory>());
_container.Register(Component.For(typeof (IDataRepository<>)).ImplementedBy(typeof (DataRepository<>)));
_container.Register(
Classes
.FromAssemblyNamed("Shuttle.Core.Data")
.Pick()
.If(type => type.Name.EndsWith("Factory"))
.Configure(configurer => configurer.Named(configurer.Implementation.Name.ToLower()))
.WithService.Select((type, basetype) => new[] {type.InterfaceMatching(@".*Factory\Z")}));
const string shuttleScheduling = "Shuttle.Scheduling";
_container.Register(
Classes
.FromAssemblyNamed(shuttleScheduling)
.BasedOn(typeof (IDataRowMapper<>))
.WithServiceFirstInterface());
_container.Register(
Classes
.FromAssemblyNamed(shuttleScheduling)
.Pick()
.If(type => type.Name.EndsWith("Repository"))
.WithServiceFirstInterface());
_container.Register(
Classes
.FromAssemblyNamed(shuttleScheduling)
.Pick()
.If(type => type.Name.EndsWith("Query"))
.WithServiceFirstInterface());
_container.Register(
Classes
.FromAssemblyNamed(shuttleScheduling)
.Pick()
.If(type => type.Name.EndsWith("Factory"))
.WithServiceFirstInterface());
_container.Register(
Classes
.FromAssemblyNamed(shuttleScheduling)
.Pick()
.If(type => type.Name.EndsWith("DomainHandler"))
.WithServiceFirstInterface());
DomainEvents.Assign(new DomainEventDispatcher(_container));
_bus = ServiceBus.Create(c => c
.SubscriptionManager(SubscriptionManager.Default())
.AddModule(new ActiveTimeRangeModule()))
.Start();
_container.Register(Component.For<IServiceBus>().Instance(_bus).LifestyleSingleton());
_repository = _container.Resolve<IScheduleRepository>();
_databaseConnectionFactory = _container.Resolve<IDatabaseConnectionFactory>();
_thread = new Thread(ProcessSchedule);
_thread.Start();
}
public ScheduleService(IScheduleRepository repo)
{
scheduleRepository = repo;
}
public ScheduleCommandHandler(IScheduleRepository scheduleRepository, IMediatorHandler bus) : base(bus)
{
_scheduleRepository = scheduleRepository;
_bus = bus;
}
public ScheduleService(IScheduleRepository _ScheduleRepository)
{
this._ScheduleRepository = _ScheduleRepository;
}
public ScheduleController(IScheduleRepository scheduleRepository, IMovieRepository movieRepository)
{
this.scheduleRepository = scheduleRepository;
this.movieRepository = movieRepository;
}
public AppointmentsController(IScheduleRepository scheduleRepository, IApplicationSettings settings)
{
this._scheduleRepository = scheduleRepository;
this._settings = settings;
}
public ScheduleCommandHandler(IScheduleRepository scheduleRepository)
{
this.scheduleRepository = scheduleRepository ?? throw new ArgumentNullException(nameof(scheduleRepository));
}
private static void SetRelatedRecordingsToNull(int idSchedule, IScheduleRepository scheduleRepository)
{
// todo : since "on delete: set null" is not currently supported in EF, we have to do this manually - remove this ugly workaround once EF gets mature enough.
var schedules = scheduleRepository.GetQuery<Schedule>(s => s.IdSchedule == idSchedule);
schedules = scheduleRepository.IncludeAllRelations(schedules);
Schedule schedule = schedules.FirstOrDefault();
if (schedule != null)
{
//scheduleRepository.DeleteList(schedule.Recordings);
for (int i = schedule.Recordings.Count - 1; i >= 0; i--)
{
Recording recording = schedule.Recordings[i];
recording.IdSchedule = null;
}
scheduleRepository.ApplyChanges<Schedule>(scheduleRepository.ObjectContext.Schedules, schedule);
}
}
public SchedulesController()
{
_scheduleRepository = new ScheduleEfRepository(new ConferenceContext());
}
public void Start()
{
XmlConfigurator.Configure();
Log.Assign(new Log4NetLog(LogManager.GetLogger(typeof (Program))));
ConnectionStrings.Approve();
container.RegisterSingleton("Shuttle.Core.Infrastructure", RegexPatterns.EndsWith("Factory"));
container.RegisterSingleton("Shuttle.Core.Infrastructure", RegexPatterns.EndsWith("Mapper"));
container.RegisterDataAccessCore();
container.RegisterDataAccessDefaults();
container.Register(Component.For<IDatabaseConnectionCache>().ImplementedBy<ThreadStaticDatabaseConnectionCache>());
container.RegisterDataAccess("Shuttle.Scheduling");
container.RegisterSingleton("Shuttle.Scheduling", RegexPatterns.EndsWith("Factory"));
container.RegisterSingleton("Shuttle.Scheduling", RegexPatterns.EndsWith("DomainHandler"));
DomainEvents.Assign(new DomainEventDispatcher(container));
bus = ServiceBus
.Create()
.SubscriptionManager(SubscriptionManager.Default())
.AddModule(new ActiveTimeRangeModule())
.Start();
container.Register(bus);
repository = container.Resolve<IScheduleRepository>();
databaseConnectionFactory = container.Resolve<IDatabaseConnectionFactory>();
thread = new Thread(ProcessSchedule);
thread.Start();
}
public ScheduleUC(IScheduleRepository ScheduleRepository)
{
scheduleRepository = ScheduleRepository;
}
public AppointmentsController(IScheduleRepository scheduleRepository, IApplicationSettings settings)
{
this._scheduleRepository = scheduleRepository;
this._settings = settings;
}
public OfficialRostersController(IAccountService accountService, IRosterService rosterService, UserManager <UserEntity> userManager,
ILogger logger, IScheduleService scheduleService, IMatchDetailService matchDetailService,
ISummonerInfoRepository summonerInfoRepository, IScheduleRepository scheduleRepository,
IGameInfoService gameInfoService)
{
_accountService = accountService ?? throw new ArgumentNullException(nameof(accountService));
_rosterService = rosterService ?? throw new ArgumentNullException(nameof(rosterService));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_scheduleService = scheduleService ?? throw new ArgumentNullException(nameof(scheduleService));
_matchDetailService = matchDetailService ?? throw new ArgumentNullException(nameof(matchDetailService));
_summonerInfoRepository = summonerInfoRepository ?? throw new ArgumentNullException(nameof(summonerInfoRepository));
_scheduleRepository = scheduleRepository ?? throw new ArgumentNullException(nameof(scheduleRepository));
_gameInfoService = gameInfoService ?? throw new ArgumentNullException(nameof(gameInfoService));
}
public ScheduleController(IScheduleRepository repository)
{
this.repository = repository;
}
public InspectorAvailabilityViewModel(IUserRepository userRepository, IAvailabilityRepository availabilityRepository, IScheduleRepository scheduleRepository)
{
_availabilityRepository = availabilityRepository;
_scheduleRepository = scheduleRepository;
// SelectedItems = selectedItems;
AnswerCollection = new ObservableCollection <string>();
SelectedEmployees = new ObservableCollection <Employee>();
EmployeeList = new ObservableCollection <Employee>();
userRepository.All()
.Where(x => x != null)
.Select(x => x).Distinct()
.ToList().ForEach(EmployeeList.Add);
//SelectedItems.CollectionChanged += SelectedItems_CollectionChanged;
var curDir = Directory.GetCurrentDirectory();
WebBrowserUri = $"file:///{curDir}/WebFiles/AvailabilityInspectors.html";
GenerateCommand = new RelayCommand <WebBrowser>(generate);
}
public EventController()
{
_eventRepository = new EFEventRepository();
_scheduleRepository = new EFScheduleRepository();
}
public ScheduleService(IDomainEventDispatcher domainEventDispatcher,
IScheduleRepository scheduleRepository)
{
_domainEventDispatcher = domainEventDispatcher;
_scheduleRespository = scheduleRepository;
}
public EventController(IEventRepository eventRepository, IScheduleRepository scheduleRepository)
{
_eventRepository = eventRepository;
_scheduleRepository = scheduleRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScheduleUnitOfWork"/> class.
/// </summary>
/// <param name="repository">The repository.</param>
public ScheduleUnitOfWork(IScheduleRepository repository)
{
this.repository = repository;
}
