Keep the automation config when replacing a device in device automations

Author: piitaya

src/components/device/ha-device-automation-picker.ts

@@ -11,8 +11,9 @@ import type { LocalizeFunc } from "../../common/translations/localize";
 import { fullEntitiesContext } from "../../data/context";
 import type { DeviceAutomation } from "../../data/device/device_automation";
 import {
+  deviceAutomationExtraConfig,
   deviceAutomationsEqual,
-  deviceAutomationsSimilar,
+  findEquivalentDeviceAutomation,
   sortDeviceAutomations,
 } from "../../data/device/device_automation";
 import type { EntityRegistryEntry } from "../../data/entity/entity_registry";
@@ -202,29 +203,40 @@ export abstract class HaDeviceAutomationPicker<
       : // No device, clear the list of automations
         [];
 
-    // If there is no value, or if we have changed the device ID, reset the
-    // value. When the device changed (for example after replacing a removed
-    // device), try to keep the same automation type/subtype on the new device
-    // before falling back to the first available automation.
     if (!this.value || this.value.device_id !== this.deviceId) {
-      const equivalent =
-        this.value && this.deviceId
-          ? this._automations.find((automation) =>
-              deviceAutomationsSimilar(automation, this.value!)
-            )
-          : undefined;
-      this._setValue(
-        equivalent ||
-          (this._automations.length
-            ? this._automations[0]
-            : this._createNoAutomation(this.deviceId))
-      );
+      this._updateValueForDevice();
     }
     this._renderEmpty = true;
     await this.updateComplete;
     this._renderEmpty = false;
   }
 
