added weather_status API (#11)

bigcat88 · web-flow · commit 83fbfdb51dca · 2023-07-02T02:02:49.000+03:00
* added `weather_status` API
diff --git a/README.md b/README.md
@@ -20,6 +20,7 @@ Project cloud-py-api was **abandoned** and divided into two parts:
  * ~~Operations with Trash bin and File versions~~
  * Operations with Users and User Groups
  * User status manipulation
+ * Weather status
  * ~~Nextcloud notifications support~~
  * ~~Shares operations support~~
  * ~~Talk support~~
diff --git a/nc_py_api/constants.py b/nc_py_api/constants.py
@@ -21,6 +21,7 @@ class ApiScope(IntEnum):
     USER_INFO = 10
     USER_STATUS = 11
     NOTIFICATIONS = 12
+    WEATHER_STATUS = 13
 
 
 class ApiScopesStruct(TypedDict):
diff --git a/nc_py_api/nextcloud.py b/nc_py_api/nextcloud.py
@@ -15,27 +15,30 @@
 from .preferences import PreferencesAPI
 from .theming import ThemingInfo, get_parsed_theme
 from .ui_files_actions_menu import UiFilesActionsAPI
-from .users import UserAPI
-from .users_groups import UsersGroupsAPI
-from .users_statuses import UsersStatusesAPI
+from .users import UsersAPI
+from .users_groups import UserGroupsAPI
+from .users_status import UserStatusAPI
+from .weather_status import WeatherStatusAPI
 
 
 class NextcloudBasic(ABC):
     apps: AppAPI
     files: FilesAPI
     preferences_api: PreferencesAPI
-    users: UserAPI
-    users_groups: UsersGroupsAPI
-    users_statuses: UsersStatusesAPI
+    users: UsersAPI
+    users_groups: UserGroupsAPI
+    users_status: UserStatusAPI
+    weather_status: WeatherStatusAPI
     _session: NcSessionBasic
 
     def _init_api(self, session: NcSessionBasic):
         self.apps = AppAPI(session)
         self.files = FilesAPI(session)
         self.preferences_api = PreferencesAPI(session)
-        self.users = UserAPI(session)
-        self.users_groups = UsersGroupsAPI(session)
-        self.users_statuses = UsersStatusesAPI(session)
+        self.users = UsersAPI(session)
+        self.users_groups = UserGroupsAPI(session)
+        self.users_status = UserStatusAPI(session)
+        self.weather_status = WeatherStatusAPI(session)
 
     @property
     def capabilities(self) -> dict:
diff --git a/nc_py_api/users.py b/nc_py_api/users.py
@@ -11,7 +11,7 @@
 ENDPOINT = f"{ENDPOINT_BASE}/users"
 
 
-class UserAPI:
+class UsersAPI:
     def __init__(self, session: NcSessionBasic):
         self._session = session
 
diff --git a/nc_py_api/users_groups.py b/nc_py_api/users_groups.py
@@ -19,7 +19,7 @@ class GroupDetails(TypedDict):
     can_remove: bool
 
 
-class UsersGroupsAPI:
+class UserGroupsAPI:
     def __init__(self, session: NcSessionBasic):
         self._session = session
 
diff --git a/nc_py_api/users_status.py b/nc_py_api/users_status.py
@@ -32,7 +32,7 @@ class CurrentUserStatus(UserStatus):
     statusIsUserDefined: bool
 
 
-class UsersStatusesAPI:
+class UserStatusAPI:
     def __init__(self, session: NcSessionBasic):
         self._session = session
 
diff --git a/nc_py_api/weather_status.py b/nc_py_api/weather_status.py
@@ -0,0 +1,79 @@
+"""
+Nextcloud API for working with weather statuses.
+"""
+
+from enum import IntEnum
+from typing import Optional, TypedDict, Union
+
+from ._session import NcSessionBasic
+from .misc import check_capabilities, require_capabilities
+
+ENDPOINT = "/ocs/v2.php/apps/weather_status/api/v1"
+
+
+class WeatherLocationMode(IntEnum):
+    UNKNOWN = 0
+    MODE_BROWSER_LOCATION = 1
+    MODE_MANUAL_LOCATION = 2
+
+
+class WeatherLocation(TypedDict):
+    latitude: float
+    longitude: float
+    address: str
+    mode: WeatherLocationMode
+
+
+class WeatherStatusAPI:
+    def __init__(self, session: NcSessionBasic):
+        self._session = session
+
+    @property
+    def available(self) -> bool:
+        return not check_capabilities("weather_status", self._session.capabilities)
+
+    def get_location(self) -> WeatherLocation:
+        require_capabilities("weather_status", self._session.capabilities)
+        result = self._session.ocs(method="GET", path=f"{ENDPOINT}/location")
+        lat = result.get("lat", "")
+        lon = result.get("lon", "")
+        return {
+            "latitude": float(lat if lat else "0"),
+            "longitude": float(lon if lon else "0"),
+            "address": result.get("address", ""),
+            "mode": WeatherLocationMode(int(result.get("mode", 0))),
+        }
+
+    def set_location(
+        self, latitude: Optional[float] = None, longitude: Optional[float] = None, address: Optional[str] = None
+    ) -> bool:
+        require_capabilities("weather_status", self._session.capabilities)
+        params: dict[str, Union[str, float]] = {}
+        if latitude is not None and longitude is not None:
+            params.update({"lat": latitude, "lon": longitude})
+        elif address:
+            params["address"] = address
+        else:
+            raise ValueError("latitude & longitude or address should be present")
+        result = self._session.ocs(method="PUT", path=f"{ENDPOINT}/location", params=params)
+        return result.get("success", False)
+
+    def get_forecast(self) -> list[dict]:
+        require_capabilities("weather_status", self._session.capabilities)
+        return self._session.ocs(method="GET", path=f"{ENDPOINT}/forecast")
+
+    def get_favorites(self) -> list[str]:
+        require_capabilities("weather_status", self._session.capabilities)
+        return self._session.ocs(method="GET", path=f"{ENDPOINT}/favorites")
+
+    def set_favorites(self, favorites: list[str]) -> bool:
+        require_capabilities("weather_status", self._session.capabilities)
+        result = self._session.ocs(method="PUT", path=f"{ENDPOINT}/favorites", json={"favorites": favorites})
+        return result.get("success", False)
+
+    def set_mode(self, mode: WeatherLocationMode) -> bool:
+        if int(mode) == WeatherLocationMode.UNKNOWN.value:
+            raise ValueError("This mode can not be set")
+        require_capabilities("weather_status", self._session.capabilities)
+        result = self._session.ocs(method="PUT", path=f"{ENDPOINT}/mode", params={"mode": int(mode)})
+        return result.get("success", False)
diff --git a/tests/_install.py b/tests/_install.py
@@ -16,7 +16,8 @@ def enabled_handler(enabled: bool, _nc: NextcloudApp) -> str:
 def initialization():
     set_enabled_handler(APP, enabled_handler)
     set_scopes(APP, {
-        "required": [ApiScope.SYSTEM, ApiScope.DAV, ApiScope.USER_INFO, ApiScope.USER_STATUS, ApiScope.NOTIFICATIONS],
+        "required": [ApiScope.SYSTEM, ApiScope.DAV, ApiScope.USER_INFO, ApiScope.USER_STATUS,
+                     ApiScope.NOTIFICATIONS, ApiScope.WEATHER_STATUS],
         "optional": []
     })
 
diff --git a/tests/users_groups_test.py b/tests/users_groups_test.py
diff --git a/tests/users_status_test.py b/tests/users_status_test.py
@@ -7,7 +7,7 @@
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_available(nc):
-    assert nc.users_statuses.available
+    assert nc.users_status.available
 
 
 def compare_user_statuses(p1, p2):
@@ -21,9 +21,9 @@ def compare_user_statuses(p1, p2):
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 @pytest.mark.parametrize("message", ("1 2 3", None, ""))
 def test_get_status(nc, message):
-    nc.users_statuses.set(message)
-    r1 = nc.users_statuses.get_current()
-    r2 = nc.users_statuses.get(nc.user)
+    nc.users_status.set(message)
+    r1 = nc.users_status.get_current()
+    r2 = nc.users_status.get(nc.user)
     compare_user_statuses(r1, r2)
     assert r1["userId"] == "admin"
     assert r1["icon"] is None
@@ -37,12 +37,12 @@ def test_get_status(nc, message):
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_get_status_non_existent_user(nc):
-    assert nc.users_statuses.get("no such user") is None
+    assert nc.users_status.get("no such user") is None
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_get_predefined(nc):
-    r = nc.users_statuses.get_predefined()
+    r = nc.users_status.get_predefined()
     if nc.srv_version["major"] < 27:
         assert r == []
     else:
@@ -57,10 +57,10 @@ def test_get_predefined(nc):
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_get_list(nc):
-    r_all = nc.users_statuses.get_list()
+    r_all = nc.users_status.get_list()
     assert r_all
     assert isinstance(r_all, list)
-    r_current = nc.users_statuses.get_current()
+    r_current = nc.users_status.get_current()
     for i in r_all:
         if i["userId"] == nc.user:
             compare_user_statuses(i, r_current)
@@ -69,18 +69,18 @@ def test_get_list(nc):
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_set_status(nc):
     time_clear = int(time()) + 60
-    nc.users_statuses.set("cool status", time_clear)
-    r = nc.users_statuses.get_current()
+    nc.users_status.set("cool status", time_clear)
+    r = nc.users_status.get_current()
     assert r["message"] == "cool status"
     assert r["clearAt"] == time_clear
     assert r["icon"] is None
-    nc.users_statuses.set("Sick!", status_icon='🤒')
-    r = nc.users_statuses.get_current()
+    nc.users_status.set("Sick!", status_icon='🤒')
+    r = nc.users_status.get_current()
     assert r["message"] == "Sick!"
     assert r["clearAt"] is None
     assert r["icon"] == '🤒'
-    nc.users_statuses.set(None)
-    r = nc.users_statuses.get_current()
+    nc.users_status.set(None)
+    r = nc.users_status.get_current()
     assert r["message"] is None
     assert r["clearAt"] is None
     assert r["icon"] is None
@@ -89,8 +89,8 @@ def test_set_status(nc):
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 @pytest.mark.parametrize("value", ("online", "away", "dnd", "invisible", "offline"))
 def test_set_status_type(nc, value):
-    nc.users_statuses.set_status_type(value)
-    r = nc.users_statuses.get_current()
+    nc.users_status.set_status_type(value)
+    r = nc.users_status.get_current()
     assert r["status"] == value
     assert r["statusIsUserDefined"]
 
@@ -99,12 +99,12 @@ def test_set_status_type(nc, value):
 @pytest.mark.parametrize("clear_at", (None, int(time()) + 360))
 def test_set_predefined(nc, clear_at):
     if nc.srv_version["major"] < 27:
-        nc.users_statuses.set_predefined("meeting")
+        nc.users_status.set_predefined("meeting")
     else:
-        predefined_statuses = nc.users_statuses.get_predefined()
+        predefined_statuses = nc.users_status.get_predefined()
         for i in predefined_statuses:
-            nc.users_statuses.set_predefined(i["id"], clear_at)
-            r = nc.users_statuses.get_current()
+            nc.users_status.set_predefined(i["id"], clear_at)
+            r = nc.users_status.get_current()
             assert r["message"] == i["message"]
             assert r["messageId"] == i["id"]
             assert r["messageIsPredefined"]
@@ -118,18 +118,18 @@ def test_get_back_status_from_from_empty_user(nc):
     nc._session.user = ""
     try:
         with pytest.raises(ValueError):
-            nc.users_statuses.get_backup_status("")
+            nc.users_status.get_backup_status("")
     finally:
         nc._session.user = orig_user
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 @pytest.mark.skipif(NC_VERSION["major"] < 27, reason="Run only on NC27+")
 def test_get_back_status_from_from_non_exist_user(nc):
-    assert nc.users_statuses.get_backup_status("mёm_m-m.l") is None
+    assert nc.users_status.get_backup_status("mёm_m-m.l") is None
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 @pytest.mark.skipif(NC_VERSION["major"] < 27, reason="Run only on NC27+")
 def test_restore_from_non_existing_back_status(nc):
-    assert nc.users_statuses.restore_backup_status("no such backup status") is None
+    assert nc.users_status.restore_backup_status("no such backup status") is None
diff --git a/tests/weather_status_test.py b/tests/weather_status_test.py
@@ -0,0 +1,78 @@
+import pytest
+
+from nc_py_api.weather_status import WeatherLocationMode
+
+from gfixture import NC_TO_TEST
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_available(nc):
+    assert nc.weather_status.available
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_get_set_location(nc):
+    nc.weather_status.set_location(longitude=0.0, latitude=0.0)
+    loc = nc.weather_status.get_location()
+    assert loc["latitude"] == 0.0
+    assert loc["longitude"] == 0.0
+    assert isinstance(loc["address"], str)
+    assert isinstance(loc["mode"], int)
+    assert nc.weather_status.set_location(address="Paris, France")
+    loc = nc.weather_status.get_location()
+    assert loc["latitude"]
+    assert loc["longitude"]
+    assert loc["address"].find("Paris") != -1
+    assert nc.weather_status.set_location(latitude=41.896655, longitude=12.488776)
+    loc = nc.weather_status.get_location()
+    assert loc["latitude"] == 41.896655
+    assert loc["longitude"] == 12.488776
+    assert loc["address"].find("Rom") != -1
+    assert nc.weather_status.set_location(latitude=41.896655, longitude=12.488776, address="Paris, France")
+    loc = nc.weather_status.get_location()
+    assert loc["latitude"] == 41.896655
+    assert loc["longitude"] == 12.488776
+    assert loc["address"].find("Rom") != -1
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_get_set_location_no_lat_lon_address(nc):
+    with pytest.raises(ValueError):
+        nc.weather_status.set_location()
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_get_forecast(nc):
+    nc.weather_status.set_location(address="Paris, France")
+    forecast = nc.weather_status.get_forecast()
+    assert isinstance(forecast, list)
+    assert forecast
+    assert isinstance(forecast[0], dict)
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_get_set_favorites(nc):
+    nc.weather_status.set_favorites([])
+    r = nc.weather_status.get_favorites()
+    assert isinstance(r, list)
+    assert not r
+    nc.weather_status.set_favorites(["Paris, France", "Madrid, Spain"])
+    r = nc.weather_status.get_favorites()
+    assert any("Paris" in x for x in r)
+    assert any("Madrid" in x for x in r)
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_set_mode(nc):
+    nc.weather_status.set_mode(WeatherLocationMode.MODE_BROWSER_LOCATION)
+    assert nc.weather_status.get_location()["mode"] == WeatherLocationMode.MODE_BROWSER_LOCATION.value
+    nc.weather_status.set_mode(WeatherLocationMode.MODE_MANUAL_LOCATION)
+    assert nc.weather_status.get_location()["mode"] == WeatherLocationMode.MODE_MANUAL_LOCATION.value
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_set_mode_invalid(nc):
+    with pytest.raises(ValueError):
+        nc.weather_status.set_mode(WeatherLocationMode.UNKNOWN)
+    with pytest.raises(ValueError):
+        nc.weather_status.set_mode(0)
