Added webhook support

src/App/NetDaemon.App/Common/INetDaemon.cs

@@ -40,6 +40,14 @@ public interface INetDaemon : INetDaemonCommon
         /// <param name="waitForResponse">If we should wait for the service to get response from Home Assistant or send/forget scenario</param>
         Task CallServiceAsync(string domain, string service, dynamic? data = null, bool waitForResponse = false);
 
+        /// <summary>
+        ///     Trigger a state change using trigger templates
+        /// </summary>
+        /// <param name="id">webhook id</param>
+        /// <param name="data">data being sent</param>
+        /// <param name="waitForResponse">If we should wait for the service to get response from Home Assistant or send/forget scenario</param>
+        void TriggerWebhook(string id, object? data, bool waitForResponse);
+
         /// <summary>
         ///     Get application instance by application instance id
         /// </summary>

src/App/NetDaemon.App/Common/Reactive/INetDaemonReactive.cs

@@ -76,6 +76,14 @@ public interface INetDaemonRxApp : INetDaemonAppBase, IRxSchedule, IRxEntity
         /// <param name="script">Script to call</param>
         void RunScript(params string[] script);
 
+        /// <summary>
+        ///     Trigger a state change using trigger templates
+        /// </summary>
+        /// <param name="id">webhook id</param>
+        /// <param name="data">data being sent</param>
+        /// <param name="waitForResponse">Waits for Home Assistant to return result before returning</param>
+        void TriggerWebhook(string id, object? data, bool waitForResponse = false);
+
         /// <summary>
         ///     Delays timeout time
         /// </summary>

src/App/NetDaemon.App/Common/Reactive/NetDaemonRxApp.cs

@@ -271,6 +271,12 @@ public void RunScript(params string[] script)
                 Daemon.CallService("script", name);
             }
         }
+        /// <inheritdoc/>
+        public void TriggerWebhook(string id, object? data, bool waitForResponse = false)
+        {
+            _ = Daemon ?? throw new NetDaemonNullReferenceException($"{nameof(Daemon)} cant be null!");
+            Daemon.TriggerWebhook(id, data, waitForResponse);
+        }
 
         /// <inheritdoc/>
         public void SaveData<T>(string id, T data)

src/App/NetDaemon.App/NetDaemon.App.csproj

@@ -22,7 +22,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="JoySoftware.HassClient" Version="21.18.2-beta" />
+    <PackageReference Include="JoySoftware.HassClient" Version="21.19.1-beta" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="5.0.0" />
     <PackageReference Include="Roslynator.Analyzers" Version="3.1.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

src/Daemon/NetDaemon.Daemon/Daemon/Config/YamlExtensions.cs

@@ -38,7 +38,7 @@ public static class YamlExtensions
             return type.GetProperty(propertyName) ?? type.GetProperty(propertyName.ToCamelCase());
         }
 
-        public static object? ToObject(this YamlScalarNode node, Type valueType, INetDaemonAppBase deamonApp)
+        public static object? ToObject(this YamlScalarNode node, Type valueType, INetDaemonAppBase? deamonApp)
         {
             _ = valueType ??
                 throw new NetDaemonArgumentNullException(nameof(valueType));
@@ -112,7 +112,7 @@ public static class YamlExtensions
                     break;
             }
 
-            if (valueType.IsAssignableTo(typeof(RxEntityBase)))
+            if (deamonApp != null && valueType.IsAssignableTo(typeof(RxEntityBase)))
             {
                 return Activator.CreateInstance(valueType, deamonApp, new[] {node.Value});
             }

src/Daemon/NetDaemon.Daemon/Daemon/NetDaemonHost.cs

@@ -43,6 +43,9 @@ public class NetDaemonHost : INetDaemonHost, IAsyncDisposable
         internal readonly Channel<(string, string, dynamic?)> _serviceCallMessageChannel =
                 Channel.CreateBounded<(string, string, dynamic?)>(200);
 
+        internal readonly Channel<(string, object?)> _webhookTriggerMessageChannel =
+                Channel.CreateBounded<(string, object?)>(200);
+
         internal readonly Channel<(string, dynamic, dynamic?)> _setStateMessageChannel =
                 Channel.CreateBounded<(string, dynamic, dynamic?)>(200);
 
