public Worker(ILogger <Worker> logger, IMqttService mqttService)
{
_logger = logger;
_mqttService = mqttService;
SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
}
public MQTTBackgroundService(ILogger <MQTTBackgroundService> logger, IMqttService client, MQTTServerConfiguration serverConfig, IEnumerable <MQTTTopicConfiguration> topicsConfig)
{
_logger = logger;
_serverConfig = serverConfig;
_topicsConfig = topicsConfig;
_client = client;
}
public WeatherForecastController(ILogger <WeatherForecastController> logger,
IMqttService mqttService
)
{
_logger = logger;
this._mqttService = mqttService;
}
public UpdateDeviceHandler(
IDeviceRepository deviceRepository,
IMqttService mqttService)
{
_deviceRepository = deviceRepository;
_mqttService = mqttService;
}
public HomeController(UserManager <ApplicationUser> userManager, ILogger <HomeController> logger, IRepository repository, IMapper mapper, IMqttService mqtt)
{
_userManager = userManager;
_logger = logger;
_repository = repository;
_mapper = mapper;
_mqtt = mqtt;
}
public SonoffTasmodaComponent(ILogger <SonoffTasmodaComponent> logger, IMqttService mqttService,
IIoTService ioTService, IEventDatabaseService eventDatabaseService)
{
_logger = logger;
_mqttService = mqttService;
_ioTService = ioTService;
_eventDatabaseService = eventDatabaseService;
}
public Initializer(
IServiceScopeFactory serviceScopeFactory,
IMqttService mqttService,
IHostApplicationLifetime hostApplicationLifetime)
{
_serviceScopeFactory = serviceScopeFactory;
_mqttService = mqttService;
_hostApplicationLifetime = hostApplicationLifetime;
}
public OwnTracksComponent(ILogger <OwnTracksComponent> logger, IMqttService mqttService,
IEventDatabaseService eventDatabaseService, IIoTService ioTService, NeonConfig neonConfig)
{
_logger = logger;
_mqttService = mqttService;
_eventDatabaseService = eventDatabaseService;
_ioTService = ioTService;
_neonConfig = neonConfig;
}
public TestCommand(
IRepository <AssetData> repo
, IMqttService mqttService
, IMqttClientService mqttClient
)
{
_repo = repo;
_mqttService = mqttService;
_mqttClient = mqttClient;
}
public ConsoleHostedService(ILogger <ConsoleHostedService> logger, IMqttService mqttService, ITcpService tcpService, IOptions <AppConfig> appConfig, IApplicationLifetime appLifetime)
{
_appLifetime = appLifetime;
_mqttService = mqttService;
_tcpService = tcpService;
_appConfig = appConfig;
_mqttService.MqttServiceClient.MqttMsgPublishReceived += client_recievedMessage;
//_mqttService.MqttServiceClient.ConnectionClosed += MqttServiceClient_ConnectionClosed;
_logger = logger;
_logger.LogInformation("ConsoleHostedService instance created...");
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="logger"></param>
/// <param name="fileSystemManager"></param>
/// <param name="config"></param>
public IoTService(ILogger <IIoTService> logger, IFileSystemManager fileSystemManager,
NeonConfig config,
IEventDatabaseService eventDatabaseService,
IMqttService mqttService
)
{
_logger = logger;
_mqttService = mqttService;
_eventDatabaseService = eventDatabaseService;
_fileSystemManager = fileSystemManager;
_config = config;
}
public Engine(ILoggerFactory loggerFactory,
IConfiguration config,
IMqttService mqttService,
IRepository repository,
IStateRegistry stateRegistry,
IFilterService filterService)
{
log = loggerFactory.CreateLogger <Engine>();
mqtt = mqttService;
repo = repository;
states = stateRegistry;
filters = filterService;
config.GetSection("Engine").Bind(this);
}
public CreateDeviceHandler(
IAccountRepository accountRepository,
IDeviceRepository deviceRepository,
IAccountDeviceRepository accountDeviceRepository,
IMqttService mqttService,
IHttpContextAccessor httpContextAccessor,
IHiveMqCredentialsService hiveMqCredentialsService)
{
_accountRepository = accountRepository;
_deviceRepository = deviceRepository;
_accountDeviceRepository = accountDeviceRepository;
_mqttService = mqttService;
_httpContextAccessor = httpContextAccessor;
_hiveMqCredentialsService = hiveMqCredentialsService;
}
public CreateDeviceHandlerTests()
{
_accountRepository = Substitute.For <IAccountRepository>();
_deviceRepository = Substitute.For <IDeviceRepository>();
_accountDeviceRepository = Substitute.For <IAccountDeviceRepository>();
_mqttService = Substitute.For <IMqttService>();
_httpContextAccessor = Substitute.For <IHttpContextAccessor>();
_hiveMqCredentialsService = Substitute.For <IHiveMqCredentialsService>();
_handler = new CreateDeviceHandler(
_accountRepository,
_deviceRepository,
_accountDeviceRepository,
_mqttService,
_httpContextAccessor,
_hiveMqCredentialsService);
}
public static async Task Main(string[] args)
{
// Read the configuration file
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory()) // Directory where the json files are located
.AddJsonFile(APPSETTINGS_FILENAME, optional: false, reloadOnChange: true)
.Build();
// Create an HttpClient that doesn't validate the server certificate
HttpClientHandler customHttpClientHandler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return(true); }
};
TelemetryConfiguration telemetryConfig = AppInsights.GetTelemetryConfiguration(configuration);
using (AppInsights.InitializeDependencyTracking(telemetryConfig))
using (AppInsights.InitializePerformanceTracking(telemetryConfig))
using (HttpClient _httpClient = new HttpClient(customHttpClientHandler))
{
_telemetryClient = new TelemetryClient(telemetryConfig);
// Abstraction representing the home automation system
_hub = new Hubitat(configuration, _httpClient);
// Start the MQTT service, if applicable.
MqttOptions mqttOptions = configuration.GetSection("MQTT").Get <MqttOptions>();
if (mqttOptions?.Enabled ?? false)
{
_mqtt = new MqttService(await MqttClientFactory.GetClient(mqttOptions), mqttOptions, _hub);
await _mqtt.Start();
}
// Class to manage long-running tasks
_taskManager = new AutomationTaskManager(configuration);
// Bind a method to handle the events raised
// by the Hubitat device
_hub.AutomationEvent += Hub_AutomationEvent;
var hubTask = _hub.StartAutomationEventWatcher();
// Wait forever, this is a daemon process
await hubTask;
}
}
public static void UseMqttEndpoint(
this IApplicationBuilder application,
MqttSettings mqttSettings,
IMqttService mqttService)
{
if (mqttSettings.WebSocketEndPoint?.Enabled != true || string.IsNullOrEmpty(mqttSettings.WebSocketEndPoint.Path))
{
return;
}
var webSocketOptions = new WebSocketOptions
{
KeepAliveInterval = TimeSpan.FromSeconds(mqttSettings.WebSocketEndPoint.KeepAliveInterval)
};
if (mqttSettings.WebSocketEndPoint.AllowedOrigins?.Any() == true)
{
foreach (var item in mqttSettings.WebSocketEndPoint.AllowedOrigins)
{
webSocketOptions.AllowedOrigins.Add(item);
}
}
application.UseWebSockets(webSocketOptions);
application.Use(async(context, next) =>
{
if (context.Request.Path == mqttSettings.WebSocketEndPoint.Path)
{
if (context.WebSockets.IsWebSocketRequest)
{
await mqttService.RunWebSocketConnectionAsync(context);
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
}
else
{
await next().ConfigureAwait(false);
}
});
}
public MqttClientMain(IMqttService mqttService)
{
this.mqttService = mqttService;
mqttClient = new MqttFactory().CreateMqttClient();
var option = new MqttClientOptionsBuilder()
.WithCleanSession(true)
.WithClientId("Main client")
.WithCommunicationTimeout(TimeSpan.FromSeconds(5))
.WithKeepAlivePeriod(TimeSpan.FromSeconds(5))
.WithProtocolVersion(MqttProtocolVersion.V311)
.WithTcpServer("127.0.0.1", Convert.ToInt32(1883));
mqttClient.ConnectAsync(option.Build());
mqttClient.Connected += (sender, e) =>
{
string str = string.Format("Main Client connected");
Console.WriteLine(str);
};
mqttClient.Disconnected += (sender, e) =>
{
string str = string.Format("Main Client disconnected");
Console.WriteLine(str);
};
mqttClient.ApplicationMessageReceived += (sender, e) =>
{
string result = System.Text.Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
string str = string.Format("Main Client received message: {0}", result);
Console.WriteLine(str);
if (e.ApplicationMessage.Topic == "scale")
{
MqttEntity mqttEntity = JsonConvert.DeserializeObject <MqttEntity>(result);
mqttService.UpdateWeightFromScale(mqttEntity);
}
if (e.ApplicationMessage.Topic.ToLower().Contains("state"))
{
mqttService.UpdateOpenCabinet(e.ApplicationMessage.Topic.ToLower());
}
};
listTopic = new List <string>();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IDiscordService discordService,
IMqttService mqttService, ILightService lightService)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCors("AllowAll");
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapHub <DiscordHub>("/hub/discord");
endpoints.MapHub <LightHub>("/hub/light");
});
}
public Worker(ILogger <Worker> logger, IMqttService mqttService)
{
_logger = logger;
_mqttService = mqttService;
}
public DLMController(IRepository repository, UserManager <ApplicationUser> userManager, IMqttService mqttService)
{
_repository = repository;
_userManager = userManager;
_mqttService = mqttService;
}
public DeviceController(IMqttService mqttService)
{
_mqttService = mqttService;
}
public MessageController(IMessageEngine messageEngine, IMqttService mqttSvc)
{
_messageEngine = messageEngine;
_mqttSvc = mqttSvc;
}
public OwnTracksComponent(ILoggerFactory loggerFactory, IIoTService ioTService, IMqttService mqttService, NeonConfig neonConfig, IComponentsService componentsService) : base(loggerFactory, ioTService, componentsService)
{
_mqttService = mqttService;
_config = neonConfig;
}
public MqttHub(IMqttService mqttService, DeviceState deviceState)
{
_mqttService = mqttService;
_deviceState = deviceState;
}
public IndexModel(ILogger <IndexModel> logger, IMqttService mqttService)
{
_logger = logger;
_mqttService = mqttService;
}
public PublishPayload(IWorkflowExpressionEvaluator expressionEvaluator, IMqttService mqttService, IOptions <MqttNetOptions> options)
{
this.expressionEvaluator = expressionEvaluator;
this.mqttService = mqttService;
this.options = options;
}
public ClientUpdateScheduler(IMqttService mqttService, DeviceState deviceState)
{
_mqttService = mqttService;
_deviceState = deviceState;
}
public SonoffTasmodaComponent(ILoggerFactory loggerFactory, IIoTService ioTService, IMqttService mqttService, IComponentsService componentsService) : base(loggerFactory, ioTService, componentsService)
{
_mqttService = mqttService;
}
public FIITParkingDataReceiver(ILogger <FIITParkingDataReceiver> logger, IServiceScopeFactory serviceScopeFactory, IHostApplicationLifetime applicationLifetime, IMqttService client, IOptions <MQTTConfiguration> configs)
: base(logger, client, configs.Value.ServerConfiguration, configs.Value.TopicConfiguration)
{
_logger = logger;
_serviceFactory = serviceScopeFactory;
}
public MqttController(IMqttService mqttService)
{
_mqttService = mqttService;
}
