platypush/platypush
platypush/platypush
2
2
Fork 4
Code Issues 31 Pull requests 1 Projects 4 Releases Packages Wiki Activity

[#29] Support for general-purpose entities #230

Closed
blacklight wants to merge 0 commits from 29-generic-entities-support into master
pull from: 29-generic-entities-support
merge into: platypush:master
Conversation 1 Commits - Files changed -
blacklight commented 2022-10-07 11:18:02 +02:00
Owner
Copy link

Closes: #29

TODO list:

  • Update UI on EntityUpdateEvent
  • UI manual refresh feature
  • Refresh button on group level
  • Plugin/group/entity info modal
  • Support for entity scan timeout
  • Investigate Z-Wave timeout on refresh
  • Implement entity loading notification upon action
  • Entities should be the default view on load
  • Double-check responsiveness on small screens
  • Test case with empty entities db
  • Investigate null created_at/meta fields
  • Investigate broken items on e.g. zigbee/zwave UI panels
  • Implement entities rename
  • Implement entities deletion
  • Implement support for custom icons for entities
  • Support for read-only/write-only entity definitions
  • Implement light entities
  • Investigate what is wrong with zigbee2mqtt
  • Light entities support on zigbee/zwave
  • Merge light.hue plugin/backend
  • Support light entities on smartthings
  • Don't wait for a response on MQTT on device_set if the device is write-only
  • Blink entities upon update
  • Show last_updated_at in entities
  • Fix broken remove entities
  • Support for parent/child relations for entities
  • Support for zwave configuration entities
  • Support for zigbee configuration entities
  • Generic support for lights on zwave.mqtt
  • Support for entity URLs
  • Support unreachable entities flag on zwave.mqtt
  • Support unreachable entities flag on zigbee.mqtt
  • Support all available entities on smartthings
  • Merge zigbee.mqtt plugin/backend
  • Merge zwave.mqtt plugin/backend
  • Replace @manages workaround with property EntityManager class
  • Support general-purpose entities on switchbot integration
  • Support general-purpose entities on bluetooth integration
  • [ ] Support OTA updates on zigbee.mqtt entities (moved to #242)
  • [ ] Support OTA updates on zwave.mqtt entities (moved to #242)
  • [ ] Support sensors in light.hue (moved to #243)
  • [ ] Support dimmers in light.hue (moved to #243)
  • Support entities in switchbot
  • [ ] Support nested filters on @hook (requires further refinements/use cases)
  • Implement entity modal
  • Display data attributes on UI modal
  • [ ] Add support for groups (moved to #244)
  • [ ] Add support for scenes (moved to #245)
  • [ ] Entity history (too complex to implement, too many use cases, and it can probably be handled better with custom user scripts on entity events that store them however the user wants)
  • Test new UI on Firefox
  • Remove (legacy) switches
  • Remove (legacy) zwave integration
  • Implement sensor entities
  • [ ] Implement camera entities (moved to #246)
  • Fix light.hue broken brightness/temp selectors
  • UI support for reachable flag
  • [ ] TV entities support for smartthings/samsungtvws (smartthings TV support has already been implemented, while samsungtvws is too specific to be modeled as a generic entity)
  • [ ] Media player entities support (moved to #247)
  • [ ] Audio player entities support (moved to #248)
  • [ ] Audio stream entities support (moved to #249)
  • Add optimizations for <keep-alive> components
Closes: #29 TODO list: * [x] Update UI on EntityUpdateEvent * [x] UI manual refresh feature * [x] Refresh button on group level * [x] Plugin/group/entity info modal * [x] Support for entity scan timeout * [x] Investigate Z-Wave timeout on refresh * [x] Implement entity loading notification upon action * [x] Entities should be the default view on load * [x] Double-check responsiveness on small screens * [x] Test case with empty entities db * [x] Investigate null created_at/meta fields * [x] Investigate broken items on e.g. zigbee/zwave UI panels * [x] Implement entities rename * [x] Implement entities deletion * [x] Implement support for custom icons for entities * [x] Support for read-only/write-only entity definitions * [x] Implement light entities * [x] Investigate what is wrong with zigbee2mqtt * [x] Light entities support on `zigbee`/`zwave` * [x] Merge `light.hue` plugin/backend * [x] Support light entities on `smartthings` * [x] Don't wait for a response on MQTT on `device_set` if the device is write-only * [x] Blink entities upon update * [x] Show `last_updated_at` in entities * [x] Fix broken _remove entities_ * [x] Support for parent/child relations for entities * [x] Support for `zwave` configuration entities * [x] Support for `zigbee` configuration entities * [x] Generic support for lights on `zwave.mqtt` * [x] Support for entity URLs * [x] Support unreachable entities flag on `zwave.mqtt` * [x] Support unreachable entities flag on `zigbee.mqtt` * [x] Support all available entities on `smartthings` * [x] Merge `zigbee.mqtt` plugin/backend * [x] Merge `zwave.mqtt` plugin/backend * [x] Replace `@manages` workaround with property `EntityManager` class * [x] Support general-purpose entities on `switchbot` integration * [x] Support general-purpose entities on `bluetooth` integration * ~~[ ] Support OTA updates on `zigbee.mqtt` entities~~ (moved to [#242](https://git.platypush.tech/platypush/platypush/issues/242)) * ~~[ ] Support OTA updates on `zwave.mqtt` entities~~ (moved to [#242](https://git.platypush.tech/platypush/platypush/issues/242)) * ~~[ ] Support sensors in `light.hue`~~ (moved to [#243](https://git.platypush.tech/platypush/platypush/issues/243)) * ~~[ ] Support dimmers in `light.hue`~~ (moved to [#243](https://git.platypush.tech/platypush/platypush/issues/243)) * [x] Support entities in `switchbot` * ~~[ ] Support nested filters on `@hook`~~ (requires further refinements/use cases) * [x] Implement entity modal * [x] Display `data` attributes on UI modal * ~~[ ] Add support for groups~~ (moved to [#244](https://git.platypush.tech/platypush/platypush/issues/244)) * ~~[ ] Add support for scenes~~ (moved to [#245](https://git.platypush.tech/platypush/platypush/issues/245)) * ~~[ ] Entity history~~ (too complex to implement, too many use cases, and it can probably be handled better with custom user scripts on entity events that store them however the user wants) * [x] Test new UI on Firefox * [x] Remove (legacy) `switches` * [x] Remove (legacy) `zwave` integration * [x] Implement sensor entities * ~~[ ] Implement camera entities~~ (moved to [#246](https://git.platypush.tech/platypush/platypush/issues/246)) * [x] Fix light.hue broken brightness/temp selectors * [x] UI support for `reachable` flag * ~~[ ] TV entities support for `smartthings`/`samsungtvws`~~ (`smartthings` TV support has already been implemented, while `samsungtvws` is too specific to be modeled as a generic entity) * ~~[ ] Media player entities support~~ (moved to [#247](https://git.platypush.tech/platypush/platypush/issues/247)) * ~~[ ] Audio player entities support~~ (moved to [#248](https://git.platypush.tech/platypush/platypush/issues/248)) * ~~[ ] Audio stream entities support~~ (moved to [#249](https://git.platypush.tech/platypush/platypush/issues/249)) * [x] Add optimizations for `<keep-alive>` components
This is particularly useful when we want to access the registry from
another process, like the web server or an external script.
Metadata attributes can now be defined and overridden on the object
itself, as well as on the database. Note that db settings will always
take priority in case of value conflicts.
- Interaction with entities should occur through the `entities.action`
  method, not by implementing native methods on each of the model
  objects
- Added cache support to prevent duplicate EntityUpdateEvents
- The cache is smartly pre-populated and kept up-to-date, so it's
  possible to trigger events as soon as the entities are published by
  the plugin (not only when the records are flushed to the internal db)
If an event comes from an entity that hasn't been persisted yet on the
internal storage then we wait for the entity record to be committed
before firing an event. It's better to wait a couple of seconds for the
database to synchronize rather than dealing with entity events with
incomplete objects.
The UI relies on these events upon refresh to detect if a device is
still reacheable. Therefore, we shouldn't mask them if we don't detect
any changes with the current entity configuration/state.
Some plugins may represent entity IDs as integers, while the database
maps external IDs to strings. This may result in entities being
incorrectly mapped during merging. Casting to string prevents these
type-related ambiguities.
- Added support for lights as native platform entities.
- Improved performance by using the JSON API objects whenever possible
  to interact with the bridge instead of the native Python objects,
  which perform a bunch of lazy API calls under the hood resulting in
  degraded performance.
- Fixed lights animation attributes by setting only the ones actually
  supported by a light.
- Several LINT fixes.
It may be an incomplete update that breaks the UI, and it will be
overwritten by the backend event anyway
TODO: Support for colors (I don't have a color Zigbee bulb to test it on yet)
The polling logic has been moved to the `light.hue` plugin itself
instead, so it's no longer required to have both a plugin and a backend
enabled in order to fully manage a Hue bridge.
- Don't return a redirect to the login page if an authentication failed
  over a JSON endpoint - instead, return a JSON payload with the error.

- Added support for additional fonts.

- Re-designed the login/registration page.

- Updated caniuse database.
blacklight changed title from WIP: Support for general-purpose entities to [#29] WIP: Support for general-purpose entities 2022-10-07 11:20:05 +02:00 
Only include readable (not state-only) properties on the payload sent to
to `zigbee2mqtt/<device>/get`.
Changed from `type` to `category`, which is basically the `name_plural`
attribute of the associated entity type metadata.

This allows us to define distinct entity metadata entries that we still
want to share the same grouping - for instance, `temperature_sensor`,
`humidity_sensor` and `battery` should all be grouped under `Sensors` on
the frontend.
Implemented (at least in `zigbee.mqtt`, for now):

- `TemperatureSensor`
- `HumiditySensor`
- `VoltageSensor`
- `CurrentSensor`
- `EnergySensor`
- `PowerSensor`
- `NumericSensor` (generic fallback 1)
- `RawSensor` (generic fallback 2)
- `Sensor` (root class)
- Don't publish a `get` request if the device has no exposed queriable
  attributes.

- Perform the recursive build of the `get` request payload before
  checking for the `access` attribute.
Now handling cases of nodes with values having multiple levels (> 1) of
nested properties.
Done for `zigbee.mqtt`, other plugins will follow
This prevents multiprocessing/concurrency issues when modifying the same
database file both from the main process and from the web server process
- The `declarative_base` instance should be shared
- Database `session_locks` should be stored at module, not instance
  level
- Better isolation of scoped sessions
- Enclapsulated `get_session` method in `UserManager`
SQLite doesn't enable foreign keys cascade on delete by default.
`UserManager.get_users` should not return a reference to the query
object, since the query object will be invalidated as soon as the
connection is closed.

Instead, it should return directly the list of `User` objects.
- Larger icon div to prevent text overlapping with icons
- Support for `selected` class
- Infer entity types on the basis of their semantic type (bool, decimal,
  list) and read-only attribute (read-only bool is `BinarySensor`,
  read-write bool is `Switch`, read-only decimal is `NumericSensor`,
  read-write decimal is `Dimmer`, etc.) instead of trying to infer it
  from the command class. Only a small set of command classes (like
  configurations, vendor-specific or internal values) will be excluded.
  This should greatly increase the number of supported values.

- Added support for `EnumSwitch` entities.

- Added inference for illuminance and humidity sensors.
blacklight changed title from [#29] WIP: Support for general-purpose entities to WIP: [#29] WIP: Support for general-purpose entities 2022-11-27 23:02:29 +01:00
blacklight changed title from WIP: [#29] WIP: Support for general-purpose entities to WIP: [#29] Support for general-purpose entities 2022-11-27 23:02:44 +01:00 
The parent->child relationship is now modelled on the database itself,
so we no longer need value names specifically formatted as
`[DeviceName] ValueName` - the UI will take care of it.
Change the documentation accordingly
The most recent versions of ZwaveJS-UI don't send the `hexId` of the
node on node change events. We have therefore to infer it from the
reported `dbLink`.
The most recent versions of ZwaveJS-UI don't send the `hexId` of the
node on node change events. We have therefore to infer it from the
reported `dbLink`.
ZWaveJS has broken back-compatibility with zwavejs2mqtt when it comes to
events format.

Only a partial representation of the node and value objects is
forwarded, and that's often not sufficient to infer the full state of
the node with its values.

The `_dispatch_event` logic has therefore been modified to accommodate
both the implementation.

This means that we have to go conservative in order to preserve
back-compatibility and not over-complicate things, even if it (slightly)
comes at the expense of performance.
The `disable_logging` attribute was only available on events and
responses, and it could only either entirely disable or enable logging
for all the events of a certain type.

The new flag allows more customization by setting the default logging
level used for any message of a certain type (or `None` to disable
logging). This makes it possible to e.g. set some verbose events to
debug level, and the user can see them if they configure the application
in debug mode.

It also delegates the logging logic to the message itself, instead of
having different parts of the application handling their own logic.
This may make things a bit less optimal, but it's probably the only
possible solution that preserves my sanity.

Managing upserts of cached instances that were previously made transient
and expunged from the session is far from easy, and the management of
recursive parent/children relationships only add one more layer of
complexity (and that management is already complex enough in its current
implementation).
The Numeric type may have casting/rounding issues with SQLite.
Serializing both children_ids and parent_id can result in nasty
SQLAlchemy bugs, especially when handling objects that haven't been
flushed yet.
The Zeroconf registration part may randomly get stuck, resulting in the
web server not being properly started.

It's therefore better to run the Zeroconf registration process
asynchronously, for it's not strictly required for the web server to
execute.
Also, print the error only on the first occurrence, to prevent log
spamming.
- Support for device options as children configuration entities
- Refactored switches management, removed legacy `switches` plugin
  integration, and supporting multiple binary switches for one device
It can also be a class -> boolean object.
Renamed to `notifyWarning` and `notifyError` respectively.

Those names can often clash with other properties defined on components
that extend the mixin (like entities).
The performance of the page is heavily degraded by components loaded
dynamically via defineAsyncComponent that recursively carry behind the
whole Vue machinery.

By wrapping defineAsyncComponent calls in shallowRef we make sure that
we only wire the root level of the newly created dynamic component.
- Toggle collapsed state also if clicked on the gap between the entity
  name and the right edge, instead of opening the entity modal. The
  entity configuration modal should open only when clicking on the
  entity name or icon (and these should be highlighted on hover as links
  as well).

- The collapsed state update should be propagated to the wrapped
  component as well, if applicable.
The EntityUpdateEvents generated by light.hue are now less noisy.
- Removed some redundant `pass` statements in Z-Wave derived event classes
- Added support for `Battery` entities
- Fixed saturation range for `Light` entities
- Parsing `min`/`max`/`unit` from the status attributes, if available
This removes warnings on `config.get`, where the `logging` configuration
key may also contain the current logging stream and we end up with a
JSONDecodeError when trying to serialize it.
- Deprecated the old `zigbee.mqtt` backend
- Black style for the `mqtt` backend
Race conditions may occur here
`switch.tplink` converted to a `RunnablePlugin` that implements
`SwitchEntityManager`.
Better prototype for `MultiLevelSwitchEntityManager.set_value`
- Better synchronization logic on stop for `AsyncRunnablePlugin`.
- Fixed several thread names by dropping `prctl.set_name` in favour of
  specifying the name directly on thread creation.
- Several LINT fixes.
- Out `gattlib` + `pybluez`, in `bleak`. It's not platform-dependent, it doesn't
  require libboost and other heavy build dependencies, and it doesn't require the
  user that runs the service from having special privileges to access raw
  Bluetooth sockets.

- Better integration with Platypush native entities. The devices are now mapped
  to write-only `EnumSwitch` entities, and the status returns the serialized
  representation of those entities instead of the previous intermediate
  representation.
- Added small documentation/annotations notes to the `Plugin` module.

- Small LINT fixes
- Added `BluetoothDevice` as its own entity type.
Scan capabilities are now implemented on the `bluetooth` plugin itself.
Exceptions that cause the termination of the plugin's loop should always
be logged as such, unless the plugin is supposed to stop and various
exceptions may occur upon teardown.
It will now automatically deal with most of the native types and convert
them to strings on the db.
These events handle the case where a Bluetooth device only publishes new
service data without advertising any additional updated properties.
- Better logic to recursively link parent/children entities, so partial
  updates won't get lost.

- Removed `EntitiesCache` - it was too much to maintain while keeping
  consistent with the ORM, and it was a perennial fight against
  SQLAlchemy's own cache.

- Removed `EntityNotifier` - with no need to merge cached entities, the
  `notify` method has become much simpler and it's simply been merged
  in the `EntitiesRepository`.
30 -> 15 seconds.
stuff
- Support for an optional callback on `publish_entities` to get notified
  when the published object are flushed to the db.

- Use `lazy='selectin'` for the entity parent -> children relationship -
  it is more efficient and it ensures that all the data the application
  needs is loaded upfront.

- `Entity.entity_key` rolled back to `<external_id, plugin>`. The
  fallback logic on `<id, plugin>` created more problems than those it
  as supposed to solve.

- Added `expire_on_commit=False` to the entities engine session to make
  sure that we don't get errors on detached/expired instances.
ImportErrors on these entity modules will be ignored when dynamically
loading them, since they have optional external dependencies and we
shouldn't throw an error if we can't import them.
- Added `wait_start()` method that other threads can use to synchronize
  with the engine and wait before performing db operations.

- Callback logic wrapped in a try/except block to prevent custom
  integrations with buggy callbacks from crashing the engine.
That's the best way to ensure that all the columns are fetched eagerly and
prevent errors later when trying to access lazily loaded attributes outside
of the session/thread.
Not the upserted entities themselves, no matter if expunged or made transient.

Reminder to my future self: returning the flushed entities and then using them
outside of the session or in another thread opens a big can of worms when using
SQLAlchemy.
- Merged together Bluetooth legacy and BLE plugins and scanners.
- Introduced Theengs as a dependency to infer BLE device types and
  create sub-entities appropriately.
- Using `BluetoothDevice` and `BluetoothService` entities as the bread
  and butter for all the Bluetooth plugin's components.
- Using a shared cache of devices and services between the legacy and
  BLE integrations, with merging/coalescing logic included.
- Extended list of discoverable services to include all those officially
  supported by the Bluetooth specs.
- Instantiate a separate pool of workers to discover services.
- Refactor of the Bluetooth events - all of them are now instantiated
  from a single `BluetoothDevice` object.
BluetoothService IDs should always be in the format `address::uuid` and
the name should always be in title format.
It's likely to just include the native type name anyway.
1. Check the manufacturer parsed via Bleak/Theengs
2. Check the MAC address prefix in the oui numbers table
3. Check from the reported `manufacturer_data`
The logic to exclude BLE beacons from randomized devices needs to be a
bit more granular and not limited only to the reported device
manufacturer.
This includes BLE beacons sent from all Google/Apple/Microsoft/Samsung
beacon networks in all of their variants.
Changed the BLE beacon parsing logic to read those fields from
`AdvertisementData` instead of `BLEDevice`.
This should avoid the risk of `DetachedInstanceError` by retrieving the
object into the session if it's not available.
GATT characteristics are not necessarily exposed as services.
Based on device address, name or manufacturer.
This logic will be used if the connection wasn't opened by the current
process and therefore a call to DBus is required to terminate it.
No replacements have been made for the OBEX backends (push and file
services). PyOBEX is too broken and unmaintained, and there are too many
poorly documented steps required to get an unprivileged user to run an
SDP service.
It's better for entity managers to be stored in their own public
package, instead of cluttering too much the namespace of their parent
package.
- Support for cloud instances as native entities.
- Using Marshmallow dataclasses+schemas instead of custom `Response`
  objects.
- Merge `linode` backend into `linode` plugin.
Workaround for the circular dependency between
`platypush.entities.bluetooth` and `platypush.plugins.bluetooth.model`.

Unentangling the circular dependency would require way too much work,
since the entity model provides several helpers and properties that
depend on the plugin's model.

The workaround in this commit is to simply push those imports down in
the methods that use them, so they won't be imported until those methods
are called, as well as removing some type annotations that depended on
those objects.
For sake of consistency - we also have `instance_id` and having the
instance name assigned to the `instance` attribute is quite ambiguous.
`str.title` capitalizes any alphabetic letter after any non-alphabetic
letter. That's a problem for Platypush plugins' naming convention,
because plugins like `sensor.distance.vl53l1x` may be broken into
`sensor.distance.vl53.l1.x`.
`backend.serial` has been removed and the polling logic merged into the
`serial` plugin.

The `serial` plugin now supports the new entity engine as well.
LGTM is now merged into Github and the badges are no longer available.
The package contains the base types and constants shared across
sensor-based integrations.
Removed the old `backend.sensor.bme280` and the old `gpio.sensor.bme280`
plugin. They have now been merged into the new `sensor.bme280` runnable
plugin, which extends the `SensorPlugin` API and supports entities.
`types.NoneType` is not always available on all Python versions, so we
have to make our own type for it.
Merged `backend.sensor.ltr559` and `gpio.sensor.ltr559` into the new
`sensor.ltr559` plugin, which extends the new `SensorPlugin` API.
No more `_value` in the JSON output instead of the `value` property.

If a column is marked as private, and there's an associated property
mapped to its public name, then we should use and serialize that value.
Removed `backend.sensor.envirophat` and `gpio.sensor.envirophat` plugin.
They have now been merged into the new `sensor.envirophat` plugin.
Not `abs(old_data - new_data) > tolerance`.
Removed legacy `backend.sensor.motion.pmw3901` and
`gpio.sensor.motion.pmw3901`. They have been merged in the new
`sensor.pmw3901` integration, compatible with the new `SensorPlugin`
API.
Removed `backend.sensor.accelerometer` and `gpio.sensor.accelerometer`.
The logic has now been merged in the new `sensor.lis3dh` integration,
which is compatible with the new `SensorPlugin` API.
Removed `backend.sensor.dht` and `gpio.sensor.dht`. They have been
merged into the new `sensor.dht` integration, which supports the new
`SensorPlugin` API.
Remove `backend.sensor.distance` and `gpio.sensor.distance`. They are
now replaced by the `sensor.hcsr04` integration, which is compatible
with the new `SensorPlugin` API.
Now all the plugins that used to implement it have been moved to
`SensorPlugin`.
For sake of naming consistency with other plugins, we should use
`poll_interval` instead.
Not if abs(old_data - new_data) >= tolerance, otherwise events will
always be triggered when tolerance=0, even if the data hasn't changed.
We need to recursively merge the columns of children entities if a child
entity isn't a leaf node.
There are probably more optimal ways of achieving this other than
passing a reference to the full list of entities to each of the
entities, such as running a BFS to recursively expand all the entities
within the child hierarchy of an entity.

This is needed because the entity needs to know which entities aren't
direct children, but are two or more layers down in the hierarchy, so
they should be passed to their own child entities.
Also, there is now a single `Cpu` entity being exported, with a nested
hierarchy structured like:

```
cpu
  -> cpu_info
  -> cpu_times
    -> idle
    -> user
    -> system
    -> ...
  -> cpu_load
    -> ...
```
Plus, `platypush.schemas.system` has now been split into multiple
submodules to avoid a single-file mega-module with all the system
schemas definitions.
- `percent_field` should be declared on `platypush.schemas.dataclasses`
  level, since it's not specific to the `system` plugin.
- Added a common `SystemBaseSchema` that takes care of calling
  `_asdict()` if the object is passed as a `psutil` object instead of a
  dict.
blacklight changed title from WIP: [#29] Support for general-purpose entities to [#29] Support for general-purpose entities 2023-04-23 14:55:52 +02:00
blacklight commented 2023-04-23 22:58:59 +02:00
Author
Owner
Copy link

This PR has already been open for more than a year. Since most of the planned foundational features have now been implemented, this PR can be closed. New tickets have been created for the remaining features.

This PR has already been open for more than a year. Since most of the planned foundational features have now been implemented, this PR can be closed. New tickets have been created for the remaining features.
blacklight closed this pull request 2023-04-23 22:59:12 +02:00

Pull request closed

This pull request cannot be reopened because the branch was deleted.
Sign in to join this conversation.
Reviewers
No reviewers
Labels
Clear labels   
architecture

   
authentication

   
backend

   
bug

   
ci/cd

   
cleanup

   
documentation

   
duplicate

   
enhancement

   
good first issue

   
help wanted

   
in progress

   
invalid

   
media

   
mobile

   
new feature

   
notes

Tickets about notes plugins

  
packaging

   
question

   
ui

   
upstream breaking change

   
voice

   
waiting user input

   
wontfix
No labels
architecture
authentication
backend
bug
ci/cd
cleanup
documentation
duplicate
enhancement
good first issue
help wanted
in progress
invalid
media
mobile
new feature
notes
packaging
question
ui
upstream breaking change
voice
waiting user input
wontfix
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
blacklight
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
platypush/platypush!230
No description provided.