@@ -159,7 +162,26 @@ public async Task<IEnumerable<HassServiceDomain>> GetAllServices()
 
             return await _hassClient.GetServices().ConfigureAwait(false);
         }
-
+        public void TriggerWebhook(string id, object? data, bool waitForResponse = false)
+        {
+            _cancelToken.ThrowIfCancellationRequested();
+            if (!waitForResponse)
+            {
+                if (!_webhookTriggerMessageChannel.Writer.TryWrite((id, data)))
+                    throw new NetDaemonException("Service call queue full!");
+            }
+            else
+            {
+                try
+                {
+                    _hassClient.TriggerWebhook(id, data).Wait(_cancelToken);
+                }
+                catch (Exception e)
+                {
+                    Logger.LogError(e, "Failed call service");
+                }
+            }
+        }
         public void CallService(string domain, string service, dynamic? data = null, bool waitForResponse = false)
         {
             _cancelToken.ThrowIfCancellationRequested();
@@ -350,9 +372,9 @@ public async Task Run(string host, short port, bool ssl, string token, Cancellat
                     return;
                 }
 
-                // Setup TTS
                 Task handleTextToSpeechMessagesTask = HandleTextToSpeechMessages(cancellationToken);
                 Task handleAsyncServiceCalls = HandleAsyncServiceCalls(cancellationToken);
+                Task handleAsyncWebhookTriggers = HandleAsyncWebhookTriggers(cancellationToken);
                 Task handleAsyncSetState = HandleAsyncSetState(cancellationToken);
 
                 await RefreshInternalStatesAndSetArea().ConfigureAwait(false);
@@ -1059,6 +1081,10 @@ private void HandleCustomEvent(HassEvent hassEvent, CancellationToken token)
                 return L;
             }
         }
+
+        // TODO: Refactor the sync to async queue system to allow
+        //       all kinds of types instead of different queues
+
         [SuppressMessage("", "CA1031")]
         private async Task HandleAsyncServiceCalls(CancellationToken cancellationToken)
         {
@@ -1093,6 +1119,39 @@ private async Task HandleAsyncServiceCalls(CancellationToken cancellationToken)
             }
         }
 
+        [SuppressMessage("", "CA1031")]
+        private async Task HandleAsyncWebhookTriggers(CancellationToken cancellationToken)
+        {
+            _cancelToken.ThrowIfCancellationRequested();
+            _ = _hassClient ?? throw new NetDaemonNullReferenceException(nameof(_hassClient));
+
+            bool hasLoggedError = false;
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    (string id, object? data)
+                    = await _webhookTriggerMessageChannel.Reader.ReadAsync(cancellationToken).ConfigureAwait(false);
+
+                    await _hassClient.TriggerWebhook(id, data).ConfigureAwait(false);
+
+                    hasLoggedError = false;
+                }
+                catch (OperationCanceledException)
+                {
+                    // Ignore we are leaving
+                }
+                catch (Exception e)
+                {
+                    if (!hasLoggedError)
+                        Logger.LogDebug(e, "Failure sending trigger webhook");
+                    hasLoggedError = true;
+                    await Task.Delay(100, cancellationToken).ConfigureAwait(false); // Do a delay to avoid loop
+                }
+            }
+        }
+
         [SuppressMessage("", "CA1031")]
         private async Task HandleAsyncSetState(CancellationToken cancellationToken)
         {

src/Daemon/NetDaemon.Daemon/NetDaemon.Daemon.csproj

@@ -20,7 +20,7 @@
     <tags>Home Assistant</tags>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="JoySoftware.HassClient" Version="21.18.2-beta" />
+    <PackageReference Include="JoySoftware.HassClient" Version="21.19.1-beta" />
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
     <PackageReference Include="Microsoft.Extensions.Http" Version="5.0.0" />
     <PackageReference Include="YamlDotNet" Version="11.1.1" />

src/DaemonRunner/DaemonRunner/DaemonRunner.csproj

@@ -21,7 +21,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="JoySoftware.HassClient" Version="21.18.2-beta" />
+    <PackageReference Include="JoySoftware.HassClient" Version="21.19.1-beta" />
     <PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.2.7" />
     <PackageReference Include="Microsoft.AspNetCore.Http" Version="2.2.2" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.2.0" />

src/Fakes/NetDaemon.Fakes/DaemonHostTestBase.cs

@@ -251,6 +251,17 @@ public void VerifyEventSent(string ev, object? eventData)
             DefaultHassClientMock.VerifyCallServiceTuple(domain, service, attributesTuples);
         }
 
