Chris Coutinho
155 lines
4.8 KiB
Python
155 lines
4.8 KiB
Python
import os
|
|
from httpx import (
|
|
AsyncClient,
|
|
Auth,
|
|
BasicAuth,
|
|
Request,
|
|
Response,
|
|
)
|
|
import logging
|
|
|
|
from .notes_client import NotesClient
|
|
from .webdav_client import WebDAVClient
|
|
from .controllers.notes_search import NotesSearchController
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def log_request(request: Request):
|
|
logger.info(
|
|
"Request event hook: %s %s - Waiting for content",
|
|
request.method,
|
|
request.url,
|
|
)
|
|
logger.info("Request body: %s", request.content)
|
|
logger.info("Headers: %s", request.headers)
|
|
|
|
|
|
def log_response(response: Response):
|
|
response.read() # Explicitly read the stream before accessing .text
|
|
logger.info("Response [%s] %s", response.status_code, response.text)
|
|
|
|
|
|
class NextcloudClient:
|
|
"""Main Nextcloud client that orchestrates all app clients."""
|
|
|
|
def __init__(self, base_url: str, username: str, auth: Auth | None = None):
|
|
self.username = username
|
|
self._client = AsyncClient(
|
|
base_url=base_url,
|
|
auth=auth,
|
|
# event_hooks={"request": [log_request], "response": [log_response]},
|
|
)
|
|
|
|
# Initialize app clients
|
|
self.notes = NotesClient(self._client, username)
|
|
self.webdav = WebDAVClient(self._client, username)
|
|
|
|
# Initialize controllers
|
|
self._notes_search = NotesSearchController()
|
|
|
|
@classmethod
|
|
def from_env(cls):
|
|
logger.info("Creating NC Client using env vars")
|
|
|
|
host = os.environ["NEXTCLOUD_HOST"]
|
|
username = os.environ["NEXTCLOUD_USERNAME"]
|
|
password = os.environ["NEXTCLOUD_PASSWORD"]
|
|
# Pass username to constructor
|
|
return cls(base_url=host, username=username, auth=BasicAuth(username, password))
|
|
|
|
async def capabilities(self):
|
|
response = await self._client.get(
|
|
"/ocs/v2.php/cloud/capabilities",
|
|
headers={"OCS-APIRequest": "true", "Accept": "application/json"},
|
|
)
|
|
response.raise_for_status()
|
|
|
|
return response.json()
|
|
|
|
# Convenience methods that delegate to subclients
|
|
async def notes_get_settings(self):
|
|
"""Get Notes app settings."""
|
|
return await self.notes.get_settings()
|
|
|
|
async def notes_get_all(self):
|
|
"""Get all notes."""
|
|
return await self.notes.get_all_notes()
|
|
|
|
async def notes_get_note(self, *, note_id: int):
|
|
"""Get a specific note."""
|
|
return await self.notes.get_note(note_id)
|
|
|
|
async def notes_create_note(
|
|
self,
|
|
*,
|
|
title: str | None = None,
|
|
content: str | None = None,
|
|
category: str | None = None,
|
|
):
|
|
"""Create a new note."""
|
|
return await self.notes.create_note(
|
|
title=title, content=content, category=category
|
|
)
|
|
|
|
async def notes_update_note(
|
|
self,
|
|
*,
|
|
note_id: int,
|
|
etag: str,
|
|
title: str | None = None,
|
|
content: str | None = None,
|
|
category: str | None = None,
|
|
):
|
|
"""Update a note."""
|
|
return await self.notes.update(
|
|
note_id=note_id, etag=etag, title=title, content=content, category=category
|
|
)
|
|
|
|
async def notes_append_content(self, *, note_id: int, content: str):
|
|
"""Append content to an existing note with a separator."""
|
|
return await self.notes.append_content(note_id=note_id, content=content)
|
|
|
|
async def notes_search_notes(self, *, query: str):
|
|
"""Search notes using token-based matching with relevance ranking."""
|
|
all_notes = await self.notes.get_all_notes()
|
|
return self._notes_search.search_notes(all_notes, query)
|
|
|
|
async def notes_delete_note(self, *, note_id: int):
|
|
"""Delete a note and its attachments."""
|
|
return await self.notes.delete_note(note_id)
|
|
|
|
async def add_note_attachment(
|
|
self,
|
|
*,
|
|
note_id: int,
|
|
filename: str,
|
|
content: bytes,
|
|
category: str | None = None,
|
|
mime_type: str | None = None,
|
|
):
|
|
"""Add/Update an attachment to a note via WebDAV PUT."""
|
|
return await self.webdav.add_note_attachment(
|
|
note_id=note_id,
|
|
filename=filename,
|
|
content=content,
|
|
category=category,
|
|
mime_type=mime_type,
|
|
)
|
|
|
|
async def get_note_attachment(
|
|
self, *, note_id: int, filename: str, category: str | None = None
|
|
):
|
|
"""Fetch a specific attachment from a note via WebDAV GET."""
|
|
return await self.webdav.get_note_attachment(
|
|
note_id=note_id, filename=filename, category=category
|
|
)
|
|
|
|
def _get_webdav_base_path(self) -> str:
|
|
"""Helper to get the base WebDAV path for the authenticated user."""
|
|
return f"/remote.php/dav/files/{self.username}"
|
|
|
|
async def close(self):
|
|
"""Close the HTTP client."""
|
|
await self._client.aclose()
|