public async Task <bool> InitSensor(Sensor newSlave)
{
if (newSlave != null)
{
var success = Sensors.TryAdd(newSlave.MAC, new HouseSlaveSensorClient {
Slave = newSlave, ConnectionId = Context.ConnectionId
});
if (success)
{
_logger.Info($"Sensor with MAC: {newSlave.MAC} has been added to current list");
var containsEntity =
await SensorRepository.ContainsEntityWithMAC(newSlave.MAC, CancellationToken.None);
if (!containsEntity)
{
await SensorRepository.Add(newSlave, Token);
_logger.Info($"Sensor with MAC: {newSlave.MAC} has been added to repository.");
}
else
{
await SensorRepository.Update(newSlave, Token);
_logger.Info($"Sensor with MAC: {newSlave.MAC} has been updated.");
}
}
}
return(false);
}
protected override void ActivateInternal()
{
var setting = Resolver.GetInstance <DeconzToMqttSetting>();
var logManager = Resolver.GetInstance <ILogManager>();
var metricRecorder = Resolver.GetInstance <IMetricRecorder>();
var sensorRepository = new SensorRepository(setting.DeconzApiKey, new Uri($"ws://{setting.DeconzAddress}:{setting.DeconzApiPort}"));
var lightRepository = new LightRepository(setting.DeconzApiKey, new Uri($"ws://{setting.DeconzAddress}:{setting.DeconzApiPort}"));
var healthCheckService = new HealthCheckService(logManager.GetLogger <HealthCheckService>());
var websockerReceiver = new WebsocketReceiver(logManager.GetLogger <WebsocketReceiver>(), new Uri($"ws://{setting.DeconzAddress}:{setting.DeconzWebsocketPort}"));
var mqttClient = new MqttClient(logManager.GetLogger <MqttClient>(), metricRecorder, logManager, setting.MqttAddress, setting.MqttUsername, setting.MqttPassword);
var eventHandler = new EventHandlingService(logManager.GetLogger <EventHandlingService>(), websockerReceiver, mqttClient, sensorRepository);
var telemetryService = new TelemetryService(logManager.GetLogger <TelemetryService>(), metricRecorder, new DeconzRepository[] {
sensorRepository,
lightRepository
}, mqttClient);
healthCheckService.AddHealthCheck(websockerReceiver);
healthCheckService.AddHealthCheck(mqttClient);
mqttClient.Start();
eventHandler.Start();
websockerReceiver.Start();
telemetryService.Start();
healthCheckService.Start();
}
public override void Configure(IFunctionsHostBuilder builder)
{
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Environment.CurrentDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
IConfigurationSection influxDBConfigurationSection = configuration.GetSection("InfluxDB");
IConfigurationSection featuresConfigurationSection = configuration.GetSection("Features");
IInfluxDBConfiguration influxDBConfiguration = new InfluxDBConfiguration();
IFeaturesConfiguration featuresConfiguration = new FeaturesConfiguration();
influxDBConfigurationSection.Bind(influxDBConfiguration);
featuresConfigurationSection.Bind(featuresConfiguration);
InfluxDBClientOptions influxDBClientOptions = InfluxDBClientOptions.Builder
.CreateNew()
.Url(influxDBConfiguration.Url)
.AuthenticateToken(influxDBConfiguration.Token.ToCharArray())
.Org(influxDBConfiguration.Organisation)
.Bucket(influxDBConfiguration.Bucket)
.Build();
InfluxDBClient influxDBClient = InfluxDBClientFactory.Create(influxDBClientOptions);
ISensorRepository sensorRepository = new SensorRepository(influxDBClient);
builder.Services.AddSingleton <IFeaturesConfiguration>(featuresConfiguration);
builder.Services.AddSingleton <ISensorRepository>(sensorRepository);
builder.Services.AddSensorService();
builder.Services.AddFeatureService();
}
public LabFarmService(LabFarmRepository labfarmRepository, SensorTypeRepository sensorTypeRepository, SensorRepository sensorRepository, ConfigurationService configService)
{
_labfarmRepository = labfarmRepository;
_sensorTypeRepository = sensorTypeRepository;
_sensorRepository = sensorRepository;
_configService = configService;
}
public UnitOfWork(ApplicationDBContext context)
{
this.context = context;
Users = new UserRepository(context);
Walls = new WallRepository(context);
Sensors = new SensorRepository(context);
Materials = new MaterialRepository(context);
}
public EventHandlingService(ILogger logger,
WebsocketReceiver websocketReceiver,
MqttClient mqttClient,
SensorRepository sensorRepository)
{
_logger = logger;
_websocketReceiver = websocketReceiver;
_mqttClient = mqttClient;
_sensorRepository = sensorRepository;
}
public SensorQuery(SensorRepository sensorRepository)
{
FieldAsync <SensorType>(
"sensor",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id", Description = "id of the sensor"
}
),
resolve: async context => await sensorRepository.Get(context.GetArgument <int>("id"))
);
FieldAsync <SensorType>(
"sensors",
resolve: async context => await sensorRepository.GetAll()
);
}
public async Task ShouldGetEntity()
{
// Arrange
var temperatureContext = CreateTemperatureContext();
var repository = new SensorRepository(temperatureContext);
var entity = repository.Add(new Sensor {
Name = "Name"
});
await repository.SaveChangesAsync();
// Act
var loadedEntity = await repository.Get(entity.Id);
// Assert
loadedEntity.Id.Should().Be(entity.Id);
loadedEntity.Name.Should().Be(entity.Name);
loadedEntity.TempReadings.Should().BeEquivalentTo(entity.TempReadings);
}
public async Task ShouldCreateEntity()
{
// Arrange
var temperatureContext = CreateTemperatureContext();
var repository = new SensorRepository(temperatureContext);
// Act
var createdEntity = repository.Add(new Sensor {
Name = "Name"
});
var saved = await repository.SaveChangesAsync();
// Assert
saved.Should().BeTrue();
createdEntity.Id.Should().BeGreaterThan(0);
createdEntity.Name.Should().Be("Name");
createdEntity.TempReadings.Should().BeNull();
}
public bool UpdateSensor(Sensor newSlave)
{
var sensorClient = Sensors.Where(x => x.Key == newSlave.MAC).Select(x => x.Value).FirstOrDefault();
if (sensorClient != null)
{
sensorClient.Slave.Name = newSlave.Name;
Sensors.AddOrUpdate(newSlave.MAC, sensorClient, (key, oldVal) => sensorClient);
try
{
SensorRepository.Update(newSlave, Token);
}
catch (Exception e)
{
_logger.Error($"Problem with updating to Database.");
return(false);
}
_logger.Info($"Sensor with MAC {newSlave.MAC} was renamed.");
}
return(false);
}
public async Task ShouldUpdateEntity()
{
// Arrange
var temperatureContext = CreateTemperatureContext();
var repository = new SensorRepository(temperatureContext);
var entity = repository.Add(new Sensor {
Name = "Name"
});
await repository.SaveChangesAsync();
entity.Name = "New name";
// Act
var updatedEntity = repository.Update(entity);
var saved = await repository.SaveChangesAsync();
// Assert
saved.Should().BeTrue();
updatedEntity.Id.Should().Be(entity.Id);
updatedEntity.Name.Should().Be("New name");
updatedEntity.TempReadings.Should().BeEquivalentTo(entity.TempReadings);
}
public SensorMutation(SensorRepository sensorRepository)
{
Name = "Mutation";
FieldAsync <SensorType>(
"createSensor",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <SensorInputType> > {
Name = "sensor"
}
),
resolve: async context =>
{
var sensor = context.GetArgument <Data.Sensor>("sensor");
sensor = sensorRepository.Add(sensor);
await sensorRepository.SaveChangesAsync();
return(sensor);
});
FieldAsync <SensorType>(
"updateSensor",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> >
{
Name = "id", Description = "id of the sensor"
},
new QueryArgument <NonNullGraphType <SensorInputType> > {
Name = "sensor"
}
),
resolve: async context =>
{
var sensor = context.GetArgument <Data.Sensor>("sensor");
sensor.Id = context.GetArgument <int>("id");
sensor = sensorRepository.Update(sensor);
await sensorRepository.SaveChangesAsync();
return(sensor);
});
}
public void DoWork(object state)
{
_logger.LogInformation("Timed Background Service is working.");
using (var scope = _scopeFactory.CreateScope())
{
var databaseContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>();
SensorHistoryRepository sensorHistoryRepository = new SensorHistoryRepository(databaseContext);
SensorRepository sensorRepository = new SensorRepository(databaseContext);
var temperatureSensors = databaseContext.Sensors.OfType <TemperatureSensor>().ToList();
var humiditySensors = databaseContext.Sensors.OfType <HumiditySensor>().ToList();
var smokeSensors = databaseContext.Sensors.OfType <SmokeSensor>().ToList();
var motionSensors = databaseContext.Sensors.OfType <MotionSensor>().ToList();
double currentTemperature = 0;
double currentHumidity = 0;
double currentSmoke = 0;
double currentMotion = 0;
const double MAX_NUMBER = 1.5;
const double MIN_NUMBER = 0.5;
foreach (var sensor in temperatureSensors)
{
currentTemperature = random.NextDouble() * ((double)sensor.MaxValue * MAX_NUMBER - (double)sensor.MinValue * MIN_NUMBER) + (double)sensor.MinValue * MIN_NUMBER;
_logger.LogInformation("currentTemperature = " + currentTemperature);
if (currentTemperature > sensor.MaxValue || currentTemperature < sensor.MinValue)
{
sensor.IsOn = true;
sensor.Temperature = currentTemperature;
}
else
{
sensor.IsOn = false;
sensor.Temperature = currentTemperature;
}
_logger.LogInformation("IsOn = " + sensor.IsOn);
//sensorHistoryRepository.AddTemperatureSensorHistory(sensor);
sensorRepository.UpdateTemperatureSensor(sensor);
}
foreach (var sensor in humiditySensors)
{
currentHumidity = random.NextDouble() * ((double)sensor.MaxValue * MAX_NUMBER - (double)sensor.MinValue * MIN_NUMBER) + (double)sensor.MinValue * MIN_NUMBER;
_logger.LogInformation("currentHumidity = " + currentHumidity);
if (currentHumidity > sensor.MaxValue || currentHumidity < sensor.MinValue)
{
sensor.IsOn = true;
sensor.Humidity = currentHumidity;
}
else
{
sensor.IsOn = false;
sensor.Humidity = currentHumidity;
}
_logger.LogInformation("IsOn = " + sensor.IsOn);
sensorRepository.UpdateHumiditySensor(sensor);
}
foreach (var sensor in smokeSensors)
{
currentSmoke = random.NextDouble() * ((double)sensor.MaxValue * MAX_NUMBER - (double)sensor.MinValue * MIN_NUMBER) + (double)sensor.MinValue * MIN_NUMBER;
_logger.LogInformation("currentSmoke = " + currentSmoke);
if (currentSmoke > sensor.MaxValue || currentSmoke < sensor.MinValue)
{
sensor.IsOn = true;
sensor.Smoke = currentSmoke;
}
else
{
sensor.IsOn = false;
sensor.Smoke = currentSmoke;
}
_logger.LogInformation("IsOn = " + sensor.IsOn);
sensorRepository.UpdateSmokeSensor(sensor);
}
foreach (var sensor in motionSensors)
{
currentMotion = random.NextDouble();
_logger.LogInformation("currentMotion = " + currentMotion);
if (currentMotion > 0.5)
{
sensor.IsOn = true;
sensor.IsMove = true;
}
else
{
sensor.IsOn = false;
sensor.IsMove = false;
}
_logger.LogInformation("IsOn = " + sensor.IsOn);
sensorRepository.UpdateMotionSensor(sensor);
}
}
}
public SensorService(string username, string password)
{
sensorRepository = new SensorRepository(username, password);
}
public SensorManager(SailbotContext context)
{
sensorRepository = new SensorRepository <T>(context);
}
internal GatewayService()
{
_gatewayRepository = new GatewayRepository();
_sensorRepository = new SensorRepository();
}
internal SensorBgWService()
{
_sensorService = new SensorService();
_sensorRepository = new SensorRepository();
_modbusService = new ModbusService();
}
public SensorController(SensorRepository sensorRepository)
{
_sensorRepository = sensorRepository;
}
public CarService()
{
_sensorRepository = new SensorRepository();
}
public SensorRepositoryFixture()
{
_connectionString = ConfigurationManager.ConnectionStrings["TheDump"].ConnectionString;
_sensorRepository = new SensorRepository();
}
public SensorService(SensorRepository sensorRepository)
{
_sensorRepository = sensorRepository;
}