+        /// <summary>
+        ///     Verifies that TriggerWebhook is called
+        /// </summary>
+        /// <param name="id">Id of webbhook</param>
+        /// <param name="data">data sent with webhook</param>
+        /// <param name="times">Number of times called</param>
+        public void VerifyTriggerWebhook(string id, object? data = null, Times? times = null)
+        {
+            DefaultHassClientMock.VerifyTriggerWebhook(id, data, times);
+        }
+
         /// <summary>
         ///     Verifies that call_service is called
         /// </summary>

src/Fakes/NetDaemon.Fakes/HassClientMock.cs

@@ -335,6 +335,20 @@ public void VerifyCallService(string domain, string service, object? data = null
                 Verify(n => n.CallService(domain, service, data!, waitForResponse), Times.AtLeastOnce);
         }
 
+        /// <summary>
+        ///     Verifies that TriggerWebhook is called
+        /// </summary>
+        /// <param name="id">Id of webbhook</param>
+        /// <param name="data">data sent with webhook</param>
+        /// <param name="times">Number of times called</param>
+        public void VerifyTriggerWebhook(string id, object? data = null, Times? times = null)
+        {
+            if (times is not null)
+                Verify(n => n.TriggerWebhook(id, data!), times.Value);
+            else
+                Verify(n => n.TriggerWebhook(id, data!), Times.AtLeastOnce);
+        }
+
         /// <summary>
         ///     Verifies that call_service is called
         /// </summary>

tests/NetDaemon.Daemon.Tests/DaemonRunner/Config/ConfigTest.cs

@@ -207,11 +207,10 @@ public void YamlScalarNotToObjectUsingEntityType(Type entityType)
             // ACT & ASSERT
             var instance = scalarValue.ToObject(entityType, appMock.Object) as RxEntityBase;
             Assert.NotNull(instance);
-            Assert.Equal(entityType,instance.GetType());
+            Assert.Equal(entityType,instance!.GetType());
             Assert.Equal("1234", instance.EntityId);
         }
 
-
         [Fact]
         public void YamlScalarNodeToObjectUsingDecimal()
         {

tests/NetDaemon.Daemon.Tests/Reactive/RxAppTest.cs

@@ -40,6 +40,34 @@ public async Task CallServiceShouldCallCorrectFunction()
             VerifyCallServiceTuple("mydomain", "myservice", ("attr", "value"));
         }
 
+        [Fact]
+        public async Task TriggerWebhookShouldCallCorrectFunction()
+        {
+            // ARRANGE
+            await InitializeFakeDaemon().ConfigureAwait(false);
+
+            // ACT
+            DefaultDaemonRxApp.TriggerWebhook("some-id", new {data = 1});
+            await RunFakeDaemonUntilTimeout().ConfigureAwait(false);
+
+            // ASSERT
+            VerifyTriggerWebhook("some-id", new {data = 1});
+        }
+
+        [Fact]
+        public async Task TriggerWebhookWithNullDataShouldCallCorrectFunction()
+        {
+            // ARRANGE
+            await InitializeFakeDaemon().ConfigureAwait(false);
+
+            // ACT
+            DefaultDaemonRxApp.TriggerWebhook("some-id", null);
+            await RunFakeDaemonUntilTimeout().ConfigureAwait(false);
+
+            // ASSERT
+            VerifyTriggerWebhook("some-id", null);
+        }
+
         [Fact]
         public async Task NewAllEventDataShouldCallFunction()
         {