Improved Email Publication

CHANGES.rst

@@ -11,6 +11,8 @@ Changelog
 
 **Changed**
 
+- #1413 Improved Email Publication
+
 
 **Removed**
 

bika/lims/api/mail.py

@@ -11,6 +11,7 @@
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from email.Utils import formataddr
+from email.Utils import parseaddr
 from smtplib import SMTPException
 from string import Template
 from StringIO import StringIO
@@ -47,6 +48,18 @@ def to_email_address(address, name=""):
     return formataddr(pair)
 
 
+def parse_email_address(address):
+    """Parse a given name/email pair
+
+    :param address: The name/email string to parse
+    :type address: basestring
+    :returns: Tuple of (name, email)
+    """
+    if not isinstance(address, basestring):
+        raise ValueError("Expected a string, got {}".format(type(address)))
+    return parseaddr(address)
+
+
 def to_email_subject(subject):
     """Convert the given subject to an email subject
 
@@ -70,44 +83,53 @@ def to_email_body_text(body, **kw):
     return MIMEText(body_template, _subtype="plain", _charset="utf8")
 
 
-def to_email_attachment(file_or_path, filename="", **kw):
+def to_email_attachment(filedata, filename="", **kw):
     """Create a new MIME Attachment
 
     The Content-Type: header is build from the maintype and subtype of the
     guessed filename mimetype. Additional parameters for this header are
     taken from the keyword arguments.
 
-    :param file_or_path: OS-level file or absolute path
-    :type file_or_path: str, FileIO, MIMEBase
+    :param filedata: File, file path, filedata
+    :type filedata: FileIO, MIMEBase, basestring
     :param filename: Filename to use
-    :type filedata: str
+    :type filename: str
     :returns: MIME Attachment
     """
-    filedata = ""
+    data = ""
     maintype = "application"
     subtype = "octet-stream"
 
+    def is_file(s):
+        try:
+            return os.path.exists(s)
+        except TypeError:
+            return False
+
     # Handle attachment
-    if isinstance(file_or_path, MIMEBase):
+    if isinstance(filedata, MIMEBase):
         # return immediately
-        return file_or_path
+        return filedata
     # Handle file/StringIO
-    elif isinstance(file_or_path, (file, StringIO)):
-        filedata = file_or_path.read()
-    # Handle file path
-    elif os.path.isfile(file_or_path):
-        filename = filename or os.path.basename(file_or_path)
-        with open(file_or_path, "r") as f:
+    elif isinstance(filedata, (file, StringIO)):
+        data = filedata.read()
+    # Handle file paths
+    if is_file(filedata):
+        filename = filename or os.path.basename(filedata)
+        with open(filedata, "r") as f:
             # read the filedata from the filepath
-            filedata = f.read()
+            data = f.read()
+    # Handle raw filedata
+    elif isinstance(filedata, basestring):
+        data = filedata
 
     # Set MIME type from keyword arguments or guess it from the filename
     mime_type = kw.pop("mime_type", None) or mimetypes.guess_type(filename)[0]
     if mime_type is not None:
         maintype, subtype = mime_type.split("/")
 
     attachment = MIMEBase(maintype, subtype, **kw)
-    attachment.set_payload(filedata)
+    attachment.set_payload(data)
     encoders.encode_base64(attachment)
     attachment.add_header("Content-Disposition",
                           "attachment; filename=%s" % filename)
@@ -132,30 +154,6 @@ def is_valid_email_address(address):
     return True
 
 
-def parse_email_address(address):
-    """Parse a given name/email pair
-
-    :param address: The name/email string to parse
-    :type address: basestring
-    :returns: RFC 2822 email address
-    """
-    if not isinstance(address, basestring):
-        raise ValueError("Expected a string, got {}".format(type(address)))
-
-    # parse <name>, <email> recipient
-    splitted = map(lambda s: s.strip(),
-                   safe_unicode(address).rsplit(",", 1))
-
-    pair = []
-    for s in splitted:
-        if is_valid_email_address(s):
-            pair.insert(0, s)
-        else:
-            pair.append(s)
-
-    return to_email_address(*pair)
-
-
 def compose_email(from_addr, to_addr, subj, body, attachments=[], **kw):
     """Compose a RFC 2822 MIME message
 

