Rename Hass.io -> Supervisor (#1522)

* Rename Hass.io -> Supervisor

* part 2

* fix lint

* fix auth name

supervisor/api/utils.py

@@ -0,0 +1,133 @@
+"""Init file for Supervisor util for RESTful API."""
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from aiohttp import web
+from aiohttp.hdrs import AUTHORIZATION
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from ..const import (
+    CONTENT_TYPE_BINARY,
+    HEADER_TOKEN,
+    HEADER_TOKEN_OLD,
+    JSON_DATA,
+    JSON_MESSAGE,
+    JSON_RESULT,
+    RESULT_ERROR,
+    RESULT_OK,
+)
+from ..exceptions import APIError, APIForbidden, HassioError
+
+_LOGGER: logging.Logger = logging.getLogger(__name__)
+
+
+def excract_supervisor_token(request: web.Request) -> Optional[str]:
+    """Extract Supervisor token from request."""
+    supervisor_token = request.headers.get(HEADER_TOKEN)
+    if supervisor_token:
+        return supervisor_token
+
+    # Remove with old Supervisor fallback
+    supervisor_token = request.headers.get(HEADER_TOKEN_OLD)
+    if supervisor_token:
+        return supervisor_token
+
+    # API access only
+    supervisor_token = request.headers.get(AUTHORIZATION)
+    if supervisor_token:
+        return supervisor_token.split(" ")[-1]
+
+    return None
+
+
+def json_loads(data: Any) -> Dict[str, Any]:
+    """Extract json from string with support for '' and None."""
+    if not data:
+        return {}
+    try:
+        return json.loads(data)
+    except json.JSONDecodeError:
+        raise APIError("Invalid json")
+
+
+def api_process(method):
+    """Wrap function with true/false calls to rest api."""
+
+    async def wrap_api(api, *args, **kwargs):
+        """Return API information."""
+        try:
+            answer = await method(api, *args, **kwargs)
+        except (APIError, APIForbidden) as err:
+            return api_return_error(message=str(err))
+        except HassioError:
+            return api_return_error(message="Unknown Error, see logs")
+
+        if isinstance(answer, dict):
+            return api_return_ok(data=answer)
+        if isinstance(answer, web.Response):
+            return answer
+        elif isinstance(answer, bool) and not answer:
+            return api_return_error()
+        return api_return_ok()
+
+    return wrap_api
+
+
+def api_process_raw(content):
+    """Wrap content_type into function."""
+
+    def wrap_method(method):
+        """Wrap function with raw output to rest api."""
+
+        async def wrap_api(api, *args, **kwargs):
+            """Return api information."""
+            try:
+                msg_data = await method(api, *args, **kwargs)
+                msg_type = content
+            except (APIError, APIForbidden) as err:
+                msg_data = str(err).encode()
+                msg_type = CONTENT_TYPE_BINARY
+            except HassioError:
+                msg_data = b""
+                msg_type = CONTENT_TYPE_BINARY
+
+            return web.Response(body=msg_data, content_type=msg_type)
+
+        return wrap_api
+
+    return wrap_method
+
+
+def api_return_error(message: Optional[str] = None) -> web.Response:
+    """Return an API error message."""
+    return web.json_response(
+        {JSON_RESULT: RESULT_ERROR, JSON_MESSAGE: message}, status=400
+    )
+
+
+def api_return_ok(data: Optional[Dict[str, Any]] = None) -> web.Response:
+    """Return an API ok answer."""
+    return web.json_response({JSON_RESULT: RESULT_OK, JSON_DATA: data or {}})
+
+
+async def api_validate(
+    schema: vol.Schema, request: web.Request, origin: Optional[List[str]] = None
+) -> Dict[str, Any]:
+    """Validate request data with schema."""
+    data: Dict[str, Any] = await request.json(loads=json_loads)
+    try:
+        data_validated = schema(data)
+    except vol.Invalid as ex:
+        raise APIError(humanize_error(data, ex)) from None
+
+    if not origin:
+        return data_validated
+
+    for origin_value in origin:
+        if origin_value not in data_validated:
+            continue
+        data_validated[origin_value] = data[origin_value]
+
+    return data_validated