public override void SetUp()
{
base.SetUp();
handlingEventRepository = new HandlingEventRepositoryHibernate();
cargoRepository = new CargoRepositoryHibernate();
locationRepository = new LocationRepositoryHibernate();
}
public BookingService(ILocationRepository locationRepository, ICargoRepository cargoRepository, IRoutingService routingService, CargoDataAccess cargoDataAccess)
{
_locationRepository = locationRepository;
_cargoRepository = cargoRepository;
_routingService = routingService;
_cargoDataAccess = cargoDataAccess;
}
public ProfileController()
{
_profileRepo = EntityProfileRepository.Instance;
_locationRepo = EntityLocationRepository.Instance;
_feedRepo = EntityActivityRepository.Instance;
_favRepo = EntityFavoriteRepository.Instance;
}
public RoutingService(ILocationRepository locatinRepository, IGraphTraversalService graphTraversalService, ICustomerAgreementRepository agreementRepository, IVoyageRepository voyageRepository)
{
_locatinRepository = locatinRepository;
_voyageRepository = voyageRepository;
_graphTraversalService = graphTraversalService;
_agreementRepository = agreementRepository;
}
public RestaurantService(ILocationRepository locationRepo)
{
locationRepository = locationRepo;
placesRepository = new PlacesRepository();
foodRepository = new FoodRepository();
itemsToSelect = new List<SelectListItem>();
}
public Engine(ILocationRepository locationRepository)
{
if (locationRepository == null)
throw new ArgumentNullException("locationRepository");
_locationRepository = locationRepository;
}
public BookingServiceFacade(PipelineFactory pipelineFactory, ILocationRepository locationRepository, ICargoRepository cargoRepository, CargoRoutingDTOAssembler cargoRoutingAssembler)
{
_pipelineFactory = pipelineFactory;
_cargoRoutingAssembler = cargoRoutingAssembler;
_cargoRepository = cargoRepository;
_locationRepository = locationRepository;
}
public ApartmentController(IApartmentRepository aRepo, ILocationRepository lRepo, IContext con, IImageRepository img)
{
AptRepo = aRepo;
LocRepo = lRepo;
context = con;
imageRepo = img;
}
public BookingService(ILocationRepository locationRepository, ICargoRepository cargoRepository, IRoutingService routingService, ICustomerRepository customerRepository)
{
_locationRepository = locationRepository;
_customerRepository = customerRepository;
_cargoRepository = cargoRepository;
_routingService = routingService;
}
public LocationSearchPostcodeService(ILocationRepository repository, ILocationQueryValidator queryValidator, ILocationQuerySanitiser postCodeSanitiser, ILocationModelMapper locationModelMapper)
: base(queryValidator)
{
_repository = repository;
_postCodeSanitiser = postCodeSanitiser;
_locationModelMapper = locationModelMapper;
}
public BookingServiceFacade(IBookingService bookingService, ILocationRepository locationRepository, RouteCandidateDTOAssember routeCandidateAssembler, CargoDataAccess cargoDataAccess)
{
_bookingService = bookingService;
_cargoDataAccess = cargoDataAccess;
_routeCandidateAssembler = routeCandidateAssembler;
_locationRepository = locationRepository;
}
public LocationProvider(ISensorDatasProvider sdp, ILocationRepository locations)
{
if (sdp == null) throw new ArgumentNullException("sdp","ISensorDataProvider dependency should be provided");
if (locations == null) throw new ArgumentNullException("locations", "Repository dependency should be provided");
_sdp = sdp;
_locations = locations;
}
public override void SetUp()
{
base.SetUp();
var db = Utils.ShippingDb;
handlingEventRepository = new HandlingEventRepositoryMongo(db);
cargoRepository = new CargoRepositoryMongo(db);
locationRepository = new LocationRepositoryMongo(db);
}
public HomeLocationUpdater(IPermissionRepository permissionRepository, ILocationRepository locationRepository)
{
if (permissionRepository == null) throw new ArgumentNullException(nameof(permissionRepository));
if (locationRepository == null) throw new ArgumentNullException(nameof(locationRepository));
_permissionRepository = permissionRepository;
_locationRepository = locationRepository;
}
public BookingService(ICargoRepository cargoRepository,
ILocationRepository locationRepository,
IRoutingService routingService)
{
this.cargoRepository = cargoRepository;
this.locationRepository = locationRepository;
this.routingService = routingService;
}
public BootcampLocationController(IBootcampLocationsRepository bootcampLocationsRepo,
IBootcampRepository bootcampRepo,
ILocationRepository locationRepo)
{
_bootcampLocationsRepo = bootcampLocationsRepo;
_bootcampRepo = bootcampRepo;
_locationRepo = locationRepo;
}
public HandlingEventFactory(ICargoRepository cargoRepository,
IVoyageRepository voyageRepository,
ILocationRepository locationRepository)
{
this.cargoRepository = cargoRepository;
this.voyageRepository = voyageRepository;
this.locationRepository = locationRepository;
}
public BootcampsController(IBootcampRepository bootcampRepo,
ILocationRepository locationRepo,
ITechnologyRepository techRepo)
{
_bootcampRepo = bootcampRepo;
_locationRepo = locationRepo;
_techRepo = techRepo;
}
public BookingServiceFacade(IBookingService bookingService, ILocationRepository locationRepository, ICargoRepository cargoRepository, RouteCandidateDTOAssember routeCandidateAssembler, CargoRoutingDTOAssembler cargoRoutingAssembler)
{
_bookingService = bookingService;
_cargoRoutingAssembler = cargoRoutingAssembler;
_routeCandidateAssembler = routeCandidateAssembler;
_cargoRepository = cargoRepository;
_locationRepository = locationRepository;
}
public LocationsController(ILocationsQueryCache locationsQueryCache, ILocationRepository locationRepository)
{
Contract.Requires<ArgumentNullException>(locationsQueryCache != null, "locationsQueryCache");
Contract.Requires<ArgumentNullException>(locationRepository != null, "loactionRepository");
_locationsQueryCache = locationsQueryCache;
_locationRepository = locationRepository;
}
public TenantController(ILandlordRepository ll, IApartmentRepository a,
ILocationRepository lo, ITenantRepository t, IContext con)
{
TRepo = t;
AptRepo = a;
LocRepo = lo;
LLRepo = ll;
context = con;
}
public LocationController(IGenericRepository genericRepository,
IMapper<CreateModel, Location> createModelToLocationMapper,
IMapper<Location, IndexModel> locationToIndexModelMapper,
ILocationRepository locationRepository)
{
_genericRepository = genericRepository;
_createModelToLocationMapper = createModelToLocationMapper;
_locationToIndexModelMapper = locationToIndexModelMapper;
_locationRepository = locationRepository;
}
public SetHomeLocationViewModel(ILocationRepository locationRepository)
{
if (locationRepository == null) throw new ArgumentNullException(nameof(locationRepository));
_locationRepository = locationRepository;
SaveCommand = new TransactionalCommandTask(Save, CanSave);
PropertyChanged += SetHomeLocationViewModel_PropertyChanged;
}
public BookingServiceFacade(IBookingService bookingService,
ICargoRepository cargoRepository,
ILocationRepository locationRepository,
IVoyageRepository voyageRepository)
{
BookingService = bookingService;
CargoRepository = cargoRepository;
LocationRepository = locationRepository;
VoyageRepository = voyageRepository;
}
public LocationController(ILandlordRepository ll, IApartmentRepository a,
ILocationRepository lo, ITenantRepository t, IContext con, IImageRepository img)
{
TRepo = t;
AptRepo = a;
LocRepo = lo;
LLRepo = ll;
context = con;
imageRepo = img;
}
public OrganizationService(IUnitOfWork unitOfWork, IOrganizationRepository organizationRepository, IPersonService personService, IWebSecurityService userService, IEmailHelper emailHelper, ILocationRepository locationRepository, ISubscriptionService subscriptionService, ICategoryService categoryService)
{
this.unitOfWork = unitOfWork;
this.organizationRepository = organizationRepository;
this.personService = personService;
this.userService = userService;
this.emailHelper = emailHelper;
this.locationRepository = locationRepository;
this.subscriptionService = subscriptionService;
this.categoryService = categoryService;
}
public AssignEmployeeToLocationRequestValidator(
ILocationRepository locationRepository,
IEmployeeRepository employeeRepository)
{
RuleFor(x => x.LocationID)
.Must(x => locationRepository.Exists(x)).WithMessage("No location with this ID exists.");
RuleFor(x => x.EmployeeID)
.Must(x => employeeRepository.Exists(x)).WithMessage("No Employee with this ID exists.");
RuleFor(x => new { x.LocationID, x.EmployeeID })
.Must(x => !(locationRepository.HasEmployee(x.LocationID, x.EmployeeID)).Result).WithMessage("This Employee is already assigned to that Location.");
}
public ContractPartnerPatternService(IContractPartnerPatternRepository contractPartnerPatternRepository,
IPartnerRepository partnerRepository,
ICustomerRepository customerRepository,
ILocationRepository locationRepository, IUnitOfWork unitOfWork)
{
this._contractPartnerPatternRepository = contractPartnerPatternRepository;
this._partnerRepository = partnerRepository;
this._locationRepository = locationRepository;
this._customerRepository = customerRepository;
this._unitOfWork = unitOfWork;
}
public FirstTimeUserExperienceTracker(IApplicationRepository applicationRepository, ILocationRepository locationRepository,
IDeviceRepository deviceRepository, ICredentialsRepository credentialsRepository, IActionRepository actionRepository,
IIftttConnector iftttConnector)
{
_applicationRepository = applicationRepository;
_locationRepository = locationRepository;
_deviceRepository = deviceRepository;
_credentialsRepository = credentialsRepository;
_actionRepository = actionRepository;
_iftttConnector = iftttConnector;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateNewClinicalCaseRequestHandler"/> class.
/// </summary>
/// <param name="lookupValueRepository">The lookup value repository.</param>
/// <param name="patientRepository">The patient repository.</param>
/// <param name="locationRepository">The location repository.</param>
/// <param name="clinicalCaseFactory">The clinical case factory.</param>
public CreateNewClinicalCaseRequestHandler(
ILookupValueRepository lookupValueRepository,
IPatientRepository patientRepository,
ILocationRepository locationRepository,
IClinicalCaseFactory clinicalCaseFactory)
{
_lookupValueRepository = lookupValueRepository;
_patientRepository = patientRepository;
_locationRepository = locationRepository;
_clinicalCaseFactory = clinicalCaseFactory;
}
public LocationsController(
IUnitRepository unitRepository,
ILocationRepository locationRepository,
ILogger logger)
{
this.unitRepository = unitRepository;
this.locationRepository = locationRepository;
this.logger = logger;
this.logger.Trace("Call LocationController");
}
public AdminViewModel()
{
_productRepository = new ProductRepository();
_categoryRepository = new CategoryRepository();
_locationRepository = new LocationRepository();
_serviceRepository = new ServiceRepository();
_allergyRepository = new AllergyRepository();
_immunizationRepository = new ImmunizationRepository();
_medicationRepository = new MedicationRepository();
_templateRepository = new TemplateRepository();
}
public EventsController(
IEventRepository eventRepository, IActionRepository actionRepository, ILocationRepository locationRepository)
{
Contract.Requires<ArgumentNullException>(eventRepository != null, "eventRepository");
Contract.Requires<ArgumentNullException>(actionRepository != null, "actionRepository");
Contract.Requires<ArgumentNullException>(locationRepository != null, "locationRepository");
_eventRepository = eventRepository;
_actionRepository = actionRepository;
_locationRepository = locationRepository;
}
public LocationsController(ILocationRepository thisRepo = null)
{
if (thisRepo == null)
{
this.locationRepo = new EFLocationRepository();
}
else
{
this.locationRepo = thisRepo;
}
}
public LocationQuery(ILocationRepository repository)
{
_repository = repository;
try
{
Initialise();
}
catch (LocalityInitialisationException)
{
}
}
public BranchController(
IBranchRepository _Branch
, IUserRepository _user
, IBranchDepartmentRepository branchDepartment
, ILocationRepository location
)
{
BranchRepository = _Branch;
userRepository = _user;
branchDepartmentRepository = branchDepartment;
locationRepository = location;
}
public CreateLocationHandler(
ILocationRepository locationRepository,
IUnitOfWork unitOfWork,
IMapper mapper,
IBusPublisher busPublisher
)
{
_locationRepository = locationRepository;
_unitOfWork = unitOfWork;
_mapper = mapper;
_busPublisher = busPublisher;
}
public LocationsController(IBookingRepository bookingRepository, ILocationRepository locationRepository, IDirectoryService directoryService, EmailHelper emailHelper)
{
_logger = NLog.LogManager.GetCurrentClassLogger();
_directoryService = directoryService;
_locationService = new LocationsService(_logger, locationRepository, bookingRepository, directoryService, emailHelper);
_locationRepository = locationRepository;
_bookingRepository = bookingRepository;
_logger.Trace(LoggerHelper.InitializeClassMessage());
}
public ResourceService(IResourceRepository resourceRepository
, IResourceTypeRepository resourceTypeRepository
, IBasicCrudService crudService
, ILocationRepository locationRepository
, ILocalizedMessagesService localizedMessagesService)
{
_resourceRepository = resourceRepository;
_resourceTypeRepository = resourceTypeRepository;
_crudService = crudService;
_locationRepository = locationRepository;
_localizedMessages = localizedMessagesService;
}
public SpotFacade(ISpotCore spotCore, ISpotResponse response, IAtomicSpotWork spotWork, ISpotRepository spotRepository, IBusinessRepository businessRepository,
ISpotUserRepository spotUserRepository, ILocationRepository locationRepository, IExceptionLogFacade exceptionLogFacade)
{
_spotCore = spotCore;
_response = response;
_spotWork = spotWork;
_spotRepository = spotRepository;
_businessRepository = businessRepository;
_spotUserRepository = spotUserRepository;
_locationRepository = locationRepository;
_exceptionLogFacade = exceptionLogFacade;
}
public AnimalsService(IMapper mapper,
ILoggerManager logger,
PetSpotDbContext context,
UserResolverService userResolverService,
ILocationRepository locationRepository)
{
this.mapper = mapper;
this.logger = logger;
this.context = context;
this.userResolverService = userResolverService;
this.locationRepository = locationRepository;
}
/// <summary>
/// Creates instance of <see cref="LocationRepositoryTest"/>
/// </summary>
public LocationRepositoryTest()
{
var url =
"mongodb://*****:*****@localhost:27017/location?authSource=admin&readPreference=primary&appname=MongoDB%20Compass&ssl=false";
_locationRepository = new LocationRepository(Options.Create(new MongoDbSettings()
{
ConnectionUrl = url,
DbName = "location",
LocationCollectionName = "geo_data_1"
}));
}
public RoomService(NLog.Logger logger, ILocationRepository locationRepository, IRoomRepository roomRepository, IBookingRepository bookingRepository, IDirectoryService directoryService, Utils.EmailHelper emailHelper)
{
_logger = logger;
_emailHelper = emailHelper;
_locationRepository = locationRepository;
_roomRepository = roomRepository;
_bookingRepository = bookingRepository;
_directoryService = directoryService;
_logger.Trace(LoggerHelper.InitializeClassMessage());
}
public void Init()
{
this.repository = MocksFactory.LocationRepository;
this.coords = new GpsCoordinate
{
Id = 129557542,
Altitude = 0,
Latitude = 41.1454754,
Longitude = -8.6155655
};
}
public AvailabilityController(VORBSContext context,
IBookingRepository bookingRepository,
ILocationRepository locationRepository,
IRoomRepository roomsRepository)
{
_logger = NLog.LogManager.GetCurrentClassLogger();
db = context;
_bookingRepository = bookingRepository;
_locationRepository = locationRepository;
_roomsRepository = roomsRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaBatchService"/> class.
/// </summary>
/// <param name="albumRepository">The album repository.</param>
/// <param name="locationRepository">The location repository.</param>
/// <param name="mediaQueueRepository">The media queue repository.</param>
/// <param name="mediaRepository">The media repository.</param>
/// <param name="uploaderMediaRepository">The uploader media repository.</param>
public MediaBatchService(IAlbumRepository albumRepository,
ILocationRepository locationRepository,
IMediaQueueRepository mediaQueueRepository,
IMediaRepository mediaRepository,
IUploaderMediaRepository uploaderMediaRepository)
{
_albumRepository = albumRepository;
_uploaderMediaRepository = uploaderMediaRepository;
_mediaRepository = mediaRepository;
_mediaQueueRepository = mediaQueueRepository;
_locationRepository = locationRepository;
}
public EventService(ILogger <EventService> logger,
IUserContextProvider userContextProvider,
IBranchRepository branchRepository,
IEventRepository eventRepository,
ILocationRepository locationRepository,
IProgramRepository programRepository) : base(logger, userContextProvider)
{
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_eventRepository = Require.IsNotNull(eventRepository, nameof(eventRepository));
_locationRepository = Require.IsNotNull(locationRepository, nameof(locationRepository));
_programRepository = Require.IsNotNull(programRepository, nameof(programRepository));
}
public HomeController(ILocationRepository locationRepo,
ICityRepository cityRepo,
ICarRepository carRepo,
IReservationRepository reservationRepo,
ReservationHelper reservationHelper)
{
_locationRepository = locationRepo;
_cityRepository = cityRepo;
_carRepository = carRepo;
_reservationRepository = reservationRepo;
_reservationHelper = reservationHelper;
}
public StartUpForm(IGetSpeakerDetail GetSpeakerDetail, IConferenceTypeRepository ConferenceTypeRepository, IConferenceRepository ConferenceRepository, IDictionaryCountryRepository DictionaryCountryRepository, IDictionaryCountyRepository DictionaryCountyRepository, IDictionaryCityRepository dictionaryCityRepository, IDictionaryConferenceCategoryRepository DictionaryConferenceCategoryRepository, ILocationRepository locationRepository)
{
_DictionaryCityRepository = dictionaryCityRepository;
_GetSpeakerDetail = GetSpeakerDetail;
_ConferenceRepository = ConferenceRepository;
_ConferenceTypeRepository = ConferenceTypeRepository;
_DictionaryCountryRepository = DictionaryCountryRepository;
_DictionaryCountyRepository = DictionaryCountyRepository;
_DictionaryConferenceCategoryRepository = DictionaryConferenceCategoryRepository;
_LocationRepository = locationRepository;
InitializeComponent();
}
public LocationService(
ILocationRepository repository,
ILocationFormValidator formValidator,
IHostingEnvironment hostingEnvironment,
IFileSystem fileSystem
)
{
_repository = repository;
_formValidator = formValidator;
_hostingEnvironment = hostingEnvironment;
_fileSystem = fileSystem;
}
public DayController(
IDayRepository dayRepository,
IPingRepository pingRepository,
IRideRepository rideRepository,
ILocationRepository locationRepository
)
{
this.dayRepository = dayRepository;
this.pingRepository = pingRepository;
this.rideRepository = rideRepository;
this.locationRepository = locationRepository;
}
public LawsuitController(ILawsuitRepository lawRepository, ILocationRepository locRepository,
IContactRepository conRepository, ITypeOfProcessRepository tRepository,
LawsuitDataContext context, UserManager <User> userManager)
{
this.context = context;
this.userManager = userManager; //used for getting data for particular lawyer
this.lawsuitRepository = lawRepository;
this.locationRepository = locRepository;
this.contactRepository = conRepository;
this.typeOfRepository = tRepository;
}
public SpotCore(ISpotUserRepository spotUserRepository, IGroupRepository groupGroupRepository,
IBusinessRepository businessRepository,
ILocationRepository locationRepository, ISpotRepository spotRepository,
IEventRepository eventRepository)
{
_spotUserRepository = spotUserRepository;
_groupRepository = groupGroupRepository;
_businessRepository = businessRepository;
_locationRepository = locationRepository;
_spotRepository = spotRepository;
_eventRepository = eventRepository;
}
public ServiceSolicitationService(IServiceSolicitationRepository serviceSolicitationRepository,
ILocationRepository locationRepository,
IAdvertiserRepository advertiserRepository,
IContractModelRepository contractModelRepository,
IAdvertisementRepository advertisementRepository)
{
_serviceSolicitationRepository = serviceSolicitationRepository;
_locationRepository = locationRepository;
_advertiserRepository = advertiserRepository;
_contractModelRepository = contractModelRepository;
_advertisementRepository = advertisementRepository;
}
public override IEnumerable <IJob> CreateJobs(IEnumerable <ISample> samples, ILocationRepository locationRepository, Action <ISample, IJob> trace)
{
return(from sample in samples
let location = locationRepository.LocateSampleProcessing(sample)
group(sample, location) by(location.Plate, location.Cavity / 8) into transferChunk
select TraceAll(AddTips( new LiquidTransferJob
{
ProtocolStepName = Id,
Source = locationRepository.LocateReagent(Reagent),
Target = transferChunk.Key.Plate
}, transferChunk.Select(l => l.location.Cavity)), trace, transferChunk.Select(g => g.sample)));
}
public ServiceSolicitationService(IServiceSolicitationRepository serviceSolicitationRepository,
ILocationRepository locationRepository,
IAdvertiserRepository advertiserRepository,
IContractModelRepository contractModelRepository,
IAdvertisementRepository advertisementRepository)
{
_serviceSolicitationRepository = serviceSolicitationRepository;
_locationRepository = locationRepository;
_advertiserRepository = advertiserRepository;
_contractModelRepository = contractModelRepository;
_advertisementRepository = advertisementRepository;
}
public CWBAPIService(
ILocationRepository locationRepositorie
, IWeatherForecastRepository weatherForecastRepository
, IWeatherForecastDetailRepository weatherForecastDetailRepository
, IOptions <CWBSettingConfig> config)
{
_LocationRepositorie = locationRepositorie;
_WeatherForecastRepository = weatherForecastRepository;
_WeatherForecastDetailRepository = weatherForecastDetailRepository;
_Authorization = config.Value.Authorization;
_BaseUrl = config.Value.DomainUrl;
}
public ImportController(IEventRepository eventRepository,
ILocationRepository locationRepository,
IMapper mapper,
Starter starter,
GeocodingService geocodingService)
{
_eventRepository = eventRepository;
_locationRepository = locationRepository;
_mapper = mapper;
_starter = starter;
_geocodingService = geocodingService;
}
public Parser(IScheduleRepository scheduleRepository, IRoomRepository roomRepository, IMovieRepository movieRepository,
ISeatTypeRepository seatTypeRepository, IReservationRepository reservationRepository, ILocationRepository locationRepository,
IMapper mapper)
{
this.scheduleRepository = scheduleRepository;
this.roomRepository = roomRepository;
this.movieRepository = movieRepository;
this.seatTypeRepository = seatTypeRepository;
this.reservationRepository = reservationRepository;
this.locationRepository = locationRepository;
this.mapper = mapper;
}
public UnitOfWork(DataContext context, UserManager <User> userManager, IHostingEnvironment env)
{
_context = context;
Projects = new ProjectRepository(_context);
Users = new UserRepository(_context, userManager);
ProbBeta = new ProblemBetaRepository(_context, userManager, env, Users);
Auth = new AuthRepository(userManager);
Likes = new LikeRepository(_context);
Comments = new CommentRepository(_context);
Ideas = new IdeaRepository(_context);
Location = new LocationRepository(_context);
}