bika/lims/browser/analysisreport.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of SENAITE.CORE.
+#
+# SENAITE.CORE is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, version 2.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Copyright 2018-2019 by it's authors.
+# Some rights reserved, see README and LICENSE.
+
+from bika.lims import api
+from bika.lims.browser import BrowserView
+from bika.lims.utils import get_image
+from plone.memoize import view
+from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
+from ZODB.POSException import POSKeyError
+
+
+class AnalysisReportInfoView(BrowserView):
+    """Show details of the Analysis Report
+    """
+    template = ViewPageTemplateFile("templates/analysisreport_info.pt")
+
+    def __init__(self, context, request):
+        super(AnalysisReportInfoView, self).__init__(context, request)
+
+    def __call__(self):
+        # disable the editable border
+        self.request.set("disable_border", 1)
+        return self.template()
+
+    @view.memoize
+    def get_report(self):
+        report_uid = self.request.form.get("report_uid")
+        return api.get_object_by_uid(report_uid, None)
+
+    @view.memoize
+    def get_primary_sample(self):
+        report = self.get_report()
+        return report.getAnalysisRequest()
+
+    @view.memoize
+    def get_metadata(self):
+        report = self.get_report()
+        return report.getMetadata()
+
+    @view.memoize
+    def get_sendlog(self):
+        report = self.get_report()
+        records = report.getSendLog()
+        return list(reversed(records))
+
+    @view.memoize
+    def get_contained_samples(self):
+        metadata = self.get_metadata()
+        samples = metadata.get("contained_requests", [])
+        sample_uids = filter(api.is_uid, samples)
+        return map(api.get_object_by_uid, sample_uids)
+
+    def get_icon_for(self, typename):
+        """Returns the big image icon by its (type-)name
+        """
+        image = "{}_big.png".format(typename)
+        return get_image(
+            image, width="20px", style="vertical-align: baseline;")
+
+    def get_filesize(self, f):
+        """Return the filesize of the PDF as a float
+        """
+        try:
+            filesize = float(f.get_size())
+            return float("%.2f" % (filesize / 1024))
+        except (POSKeyError, TypeError, AttributeError):
+            return 0.0
+
+    @view.memoize
+    def get_attachment_data_by_uid(self, uid):
+        """Retrieve attachment data by UID
+        """
+        attachment = api.get_object_by_uid(uid, default=None)
+        # Attachment file not found/deleted
+        if attachment is None:
+            return {}
+        f = attachment.getAttachmentFile()
+        attachment_type = attachment.getAttachmentType()
+        attachment_keys = attachment.getAttachmentKeys()
+        filename = f.filename
+        filesize = self.get_filesize(f)
+        mimetype = f.getContentType()
+        report_option = attachment.getReportOption()
+
+        return {
+            "obj": attachment,
+            "attachment_type": attachment_type,
+            "attachment_keys": attachment_keys,
+            "file": f,
+            "uid": uid,
+            "filesize": filesize,
+            "filename": filename,
+            "mimetype": mimetype,
+            "report_option": report_option,
+        }

bika/lims/browser/analysisreport.zcml

@@ -0,0 +1,17 @@
+<configure
+    xmlns="http://namespaces.zope.org/zope"
+    xmlns:browser="http://namespaces.zope.org/browser"
+    xmlns:i18n="http://namespaces.zope.org/i18n"
+    i18n_domain="senaite.core">
+
+  <!-- Analysis Report Info View
+       (used in report listings for Popup Overlays) -->
+  <browser:page
+      for="*"
+      name="analysisreport_info"
+      class="bika.lims.browser.analysisreport.AnalysisReportInfoView"
+      permission="zope.Public"
+      layer="bika.lims.interfaces.IBikaLIMS"
+      />
+
+</configure>

bika/lims/browser/configure.zcml

@@ -9,6 +9,7 @@
 
   <include file="analysis.zcml"/>
   <include file="analysisprofile.zcml"/>
+  <include file="analysisreport.zcml"/>
   <include file="analysisservice.zcml"/>
   <include file="analysisspec.zcml"/>
   <include file="arimports.zcml"/>