senaite.core.content.clientcontact

Complexity

Total Complexity

54

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	ClientContact.getLastname()	0	3	1
A	ClientContact.getCCContacts()	0	5	2
A	ClientContact.mutator()	0	8	2
A	ClientContact.setMobilePhone()	0	7	3
A	ClientContact.getEmail()	0	3	1
A	ClientContact.set_string_value()	0	11	3
A	ClientContact.Title()	0	3	1
A	ClientContact.setCCContacts()	0	4	1
A	ClientContact.getBusinessPhone()	0	3	1
A	ClientContact.getJobTitle()	0	3	1
A	ClientContact.setHomePhone()	0	7	3
A	ClientContact.get_cc_contacts_query()	0	21	2
A	IClientContactSchema.validate_email()	0	11	3
A	ClientContact.getFirstname()	0	3	1
A	ClientContact.setBusinessPhone()	0	7	3
A	ClientContact.getMobilePhone()	0	3	1
A	ClientContact.setSalutation()	0	3	1
A	IClientContactSchema.validate_business_phone()	0	5	1
A	ClientContact.accessor()	0	8	2
A	ClientContact.getSalutation()	0	3	1
A	IClientContactSchema.validate_phone()	0	7	3
A	ClientContact.setEmail()	0	7	3
A	ClientContact.get_string_value()	0	5	1
A	ClientContact.setDepartment()	0	3	1
A	ClientContact.getClient()	0	8	2
A	ClientContact.setFirstname()	0	3	1
A	ClientContact.getHomePhone()	0	3	1
A	IClientContactSchema.validate_home_phone()	0	5	1
A	IClientContactSchema.validate_mobile_phone()	0	5	1
A	ClientContact.setLastname()	0	3	1
A	ClientContact.setJobTitle()	0	3	1
A	ClientContact.getFullname()	0	6	1
A	ClientContact.getDepartment()	0	3	1

# -*- coding: utf-8 -*-

import re

from AccessControl import ClassSecurityInfo
from bika.lims import api
from bika.lims import senaiteMessageFactory as _
from bika.lims.api.mail import is_valid_email_address
from bika.lims.interfaces import IClient
from bika.lims.interfaces import IDeactivable
from plone.autoform import directives
from plone.dexterity.content import Container
from plone.supermodel import model
from Products.CMFCore import permissions
from senaite.core.interfaces import IClientContact
from senaite.core.schema import UIDReferenceField
from senaite.core.z3cform.widgets.uidreference import UIDReferenceWidgetFactory
from six import string_types
from zope import schema
from zope.interface import implementer
from zope.interface import Invalid
from zope.interface import invariant


def is_valid_phone(phone):
    """Returns whether the given phone is valid or not
    """
    # XXX Better validate with phonenumbers library here?
    # https://pypi.org/project/phonenumbers/
    phone = phone.strip()
    match = re.match(r"^[+(]?\d+(?:[- )(]+\d+)+$", phone)
    if not match:
        return False
    return True


class IClientContactSchema(model.Schema):
    """Client's Contact Schema interface
    """

    salutation = schema.TextLine(
        title=_(u"Salutation"),
        description=_(
            u"Greeting title eg. Mr, Mrs, Dr"
        ),
        required=False,
    )

    firstname = schema.TextLine(
        title=_(u"Firstname"),
        required=True,
    )

    lastname = schema.TextLine(
        title=_(u"Lastname"),
        required=True,
    )

    email = schema.TextLine(
        title=_(u"Email"),
        required=False,
    )

    business_phone = schema.TextLine(
        title=_(u"Phone (business)"),
        required=False,
    )

    mobile_phone = schema.TextLine(
        title=_(u"Phone (mobile)"),
        required=False,
    )

    home_phone = schema.TextLine(
        title=_(u"Phone (home)"),
        required=False,
    )

    job_title = schema.TextLine(
        title=_(u"Job title"),
        required=False,
    )

    department = schema.TextLine(
        title=_(u"Department"),
        required=False,
    )

    cc_contacts = UIDReferenceField(
        title=_(u"Contacts to CC"),
        description=_(
            u"Contacts that will receive a copy of the notification emails "
            u"sent to this contact. Only contacts from same client are allowed"
        ),
        allowed_types=("ClientContact", ),
        multi_valued=True,
        required=False,
    )

    directives.widget(
        "cc_contacts",
        UIDReferenceWidgetFactory,
        catalog="portal_catalog",
        query="get_cc_contacts_query",
        display_template="<a href='${url}'>${title}</a>",
        columns=[
            {
                "name": "title",
                "width": "30",
                "align": "left",
                "label": _(u"Title"),
            }, {
                "name": "description",
                "width": "70",
                "align": "left",
                "label": _(u"Description"),
            },
        ],
        limit=15,

    )

    # Notification preferences fieldset
    model.fieldset(
        "notification_preferences",
        label=_(u"Notification preferences"),
        fields=["cc_contacts",]
    )

    @invariant
    def validate_email(self):
        """Checks if the email is correct
        """
        email = self.email
        if not email:
            return

        email = email.strip()
        if not is_valid_email_address(email):
            raise Invalid(_("Email is not valid"))

    def validate_phone(self, field_name):
        phone = getattr(self, field_name)
        if not phone:
            return

        if not is_valid_phone(phone):
            raise Invalid(_("Phone is not valid"))

    @invariant
    def validate_business_phone(self):
        """Checks if the business phone is correct
        """
        self.validate_phone("business_phone")

    @invariant
    def validate_home_phone(self):
        """Checks if the home phone is correct
        """
        self.validate_phone("home_phone")

    @invariant
    def validate_mobile_phone(self):
        """Checks if the mobile phone is correct
        """
        self.validate_phone("mobile_phone")


