config_flow.py 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. from __future__ import annotations
  2. from typing import Any
  3. import caldav
  4. import caldav.lib.error as caldav_error
  5. import voluptuous as vol
  6. from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult, OptionsFlow
  7. from homeassistant.core import callback
  8. from homeassistant.helpers.selector import (
  9. BooleanSelector,
  10. TextSelector,
  11. TextSelectorConfig,
  12. TextSelectorType,
  13. )
  14. from .const import (
  15. CONF_CALDAV_ENABLED,
  16. CONF_CALDAV_URL,
  17. CONF_CALENDAR_NAME,
  18. CONF_CURRENT_NAME,
  19. CONF_NEXT_NAME,
  20. CONF_PASSWORD,
  21. CONF_ROOM_STATE_NAME,
  22. CONF_USERNAME,
  23. DEFAULT_CURRENT_NAME,
  24. DEFAULT_NEXT_NAME,
  25. DEFAULT_ROOM_STATE_NAME,
  26. DOMAIN,
  27. SENSOR_KEYS,
  28. default_option_key,
  29. )
  30. class RoomCalConfigFlow(ConfigFlow, domain=DOMAIN):
  31. VERSION = 1
  32. async def async_step_user(
  33. self, user_input: dict[str, Any] | None = None
  34. ) -> ConfigFlowResult:
  35. if user_input is not None:
  36. return self.async_create_entry(
  37. title=user_input[CONF_ROOM_STATE_NAME],
  38. data=user_input,
  39. )
  40. return self.async_show_form(
  41. step_id="user",
  42. data_schema=vol.Schema({
  43. vol.Required(CONF_ROOM_STATE_NAME, default=DEFAULT_ROOM_STATE_NAME): str,
  44. vol.Required(CONF_CURRENT_NAME, default=DEFAULT_CURRENT_NAME): str,
  45. vol.Required(CONF_NEXT_NAME, default=DEFAULT_NEXT_NAME): str,
  46. }),
  47. )
  48. async def async_step_reauth(
  49. self, entry_data: dict[str, Any]
  50. ) -> ConfigFlowResult:
  51. return await self.async_step_reauth_confirm()
  52. async def async_step_reauth_confirm(
  53. self, user_input: dict[str, Any] | None = None
  54. ) -> ConfigFlowResult:
  55. errors: dict[str, str] = {}
  56. if user_input is not None:
  57. try:
  58. await self.hass.async_add_executor_job(
  59. _test_caldav_auth,
  60. self._get_reauth_entry().options.get(CONF_CALDAV_URL, ""),
  61. user_input[CONF_USERNAME],
  62. user_input[CONF_PASSWORD],
  63. )
  64. except caldav_error.AuthorizationError:
  65. errors["base"] = "invalid_auth"
  66. except Exception:
  67. errors["base"] = "cannot_connect"
  68. else:
  69. return self.async_update_reload_and_abort(
  70. self._get_reauth_entry(),
  71. data_updates={
  72. CONF_USERNAME: user_input[CONF_USERNAME],
  73. CONF_PASSWORD: user_input[CONF_PASSWORD],
  74. },
  75. )
  76. return self.async_show_form(
  77. step_id="reauth_confirm",
  78. data_schema=vol.Schema({
  79. vol.Required(CONF_USERNAME): str,
  80. vol.Required(CONF_PASSWORD): TextSelector(
  81. TextSelectorConfig(type=TextSelectorType.PASSWORD)
  82. ),
  83. }),
  84. errors=errors,
  85. )
  86. @staticmethod
  87. @callback
  88. def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
  89. return RoomCalOptionsFlow()
  90. class RoomCalOptionsFlow(OptionsFlow):
  91. async def async_step_init(
  92. self, user_input: dict[str, Any] | None = None
  93. ) -> ConfigFlowResult:
  94. return await self.async_step_caldav()
  95. async def async_step_caldav(
  96. self, user_input: dict[str, Any] | None = None
  97. ) -> ConfigFlowResult:
  98. errors: dict[str, str] = {}
  99. if user_input is not None:
  100. if user_input.get(CONF_CALDAV_ENABLED) and user_input.get(CONF_CALDAV_URL):
  101. try:
  102. await self.hass.async_add_executor_job(
  103. _test_caldav_auth,
  104. user_input[CONF_CALDAV_URL],
  105. self.config_entry.data.get(CONF_USERNAME, ""),
  106. self.config_entry.data.get(CONF_PASSWORD, ""),
  107. )
  108. except caldav_error.AuthorizationError:
  109. errors["base"] = "invalid_auth"
  110. except Exception:
  111. errors["base"] = "cannot_connect"
  112. if not errors:
  113. self._pending_options = dict(self.config_entry.options)
  114. self._pending_options.update(user_input)
  115. return await self.async_step_defaults()
  116. opts = self.config_entry.options
  117. return self.async_show_form(
  118. step_id="caldav",
  119. data_schema=vol.Schema({
  120. vol.Required(CONF_CALDAV_ENABLED, default=opts.get(CONF_CALDAV_ENABLED, False)): BooleanSelector(),
  121. vol.Optional(CONF_CALDAV_URL, default=opts.get(CONF_CALDAV_URL, "")): str,
  122. vol.Optional(CONF_CALENDAR_NAME, default=opts.get(CONF_CALENDAR_NAME, "")): str,
  123. }),
  124. errors=errors,
  125. )
  126. async def async_step_defaults(
  127. self, user_input: dict[str, Any] | None = None
  128. ) -> ConfigFlowResult:
  129. if user_input is not None:
  130. self._pending_options.update(
  131. {default_option_key(k): v or None for k, v in user_input.items()}
  132. )
  133. return self.async_create_entry(data=self._pending_options)
  134. opts = self.config_entry.options
  135. schema_dict: dict[Any, Any] = {}
  136. for key in SENSOR_KEYS:
  137. opt_key = default_option_key(key)
  138. schema_dict[vol.Optional(key, default=opts.get(opt_key, ""))] = str
  139. return self.async_show_form(
  140. step_id="defaults",
  141. data_schema=vol.Schema(schema_dict),
  142. )
  143. def _test_caldav_auth(url: str, username: str, password: str) -> None:
  144. """Blocking: verify credentials by fetching the principal."""
  145. client = caldav.DAVClient(url=url, username=username, password=password)
  146. client.principal()