public SensorEntity GetById(
Guid id,
[FromServices] ISensorRepository repository
)
{
return(repository.GetById(id));
}
public IList <SensorEntity> GetAllByArea(
Guid id,
[FromServices] ISensorRepository repository
)
{
return(repository.GetAllByArea(id));
}
public SensorManagerImplementation(IRepoManager repoManager, CMMotionManager motionManager, CLLocationManager locationManager, CMPedometer pedometer)
{
_repoManager = repoManager ?? throw new ArgumentNullException(nameof(repoManager));
_motionManager = motionManager ?? throw new ArgumentNullException(nameof(motionManager));
_locationManager = locationManager ?? throw new ArgumentNullException(nameof(locationManager));
_pedometer = pedometer ?? throw new ArgumentNullException(nameof(pedometer));
_queue = new NSOperationQueue();
_sensorMeasurementSessionRepository = _repoManager.SensorMeasurementSessionRepository;
_accelerometerRepository = _repoManager.AccelerometerRepository;
_gyroscoperRepository = _repoManager.GyroscopeRepository;
_magnetometerRepository = _repoManager.MagnetometerRepository;
_linearAccelerationRepository = _repoManager.LinearAccelerationRepository;
_orientationRepository = _repoManager.OrientationRepository;
_quaternionRepository = _repoManager.QuaternionRepository;
_gravityRepository = _repoManager.GravityRepository;
locationManager.DesiredAccuracy = CLLocation.AccuracyBest;
locationManager.HeadingFilter = 1;
locationManager.AllowsBackgroundLocationUpdates = true;
motionManager.DeviceMotionUpdateInterval = 0.1;
motionManager.AccelerometerUpdateInterval = 0.1;
motionManager.GyroUpdateInterval = 0.1;
motionManager.MagnetometerUpdateInterval = 0.1;
}
public EventHandler(IEventRepository eventRepository, ISensorRepository sensorRepository, ISensorService sensorService, EventWsHandler eventWs)
{
_eventRepository = eventRepository;
_sensorRepository = sensorRepository;
_sensorService = sensorService;
_eventWs = eventWs;
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory,
IServiceProvider serviceProvider, ISensorRepository repo)
{
// loggerFactory
// .AddConsole()
// .AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseWebSockets();
app.MapWebSocketManager("/chat", serviceProvider.GetService <ChatMessageSocketHandler>());
//app.MapWebSocketManager("/sensor", serviceProvider.GetService<SensorMessageSocketHandler>());
repo.GetAll().ToList().ForEach(s => {
var handler = serviceProvider.GetService <SensorMessageSocketHandler>();
handler.Sensor = s;
app.MapWebSocketManager("/sensor/" + s.Id.ToString(), handler);
});
app.UseOwin(x => x.UseNancy());
app.Use(async(http, next) =>
{
http.Response.Redirect($"http://{http.Request.Host}");
await Task.CompletedTask;
});
}
public GlucoseService(IEventAggregator eventAggregator, IUserRepository userRepository, IUserSettingsRepository userSettingsRepository,
ISensorRepository sensorRepository, IGlucoseMeasureRepository GlucoseMeasureRepository, AppSettings settings)
{
this.eventAggregator = eventAggregator;
this.userRepository = userRepository;
this.userSettingsRepository = userSettingsRepository;
this.sensorRepository = sensorRepository;
this.glucoseMeasureRepository = GlucoseMeasureRepository;
this.appSettings = settings;
// subscription to the init measureServiceEvent
// This event is possibly raised by the background service after its full initialization
this.eventAggregator.GetEvent <InitMeasureServiceEvent>().Subscribe(async(value) =>
{
// intialize the measure service. We know he's awaken so we can get the dependancy
this.measureService = Xamarin.Forms.DependencyService.Get <IMeasure>(DependencyFetchTarget.GlobalInstance);
// then we awake the device
await WakeUpMeasureServiceAsync();
});
// subscription to the LastMeasureReceivedEvent
// This event could be raised by the Hidden page for the purpose of simulated data
this.eventAggregator.GetEvent <LastMeasureReceivedEvent>().Subscribe((value) =>
{
SpreadLastMeasure(value);
ProcessAveragesValues();
}
);
}
public EventoService(IEventoRepository eventoRepository,
ISensorRepository sensorRepository,
INotificador notificador) : base(notificador)
{
_eventoRepository = eventoRepository;
_sensorRepository = sensorRepository;
}
public UnitOfWork(
SmartGardenContext context,
IRepository <User> userRepository,
IIrigationSystemRepository irigationSystemRepository,
ISensorRepository sensorRepository,
ISystemStateRepository systemStateRepository,
IBoardsKeysRepository boardsKeysRepository,
IScheduleRepository scheduleRepository,
IZoneRepository zoneRepository,
ISensorPortRepository sensorPortRepository,
IMeasurementRepository measurementRepository,
IFCMTokenRepository fcmTokenRepository,
IRepository <GlobalVegetables> globalVegetablesRepository,
IUserVegetablesRepository userVegetablesRepository
)
{
_context = context;
UserGenericRepository = userRepository;
IrigationSystemRepository = irigationSystemRepository;
SensorRepository = sensorRepository;
SystemStateRepository = systemStateRepository;
BoardsKeyRepository = boardsKeysRepository;
ScheduleRepository = scheduleRepository;
ZoneRepository = zoneRepository;
SensorPortRepository = sensorPortRepository;
MeasurementRepository = measurementRepository;
FCMTokenRepository = fcmTokenRepository;
GlobalVegetablesRepository = globalVegetablesRepository;
UserVegetablesRepository = userVegetablesRepository;
}
public CreateBatteryMeasurementService(
IBatteryMeasurementRepository batteryMeasurementRepository,
ISensorRepository sensorRepository)
{
this.batteryMeasurementRepository = batteryMeasurementRepository;
this.sensorRepository = sensorRepository;
}
public CreateTemperatureMeasurementService(
ITemperatureMeasurementRepository temperatureMeasurementRepository,
ISensorRepository sensorRepository)
{
this.temperatureMeasurementRepository = temperatureMeasurementRepository;
this.sensorRepository = sensorRepository;
}
public SensorService()
{
_repoManager = App.Container.Resolve <IRepoManager>();
_accelerometerRepository = _repoManager.AccelerometerRepository;
_gyroscopeRepository = _repoManager.GyroscopeRepository;
_magnetometerRepository = _repoManager.MagnetometerRepository;
}
public SensorService(
ISensorRepository sensors,
ISensorLinkRepository links
)
{
this.m_links = links;
this.m_sensors = sensors;
}
public MQTTDataHandler(ILogger <MQTTDataHandler> logger, ICacheService cache, IParkingEntryRepository parkEntryRepo, ISensorRepository sensorRepo, IParkingSpotRepository spotRepo)
{
_logger = logger;
_cache = cache;
_parkEntryRepo = parkEntryRepo;
_sensorRepo = sensorRepo;
_spotRepo = spotRepo;
}
public SensorValidationService(ISensorRepository sensorRepository,
ISensorAlarmRepository sensorAlarmRepository,
ILogger <ISensorValidationService> logger)
{
_sensorRepository = sensorRepository;
_sensorAlarmRepository = sensorAlarmRepository;
_logger = logger;
}
public DbSeeder(ILogger <DbSeeder> logger,
ISensorRepository sensorRepository,
IUiConfigurationRepository uiConfigurationRepository)
{
_logger = logger;
_sensorRepository = sensorRepository;
_uiConfigurationRepository = uiConfigurationRepository;
}
public LiveDataHandlersController(
IHttpContextAccessor ctx,
ISensorLinkRepository links,
ISensorRepository sensors,
IApiKeyRepository keys,
ILiveDataHandlerRepository repo) : base(ctx, sensors, links, keys)
{
this.m_repo = repo;
}
public SensoresController(ISensorRepository sensorRepository,
ISensorService sensorService,
IMapper mapper,
INotificador notificador) : base(notificador)
{
_sensorRepository = sensorRepository;
_sensorService = sensorService;
_mapper = mapper;
}
private void resetRepositories()
{
_deviceDetail = null;
_device = null;
_deviceType = null;
_pin = null;
_sensor = null;
_user = null;
}
public DashBoardService(IBuildingRepository buildingRepository, IFloorRepository floorRepository, IRoomRepository roomRepository, ISensorRepository sensorRepository, ILogger <DashBoardService> logger, IMapper mapper)
{
_buildingRepository = buildingRepository;
_floorRepository = floorRepository;
_roomRepository = roomRepository;
_sensorRepository = sensorRepository;
_logger = logger;
_mapper = mapper;
}
public IngestionMessageHandlerSelector(ISensorRepository sensorRepository)
{
SetupHandlers(new Dictionary <Type, IMessageHandler>
{
{ typeof(NewSensorReading), new NewSensorReadingMessageHandler(sensorRepository) },
{ typeof(ClientHandshakeRequest), new ClientHandshakeRequestMessageHandler(sensorRepository) },
{ typeof(TimeRequest), new TimeRequestMessageHandler() }
});
}
public AbstractDataController(IHttpContextAccessor ctx,
ISensorRepository sensors,
ISensorLinkRepository links,
IApiKeyRepository keys) : base(ctx)
{
this.m_sensors = sensors;
this.m_links = links;
this.m_keys = keys;
}
public TriggersController(IHttpContextAccessor ctx,
ISensorRepository sensors,
ISensorLinkRepository links,
ITriggerAdministrationRepository triggers,
ICommandPublisher publisher,
IApiKeyRepository keys) : base(ctx, sensors, links, keys)
{
this.m_triggers = triggers;
this.m_mqtt = publisher;
}
public SensorService(
IDeviceRepository deviceRepository,
ISensorRepository sensorRepository,
ISensorDeviceRepository sensorDeviceRepository
)
{
_deviceRepository = deviceRepository;
_sensorRepository = sensorRepository;
_sensorDeviceRepository = sensorDeviceRepository;
}
public ExportController(IHttpContextAccessor ctx,
IMeasurementRepository measurements,
ISensorService sensorService,
ISensorRepository sensors,
ISensorLinkRepository links,
IApiKeyRepository keys) : base(ctx, sensors, links, keys)
{
this.m_measurements = measurements;
this.m_sensorService = sensorService;
}
public HistoricalDataController(
IStationRepository StationRepository,
IDataRepository DataRepository,
ISensorRepository SensorRepository
)
{
_StationRepository = StationRepository;
_DataRepository = DataRepository;
_SensorRepository = SensorRepository;
}
public SensorController(ISensorRepository sensorRepository,
ISensorService sensorService,
IMapper mapper,
IHubContext <EventoHub> hubContext)
{
_sensorRepository = sensorRepository;
_sensorService = sensorService;
_mapper = mapper;
_hubContext = hubContext;
}
public SensorManager(ISensorRepository sensorRepository,
IZoneRepository zoneRepository,
IScheduleRepository scheduleRepository,
ISwitchRepository switchRepository)
{
this.sensorRepository = sensorRepository;
this.zoneRepository = zoneRepository;
this.switchRepository = switchRepository;
this.scheduleRepository = scheduleRepository;
}
public BlobsController(IHttpContextAccessor ctx,
ISensorRepository sensors,
ISensorLinkRepository links,
IBlobRepository blobs,
IBlobService blobService,
IApiKeyRepository keys) : base(ctx, sensors, links, keys)
{
this.m_blobs = blobs;
this.m_blobService = blobService;
}
public MessagesController(IHttpContextAccessor ctx,
IMessageRepository messages,
ISensorLinkRepository links,
IApiKeyRepository keys,
ISensorService sensorService,
ISensorRepository sensors) : base(ctx, sensors, links, keys)
{
this.m_messages = messages;
this.m_sensorService = sensorService;
}
public SensorFusionService()
{
// TODO Service locator style. Use constructor injection. Not possible at the moment
// because this service is instantiated by android.
_repoManager = App.Container.Resolve <IRepoManager>();
_linearAccelerationRepository = _repoManager.LinearAccelerationRepository;
_orientationRepository = _repoManager.OrientationRepository;
_quaternionRepository = _repoManager.QuaternionRepository;
_gravityRepository = _repoManager.GravityRepository;
}
public LastSensorDataController(ISensorRepository repository)
{
this.db = repository;
}
public SensorController(ISensorRepository sensors,IRepository<Network> networks)
{
_sensors = sensors;
_networks = networks;
}
public sensor_dataController(ISensorRepository repository)
{
this.db = repository;
}
public TempatureObservationsController(IConnectionManager connectionManager,
ISensorRepository sensors)
{
_connectionManager = connectionManager;
_sensors = sensors;
}