@implementer(IClientContact, IClientContactSchema, IDeactivable)
class ClientContact(Container):
    """Client Contact type
    """
    # Catalogs where this type will be catalogued
    _catalogs = ["portal_catalog"]

    security = ClassSecurityInfo()

    @security.private
    def accessor(self, fieldname):
        """Return the field accessor for the fieldname
        """
        schema = api.get_schema(self)
        if fieldname not in schema:
            return None
        return schema[fieldname].get

    @security.private
    def mutator(self, fieldname):
        """Return the field mutator for the fieldname
        """
        schema = api.get_schema(self)
        if fieldname not in schema:
            return None
        return schema[fieldname].set

    @security.protected(permissions.View)
    def Title(self):
        return self.getFullname()

    @security.private
    def set_string_value(self, field_name, value, validator=None):
        if not isinstance(value, string_types):
            value = u""

        value = value.strip()
        if validator:
            validator(value)

        mutator = self.mutator(field_name)
        mutator(self, api.safe_unicode(value))

    @security.private
    def get_string_value(self, field_name, default=""):
        accessor = self.accessor(field_name)
        value = accessor(self) or default
        return value.encode("utf-8")

    @security.protected(permissions.ModifyPortalContent)
    def setSalutation(self, value):
        self.set_string_value("salutation", value)

    @security.protected(permissions.View)
    def getSalutation(self):
        return self.get_string_value("salutation")

    @security.protected(permissions.ModifyPortalContent)
    def setFirstname(self, value):
        self.set_string_value("firstname", value)

    @security.protected(permissions.View)
    def getFirstname(self):
        return self.get_string_value("firstname")

    @security.protected(permissions.ModifyPortalContent)
    def setLastname(self, value):
        self.set_string_value("lastname", value)

    @security.protected(permissions.View)
    def getLastname(self):
        return self.get_string_value("lastname")

    @security.protected(permissions.ModifyPortalContent)
    def setEmail(self, value):
        def validate_email(email):
            if email and not is_valid_email_address(email):
                raise ValueError("Email is not valid")

        self.set_string_value("email", value, validator=validate_email)

    @security.protected(permissions.View)
    def getEmail(self):
        return self.get_string_value("email")

    @security.protected(permissions.ModifyPortalContent)
    def setBusinessPhone(self, value):
        def validate_phone(phone):
            if phone and not is_valid_phone(phone):
                raise ValueError("Phone is not valid")

        self.set_string_value("business_phone", value, validator=validate_phone)

    @security.protected(permissions.View)
    def getBusinessPhone(self):
        return self.get_string_value("business_phone")

    @security.protected(permissions.ModifyPortalContent)
    def setMobilePhone(self, value):
        def validate_phone(phone):
            if phone and not is_valid_phone(phone):
                raise ValueError("Phone is not valid")

        self.set_string_value("mobile_phone", value, validator=validate_phone)

    @security.protected(permissions.View)
    def getMobilePhone(self):
        return self.get_string_value("mobile_phone")

    @security.protected(permissions.ModifyPortalContent)
    def setHomePhone(self, value):
        def validate_phone(phone):
            if phone and not is_valid_phone(phone):
                raise ValueError("Phone is not valid")

        self.set_string_value("home_phone", value, validator=validate_phone)

    @security.protected(permissions.View)
    def getHomePhone(self):
        return self.get_string_value("home_phone")

    @security.protected(permissions.ModifyPortalContent)
    def setJobTitle(self, value):
        self.set_string_value("job_title", value)

    @security.protected(permissions.View)
    def getJobTitle(self):
        return self.get_string_value("job_title")

    @security.protected(permissions.ModifyPortalContent)
    def setDepartment(self, value):
        self.set_string_value("department", value)

    @security.protected(permissions.View)
    def getDepartment(self):
        return self.get_string_value("department")

    @security.protected(permissions.ModifyPortalContent)
    def setCCContacts(self, value):
        mutator = self.mutator("cc_contacts")
        mutator(self, value)

    @security.protected(permissions.View)
    def getCCContacts(self, as_objects=False):
        accessor = self.accessor("cc_contacts")
        uids = accessor(self, as_objects=as_objects) or []
        return map(lambda uid: uid.encode("utf-8"), uids)

    @security.protected(permissions.View)
    def getFullname(self):
        """Returns the fullname of this Client Contact
        """
        full = filter(None, [self.getFirstname(), self.getLastname()])
        return " ".join(full)

    @security.protected(permissions.View)
    def getClient(self):
        """Returns the client this Client Contact belongs to
        """
        obj = api.get_parent(self)
        if IClient.providedBy(obj):
            return obj
        return None

    @security.private
    def get_cc_contacts_query(self):
        """Returns the default query for the cc_contacts field. Only contacts
        from same client as the current one are displayed, if client set
        """
        query = {
            "portal_type": "ClientContact",
            "is_active": True,
            "sort_on": "title",
            "sort_order": "ascending",
        }
        client = self.getClient()
        if client:
            query.update({
                "path": {
                    "query": api.get_path(client),
                    "level": 0
                }
            })

        return query