+  // The current value belongs to another device, either because there is no
+  // value yet or because the device was just changed. Move it to the same
+  // automation on the new device when there is one, otherwise start over.
+  private _updateValueForDevice() {
+    if (this.deviceId && this.value) {
+      const equivalent = findEquivalentDeviceAutomation(
+        this._entityReg,
+        this._automations!,
+        this.value
+      );
+      if (equivalent) {
+        this._setValue({
+          ...equivalent,
+          ...deviceAutomationExtraConfig(this.value),
+        });
+        return;
+      }
+    }
+
+    this._setValue(
+      this._automations!.length
+        ? this._automations![0]
+        : this._createNoAutomation(this.deviceId)
+    );
+  }
+
   private _automationChanged(ev: ValueChangedEvent<string>) {
     ev.stopPropagation();
     const value = ev.detail.value;

src/data/device/device_automation.ts

@@ -182,26 +182,70 @@ export const deviceAutomationEditorMode = (
     : "unknown-device";
 };
 
-// Like deviceAutomationsEqual, but ignores device_id and entity_id so an
-// automation can be matched to the equivalent one on a different device (for
-// example when a referenced device was replaced by a split device).
-export const deviceAutomationsSimilar = (
+// Whether two device automations describe the same kind of automation, meaning
+// the same domain, type, subtype and event. Which device and which entity they
+// apply to is ignored, so an automation can be matched against the ones another
+// device offers.
+const deviceAutomationsSameType = (a: DeviceAutomation, b: DeviceAutomation) =>
+  deviceAutomationIdentifiers
+    .filter((property) => property !== "device_id" && property !== "entity_id")
+    .every((property) => Object.is(a[property], b[property]));
+
+// Whether two device automations point at the same entity. Both the entity
+// registry id and the entity id are accepted as reference, on either side.
+const deviceAutomationsSameEntity = (
+  entityRegistry: EntityRegistryEntry[],
   a: DeviceAutomation,
   b: DeviceAutomation
 ) => {
-  if (typeof a !== typeof b) {
+  if (!a.entity_id && !b.entity_id) {
+    return true;
+  }
+  if (!a.entity_id || !b.entity_id) {
     return false;
   }
-  return deviceAutomationIdentifiers
-    .filter((property) => property !== "device_id" && property !== "entity_id")
-    .every((property) => {
-      const inA = property in a;
-      const inB = property in b;
-      if (!inA && !inB) {
-        return true;
-      }
-      return Object.is(a[property], b[property]);
-    });
+  return (
+    a.entity_id === b.entity_id ||
+    compareEntityIdWithEntityRegId(entityRegistry, a.entity_id, b.entity_id)
+  );
+};
+
+// Finds, among the automations a device offers, the one matching the given
+// automation, so a device automation can follow its device after the device was
+// replaced. A device exposes the same automation type once per entity, so
+// matching on the type alone picks an arbitrary entity. Splitting a device
+// leaves the entity registry ids untouched, which makes the entity the reliable
+// match, the type only serving as a fallback for entity-less automations.
+export const findEquivalentDeviceAutomation = <T extends DeviceAutomation>(
+  entityRegistry: EntityRegistryEntry[],
+  automations: T[],
+  automation: DeviceAutomation
+): T | undefined => {
+  const sameType = automations.filter((candidate) =>
+    deviceAutomationsSameType(candidate, automation)
+  );
+  const sameEntity = sameType.find((candidate) =>
+    deviceAutomationsSameEntity(entityRegistry, candidate, automation)
+  );
+  return sameEntity || sameType[0];
+};
+
+// Everything the automation list does not return: the extra fields of the
+// capabilities schema (`for`, `above`, ...) and the config of the row holding
+// the automation (`enabled`, `id`, `alias`, ...).
+export const deviceAutomationExtraConfig = <T extends DeviceAutomation>(
+  automation: T
+): Partial<T> => {
+  const extraConfig: Partial<T> = {};
+  for (const property in automation) {
+    if (
+      property !== "metadata" &&
+      !deviceAutomationIdentifiers.includes(property)
+    ) {
+      extraConfig[property] = automation[property];
+    }
+  }
+  return extraConfig;
 };
 
 const compareEntityIdWithEntityRegId = (

test/data/device_automation.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import type { DeviceTrigger } from "../../src/data/device/device_automation";
+import { findEquivalentDeviceAutomation } from "../../src/data/device/device_automation";
+import type { EntityRegistryEntry } from "../../src/data/entity/entity_registry";
+
+const entityRegistry = [
+  { id: "regid1", entity_id: "binary_sensor.one" },
+  { id: "regid2", entity_id: "binary_sensor.two" },
+] as EntityRegistryEntry[];
+
+const trigger = (partial: Partial<DeviceTrigger>): DeviceTrigger =>
+  ({
+    trigger: "device",
+    domain: "binary_sensor",
+    device_id: "device1",
+    ...partial,
+  }) as DeviceTrigger;
+
+describe("findEquivalentDeviceAutomation", () => {
+  it("picks the automation on the same entity among several of the same type", () => {
+    const automations = [
+      trigger({ device_id: "device2", type: "turned_on", entity_id: "regid1" }),
+      trigger({ device_id: "device2", type: "turned_on", entity_id: "regid2" }),
+    ];
+
+    expect(
+      findEquivalentDeviceAutomation(
+        entityRegistry,
+        automations,
+        trigger({ type: "turned_on", entity_id: "regid2" })
+      )
+    ).toBe(automations[1]);
+  });
+
+  it("matches an entity referenced by entity id against one referenced by registry id", () => {
+    const automations = [
+      trigger({ device_id: "device2", type: "turned_on", entity_id: "regid1" }),
+      trigger({ device_id: "device2", type: "turned_on", entity_id: "regid2" }),
+    ];
+
+    expect(
+      findEquivalentDeviceAutomation(
+        entityRegistry,
+        automations,
+        trigger({ type: "turned_on", entity_id: "binary_sensor.two" })
+      )
+    ).toBe(automations[1]);
+  });
+
+  it("falls back to the first automation of the same type when the entity is elsewhere", () => {
+    const automations = [
+      trigger({ device_id: "device2", type: "turned_on", entity_id: "regid1" }),
+      trigger({
+        device_id: "device2",
+        type: "turned_off",
+        entity_id: "regid1",
+      }),
+    ];
+
+    expect(
+      findEquivalentDeviceAutomation(
+        entityRegistry,
+        automations,
+        trigger({ type: "turned_on", entity_id: "regid2" })
+      )
+    ).toBe(automations[0]);
+  });
+
+  it("matches entity-less automations on their subtype", () => {
+    const automations = [
+      trigger({
+        device_id: "device2",
+        domain: "zha",
+        type: "remote_button_short_press",
+        subtype: "button_1",
+      }),
+      trigger({
+        device_id: "device2",
+        domain: "zha",
+        type: "remote_button_short_press",
+        subtype: "button_2",
+      }),
+    ];
+
+    expect(
+      findEquivalentDeviceAutomation(
+        entityRegistry,
+        automations,
+        trigger({
+          domain: "zha",
+          type: "remote_button_short_press",
+          subtype: "button_2",
+        })
+      )
+    ).toBe(automations[1]);
+  });
+
+  it("returns undefined when the device offers no automation of that type", () => {
+    const automations = [
+      trigger({
+        device_id: "device2",
+        type: "turned_off",
+        entity_id: "regid1",
+      }),
+    ];
+
+    expect(
+      findEquivalentDeviceAutomation(
+        entityRegistry,
+        automations,
+        trigger({ type: "turned_on", entity_id: "regid1" })
+      )
+    ).toBeUndefined();
+  });
+});