Update notice_publisher.py

Author: CaptainOfHacks

ted_sws/notice_publisher/services/notice_publisher.py

@@ -1,80 +1,48 @@
 import base64
+import pathlib
 import tempfile
-from pathlib import Path
-from typing import Union
 
 from ted_sws import config
-from ted_sws.core.model.notice import Notice, NoticeStatus, UnsupportedStatusTransition
+from ted_sws.core.model.notice import Notice, NoticeStatus
 from ted_sws.data_manager.adapters.notice_repository import NoticeRepositoryABC
-from ted_sws.notice_packager.adapters.archiver import ARCHIVE_DEFAULT_FORMAT
-from ted_sws.notice_publisher.adapters.notice_publisher import NoticePublisherFactory
-from ted_sws.notice_publisher.adapters.notice_publisher_abc import NoticePublisherABC
-
-
-class NoticePublishBuilder:
-    def __init__(self, notice: Union[Notice, str], notice_repository: NoticeRepositoryABC,
-                 notice_publisher: NoticePublisherABC, remote_path: str = None):
-        self.notice_repository = notice_repository
-        if isinstance(notice, str):
-            notice_id = notice
-            notice: Notice = self.notice_repository.get(reference=notice_id)
-            if notice is None:
-                raise Exception(f"Notice {notice_id} could not be found.")
-
-        self.notice = notice
-        self.check_publish_eligibility()
-
-        self.notice_publisher = notice_publisher
-        self.remote_path = remote_path
-
-    def check_publish_eligibility(self):
-        if self.notice.status != NoticeStatus.ELIGIBLE_FOR_PUBLISHING:
-            raise UnsupportedStatusTransition(
-                f"Notice {self.notice.ted_id} is not Eligible for Publishing. Status: {self.notice.status}")
-
-    def package_content(self) -> bytes:
-        mets_manifestation = self.notice.mets_manifestation
-        if not mets_manifestation or not mets_manifestation.object_data:
-            raise ValueError("Notice does not have a METS manifestation to be published.")
-
-        package_content = base64.b64decode(bytes(mets_manifestation.object_data, encoding='utf-8'), validate=True)
-        return package_content
-
-    def build_remote_path(self) -> str:
-        remote_path = self.remote_path
-        if remote_path is None:
-            remote_path = f"{config.SFTP_PATH}/{self.notice.ted_id}"
-            if ARCHIVE_DEFAULT_FORMAT == "zip":
-                remote_path += '.zip'
-        return remote_path
-
-    def publish(self):
-        source_file = tempfile.NamedTemporaryFile()
-        source_file.write(self.package_content())
-
-        try:
-            if self.notice_publisher.publish(source_path=Path(source_file.name), remote_path=self.build_remote_path()):
-                self.notice.update_status_to(NoticeStatus.PUBLISHED)
-                self.notice_repository.update(self.notice)
-        except Exception as e:
-            raise Exception(f"Notice {self.notice.ted_id} could not be published: " + str(e))
-
-        return self.notice.status == NoticeStatus.PUBLISHED
-
-
-def publish_notice(notice: Union[Notice, str], notice_publisher: NoticePublisherABC,
-                   notice_repository: NoticeRepositoryABC, remote_path=None) -> bool:
-    publish_builder = NoticePublishBuilder(notice, notice_repository, notice_publisher, remote_path)
-    return publish_builder.publish()
-
-
-def publish_single_notice(notice: Union[Notice, str], notice_repository: NoticeRepositoryABC, hostname, username,
-                          password, port=None, remote_path=None) -> bool:
-    notice_publisher: NoticePublisherABC = NoticePublisherFactory.get_publisher(hostname=hostname, username=username,
-                                                                                password=password, port=port,
-                                                                                remote_path=remote_path)
-    notice_publisher.connect()
-    notice_published: bool = publish_notice(notice, notice_publisher, notice_repository, remote_path)
-    notice_publisher.disconnect()
-
-    return notice_published
+from ted_sws.notice_publisher.adapters.sftp_notice_publisher import SFTPPublisher
+from ted_sws.notice_publisher.adapters.sftp_publisher_abc import SFTPPublisherABC
+
+
+def publish_notice(notice: Notice, publisher: SFTPPublisherABC = SFTPPublisher(),
+                   remote_folder_path=config.SFTP_PATH) -> bool:
+    """
+        This function publishes the METS manifestation for a Notice in Cellar.
+    """
+
+    mets_manifestation = notice.mets_manifestation
+    if not mets_manifestation or not mets_manifestation.object_data:
+        raise ValueError("Notice does not have a METS manifestation to be published.")
+
+    package_content = base64.b64decode(bytes(mets_manifestation.object_data, encoding='utf-8'), validate=True)
+    remote_notice_path = f"{remote_folder_path}/{notice.ted_id}.zip"
+    source_file = tempfile.NamedTemporaryFile()
+    source_file.write(package_content)
+
+    try:
+        publisher.connect()
+        if publisher.publish(source_path=pathlib.Path(source_file.name),
+                             remote_path=remote_notice_path):
+            notice.update_status_to(NoticeStatus.PUBLISHED)
+        publisher.disconnect()
+    except Exception as e:
+        raise Exception(f"Notice {notice.ted_id} could not be published: " + str(e))
+
+    return notice.status == NoticeStatus.PUBLISHED
+
+
+def publish_notice_by_id(notice_id: str, notice_repository: NoticeRepositoryABC,
+                         publisher: SFTPPublisherABC, remote_folder_path=None) -> bool:
+    """
+        This function publishes the METS manifestation of a Notice, based on notice_id, in Cellar.
+    """
+    notice = notice_repository.get(reference=notice_id)
+    result = publish_notice(notice=notice, publisher=publisher, remote_folder_path=remote_folder_path)
+    if result:
+        notice_repository.update(notice=notice)
+    return result