Merge pull request #44 from bugout-dev/public-journal-endpoints

Public journal endpoints

Author: zomglings

bugout/__init__.py

@@ -7,7 +7,7 @@
 
 __email__ = "engineering@bugout.dev"
 __license__ = "MIT"
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 __all__ = (
     "__author__",

bugout/app.py

@@ -841,14 +841,114 @@ def search(
             **kwargs,
         )
 
-    # Public
+    # Public journals
     def check_journal_public(
         self,
         journal_id: Union[str, uuid.UUID],
         timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
     ) -> bool:
         self.journal.timeout = timeout
-        return self.journal.check_journal_public(journal_id=journal_id)
+        return self.journal.check_journal_public(journal_id=journal_id, **kwargs)
+
+    def list_public_journals(
+        self,
+        user_id: Union[str, uuid.UUID],
+        timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
+    ) -> data.BugoutJournals:
+        self.journal.timeout = timeout
+        return self.journal.list_public_journals(user_id=user_id, **kwargs)
+
+    def get_public_journal(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
+    ) -> data.BugoutJournal:
+        self.journal.timeout = timeout
+        return self.journal.get_public_journal(journal_id=journal_id, **kwargs)
+
+    def get_public_journal_entries(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
+    ) -> data.BugoutJournalEntries:
+        self.journal.timeout = timeout
+        return self.journal.get_public_journal_entries(journal_id=journal_id, **kwargs)
+
+    def create_public_journal_entry(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        title: str,
+        content: str,
+        tags: List[str] = [],
+        context_url: Optional[str] = None,
+        context_id: Optional[str] = None,
+        context_type: Optional[str] = None,
+        timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
+    ) -> data.BugoutJournalEntry:
+        self.journal.timeout = timeout
+        return self.journal.create_public_journal_entry(
+            journal_id=journal_id,
+            title=title,
+            content=content,
+            tags=tags,
+            context_url=context_url,
+            context_id=context_id,
+            context_type=context_type,
+            **kwargs,
+        )
+
+    def touch_public_journal_entry(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        entry_id: Union[str, uuid.UUID],
+        timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
+    ) -> List[str]:
+        self.journal.timeout = timeout
+        return self.journal.touch_public_journal_entry(
+            journal_id=journal_id, entry_id=entry_id, **kwargs
+        )
+
+    def get_public_journal_entry(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        entry_id: Union[str, uuid.UUID],
+        timeout: float = REQUESTS_TIMEOUT,
+        **kwargs: Dict[str, Any],
+    ) -> data.BugoutJournalEntry:
+        self.journal.timeout = timeout
+        return self.journal.get_public_journal_entry(
+            journal_id=journal_id, entry_id=entry_id, **kwargs
+        )
+
+    def public_search(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        query: str,
+        filters: Optional[List[str]] = None,
+        limit: int = 10,
+        offset: int = 0,
+        content: bool = True,
+        timeout: float = REQUESTS_TIMEOUT,
+        order: SearchOrder = SearchOrder.DESCENDING,
+        **kwargs: Dict[str, Any],
+    ) -> data.BugoutSearchResults:
+        self.journal.timeout = timeout
+        return self.journal.public_search(
+            journal_id,
+            query,
+            filters,
+            limit,
+            offset,
+            content,
+            order=order,
+            **kwargs,
+        )
 
     # Humbug
     def get_humbug_integrations(

bugout/journal.py

@@ -556,9 +556,155 @@ def search(
         )
         return BugoutSearchResults(**result)
 
-    # Public module
-    def check_journal_public(self, journal_id: Union[str, uuid.UUID]) -> bool:
-        journal_path = "public/check"
-        query_params = {"journal_id": journal_id}
-        result = self._call(method=Method.get, path=journal_path, params=query_params)
+    # Public journals module
+    def check_journal_public(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        **kwargs: Dict[str, Any],
+    ) -> bool:
+        check_path = f"public/{journal_id}/check"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        result = self._call(method=Method.get, path=check_path, headers=headers)
+        return result
+
+    def list_public_journals(
+        self,
+        user_id: Union[str, uuid.UUID],
+        **kwargs: Dict[str, Any],
+    ) -> BugoutJournals:
+        public_journals_path = "public"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        query_params = {"user_id": user_id}
+        result = self._call(
+            method=Method.get,
+            path=public_journals_path,
+            params=query_params,
+            headers=headers,
+        )
+        return BugoutJournals(**result)
+
+    def get_public_journal(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        **kwargs: Dict[str, Any],
+    ) -> BugoutJournal:
+        public_journal_path = f"public/{journal_id}"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        result = self._call(
+            method=Method.get,
+            path=public_journal_path,
+            headers=headers,
+        )
+        return BugoutJournal(**result)
+
+    def get_public_journal_entries(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        **kwargs: Dict[str, Any],
+    ) -> BugoutJournalEntries:
+        public_journal_path = f"public/{journal_id}/entries"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        result = self._call(
+            method=Method.get,
+            path=public_journal_path,
+            headers=headers,
+        )
+        return BugoutJournalEntries(**result)
+
+    def create_public_journal_entry(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        title: str,
+        content: str,
+        tags: List[str] = [],
+        context_url: Optional[str] = None,
+        context_id: Optional[str] = None,
+        context_type: Optional[str] = None,
+        **kwargs: Dict[str, Any],
+    ) -> BugoutJournalEntry:
+        entry_path = f"public/{journal_id}/entries"
+        json = {
+            "title": title,
+            "content": content,
+            "tags": tags,
+            "context_url": context_url,
+            "context_id": context_id,
+            "context_type": context_type,
+        }
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        result = self._call(
+            method=Method.post, path=entry_path, headers=headers, json=json
+        )
+        return BugoutJournalEntry(**result)
+
+    def touch_public_journal_entry(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        entry_id: Union[str, uuid.UUID],
+        **kwargs: Dict[str, Any],
+    ) -> List[str]:
+        public_journal_path = f"public/{journal_id}/entries/{entry_id}"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        result = self._call(
+            method=Method.put,
+            path=public_journal_path,
+            headers=headers,
+        )
         return result
+
+    def get_public_journal_entry(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        entry_id: Union[str, uuid.UUID],
+        **kwargs: Dict[str, Any],
+    ) -> BugoutJournalEntry:
+        public_journal_path = f"public/{journal_id}/entries/{entry_id}"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        result = self._call(
+            method=Method.get,
+            path=public_journal_path,
+            headers=headers,
+        )
+        return BugoutJournalEntry(**result)
+
+    def public_search(
+        self,
+        journal_id: Union[str, uuid.UUID],
+        query: str,
+        filters: Optional[List[str]] = None,
+        limit: int = 10,
+        offset: int = 0,
+        content: bool = True,
+        order: SearchOrder = SearchOrder.DESCENDING,
+        **kwargs: Dict[str, Any],
+    ) -> BugoutSearchResults:
+        search_path = f"public/{journal_id}/search"
+        headers = {}
+        if "headers" in kwargs.keys():
+            headers.update(kwargs["headers"])
+        query_params = {
+            "q": query,
+            "filters": filters if filters is not None else [],
+            "limit": limit,
+            "offset": offset,
+            "content": content,
+            "order": order.value,
+        }
+        result = self._call(
+            method=Method.get, path=search_path, params=query_params, headers=headers
+        )
+        return BugoutSearchResults(**result)