/// <summary>
/// Convert a HassEvent to CallServiceEvent
/// </summary>
/// <param name="hassEvent">HassEvent to convert</param>
/// <exception cref="NullReferenceException"></exception>
public static HassServiceEventData?ToCallServiceEvent(this HassEvent hassEvent)
{
var jsonElement = hassEvent.DataElement ??
throw new NullReferenceException("DataElement cannot be empty");
return(jsonElement.ToObject <HassServiceEventData>());
}
public static Event Map(this HassEvent hassEvent)
{
return(new Event
{
Origin = hassEvent.Origin,
EventType = hassEvent.EventType,
TimeFired = hassEvent.TimeFired,
DataElement = hassEvent.DataElement
});
}
private void HandleEvent(HassEvent hassEvent)
{
_logger.LogDebug("New event ({EventType})", hassEvent.EventType);
switch (hassEvent.EventType)
{
case "state_changed":
var state = hassEvent.ToStateChangedEvent();
_logger.LogInformation("state changed: {State}", state);
break;
}
}
public async Task SubscribeToEventsReturnsCorrectEvent()
{
// ARRANGE
var mock = new HassWebSocketMock();
// Get the connected hass client
await using var hassClient = await mock.GetHassConnectedClient().ConfigureAwait(false);
var subscribeTask = hassClient.SubscribeToEvents();
// Add result success
mock.AddResponse(@"{""id"": 2, ""type"": ""result"", ""success"": true, ""result"": null}");
await subscribeTask.ConfigureAwait(false);
// Add response event message, see event.json as reference
mock.AddResponse(HassWebSocketMock.EventMessage);
// ACT
HassEvent eventMsg = await hassClient.ReadEventAsync().ConfigureAwait(false);
// ASSERT, object multiple assertions
Assert.NotNull(eventMsg);
Assert.Equal("LOCAL", eventMsg.Origin);
Assert.Equal(DateTime.Parse("2019-02-17T11:43:47.090511+00:00"), eventMsg.TimeFired);
var stateMessage = eventMsg.Data as HassStateChangedEventData;
Assert.True(stateMessage?.EntityId == "binary_sensor.vardagsrum_pir");
Assert.True(stateMessage.OldState?.EntityId == "binary_sensor.vardagsrum_pir");
Assert.True(stateMessage.OldState?.Attributes != null &&
((JsonElement)stateMessage.OldState?.Attributes?["battery_level"]).GetInt32() ! == 100);
Assert.True(((JsonElement)stateMessage.OldState?.Attributes?["on"]).GetBoolean() !);
Assert.True(((JsonElement)stateMessage.OldState?.Attributes?["friendly_name"]).GetString() ! ==
"Rörelsedetektor TV-rum");
// Test the date and time conversions that it matches UTC time
DateTime?lastChanged = stateMessage.OldState?.LastChanged;
// Convert utc date to local so we can compare, this test will be ok on any timezone
DateTime target = new DateTime(2019, 2, 17, 11, 41, 08, DateTimeKind.Utc).ToLocalTime();
Assert.True(lastChanged.Value.Year == target.Year);
Assert.True(lastChanged.Value.Month == target.Month);
Assert.True(lastChanged.Value.Day == target.Day);
Assert.True(lastChanged.Value.Hour == target.Hour);
Assert.True(lastChanged.Value.Minute == target.Minute);
Assert.True(lastChanged.Value.Second == target.Second);
// Just test one of the NewStateOne
Assert.True(stateMessage.NewState?.EntityId == "binary_sensor.vardagsrum_pir");
}
public async Task TestSubscribeEvents()
{
await using var wscli = new HassClient();
bool result = await wscli.ConnectAsync(new Uri("ws://127.0.0.1:5001/api/websocket"), "ABCDEFGHIJKLMNOPQ",
false);
Assert.True(result);
Assert.True(await wscli.SubscribeToEvents());
HassEvent eventMsg = await wscli.ReadEventAsync();
var stateMessage = eventMsg?.Data as HassStateChangedEventData;
Assert.True(stateMessage != null && stateMessage.EntityId == "binary_sensor.vardagsrum_pir");
Assert.True(stateMessage.OldState?.EntityId == "binary_sensor.vardagsrum_pir");
Assert.True(stateMessage.OldState?.Attributes != null &&
((JsonElement)stateMessage.OldState?.Attributes?["battery_level"]).GetInt32() ! == 100);
Assert.True(((JsonElement)stateMessage.OldState?.Attributes?["on"]).GetBoolean() !);
Assert.True(((JsonElement)stateMessage.OldState?.Attributes?["friendly_name"]).GetString() ! ==
"Rörelsedetektor TV-rum");
// Test the date and time conversions that it matches UTC time
DateTime?lastChanged = stateMessage.OldState?.LastChanged;
// Convert utc date to local so we can compare, this test will be ok on any timezone
DateTime targetChanged = new DateTime(2019, 2, 17, 11, 41, 08, DateTimeKind.Utc).ToLocalTime();
// Test the date and time conversions that it matches UTC time
DateTime?lastUpdated = stateMessage.OldState?.LastUpdated;
// Convert utc date to local so we can compare, this test will be ok on any timezone
DateTime targetUpdated = new DateTime(2019, 2, 17, 11, 42, 08, DateTimeKind.Utc).ToLocalTime();
Assert.True(lastChanged.Value.Year == targetChanged.Year);
Assert.True(lastChanged.Value.Month == targetChanged.Month);
Assert.True(lastChanged.Value.Day == targetChanged.Day);
Assert.True(lastChanged.Value.Hour == targetChanged.Hour);
Assert.True(lastChanged.Value.Minute == targetChanged.Minute);
Assert.True(lastChanged.Value.Second == targetChanged.Second);
Assert.True(lastUpdated.Value.Year == targetUpdated.Year);
Assert.True(lastUpdated.Value.Month == targetUpdated.Month);
Assert.True(lastUpdated.Value.Day == targetUpdated.Day);
Assert.True(lastUpdated.Value.Hour == targetUpdated.Hour);
Assert.True(lastUpdated.Value.Minute == targetUpdated.Minute);
Assert.True(lastUpdated.Value.Second == targetUpdated.Second);
await wscli.CloseAsync();
}
public async Task EventWithStateIntegerShouldHaveCorrectTypeAndValue()
{
var mock = new HassWebSocketMock();
// Get the connected hass client
await using var hassClient = await mock.GetHassConnectedClient().ConfigureAwait(false);
// Add response event message, see event.json as reference
mock.AddResponse(HassWebSocketMock.EventMessageInteger);
// ACT
HassEvent eventMsg = await hassClient.ReadEventAsync().ConfigureAwait(false);
var stateMessage = eventMsg.Data as HassStateChangedEventData;
Assert.Equal(321, stateMessage?.NewState.State);
Assert.Equal(123, stateMessage?.OldState.State);
}
public async Task SubscriptToEventTypeShouldReturnEvent(EventType eventType)
{
// ARRANGE
var mock = new HassWebSocketMock();
// Get the connected hass client
await using var hassClient = await mock.GetHassConnectedClient().ConfigureAwait(false);
// ACT AND ASSERT
var subscribeTask = hassClient.SubscribeToEvents(eventType);
mock.AddResponse(@"{""id"": 2, ""type"": ""result"", ""success"": true, ""result"": null}");
Assert.True(await subscribeTask.ConfigureAwait(false));
mock.AddResponse(HassWebSocketMock.EventMessage);
HassEvent eventMsg = await hassClient.ReadEventAsync().ConfigureAwait(false);
Assert.NotNull(eventMsg);
}
private static async Task ConnectToHomeAssistant(string ip, short port, bool events, string token)
{
ILoggerFactory factory = LoggerFactory.Create(builder =>
{
builder
.ClearProviders()
// .AddFilter("HassClient.HassClient", LogLevel.Trace)
.AddConsole()
.AddDebug()
.SetMinimumLevel(LogLevel.Trace);
});
await using IHassClient client = new HassClient(factory);
var token_env = Environment.GetEnvironmentVariable("HASS_TOKEN");
if (token_env != null)
{
token = token_env;
}
bool connected = await client.ConnectAsync(ip, port, false, token, true);
if (!connected)
{
Console.WriteLine("Failed to connect to Home assistant.. bailing...");
return;
}
Console.WriteLine("Login success");
if (client.States != null)
{
Console.WriteLine($"Number of states: {client.States.Count}");
}
var services = await client.GetServices();
var tempTest = client.States["sensor.frysnere_temperature"];
if (events)
{
// Subscribe to all events
await client.SubscribeToEvents();
}
// await client.CallService("light", "toggle", new { entity_id = "light.tomas_rum" });
await client.CallService("light", "no_exist", new { entity_id = "light.tomas_rum_not_exist" });
//var tt = await client.SetState("sensor.csharp", "cool", new {daemon = true});
//var result = await client.SendEvent("test_event", new { data="hello" });
while (true)
{
try
{
HassEvent eventMsg = await client.ReadEventAsync();
// if (nrOfTimes++ > 8)
// {
// await client.DisposeAsync();
// System.Console.WriteLine("Closing and returning...");
// return;
// }
//Console.WriteLine($"Eventtype: {eventMsg.EventType}");
if (eventMsg.EventType == "state_changed")
{
var stateMessage = eventMsg?.Data as HassStateChangedEventData;
Console.WriteLine(
$"{stateMessage.EntityId}: {stateMessage.OldState.State}->{stateMessage.NewState.State}");
}
else if (eventMsg.EventType == "call_service")
{
var serviceMessage = eventMsg?.Data as HassServiceEventData;
serviceMessage.ServiceData = null;
Console.WriteLine($"{serviceMessage.Service}: {serviceMessage.ServiceData}");
}
else
{
Console.WriteLine("event!");
}
}
catch (OperationCanceledException)
{
// Graceful
return;
}
catch (Exception e)
{
Console.WriteLine("Error", e);
return;
}
}
}
