peeringdb-peeringdb/peeringdb_server/deskpro.py

"""
DeskPro API Client
"""

import re
import requests

from django.template import loader
from django.conf import settings

from peeringdb_server.models import DeskProTicket
from peeringdb_server.inet import RdapNotFoundError


def ticket_queue(subject, body, user):
    """ queue a deskpro ticket for creation """

    ticket = DeskProTicket.objects.create(
        subject=u"{}{}".format(settings.EMAIL_SUBJECT_PREFIX, subject),
        body=body,
        user=user,
    )


class APIError(IOError):
    def __init__(self, msg, data):
        super(APIError, self).__init__(msg)
        self.data = data


def ticket_queue_asnauto_skipvq(user, org, net, rir_data):
    """
    queue deskro ticket creation for asn automation action: skip vq
    """

    if isinstance(net, dict):
        net_name = net.get("name")
    else:
        net_name = net.name

    if isinstance(org, dict):
        org_name = org.get("name")
    else:
        org_name = org.name

    ticket_queue(
        "[ASNAUTO] Network '%s' approved for existing Org '%s'" % (net_name, org_name),
        loader.get_template("email/notify-pdb-admin-asnauto-skipvq.txt").render(
            {"user": user, "org": org, "net": net, "rir_data": rir_data}
        ),
        user,
    )


def ticket_queue_asnauto_affil(user, org, net, rir_data):
    """
    queue deskro ticket creation for asn automation action: affil
    """

    ticket_queue(
        "[ASNAUTO] Ownership claim granted to Org '%s' for user '%s'"
        % (org.name, user.username),
        loader.get_template("email/notify-pdb-admin-asnauto-affil.txt").render(
            {"user": user, "org": org, "net": net, "rir_data": rir_data}
        ),
        user,
    )


def ticket_queue_asnauto_create(
    user, org, net, rir_data, asn, org_created=False, net_created=False
):
    """
    queue deskro ticket creation for asn automation action: create
    """

    subject = []

    if org_created:
        subject.append("Organization '%s'" % org.name)
    if net_created:
        subject.append("Network '%s'" % net.name)

    if not subject:
        return
    subject = ", ".join(subject)

    ticket_queue(
        "[ASNAUTO] %s created" % subject,
        loader.get_template(
            "email/notify-pdb-admin-asnauto-entity-creation.txt"
        ).render(
            {
                "user": user,
                "org": org,
                "net": net,
                "asn": asn,
                "org_created": org_created,
                "net_created": net_created,
                "rir_data": rir_data,
            }
        ),
        user,
    )


def ticket_queue_rdap_error(user, asn, error):
    if isinstance(error, RdapNotFoundError):
        return
    error_message = "{}".format(error)

    if re.match("(.+) returned 400", error_message):
        return

    subject = "[RDAP_ERR] {} - AS{}".format(user.username, asn)
    ticket_queue(
        subject,
        loader.get_template("email/notify-pdb-admin-rdap-error.txt").render(
            {"user": user, "asn": asn, "error_details": error_message}
        ),
        user,
    )


class APIClient(object):
    def __init__(self, url, key):
        self.key = key
        self.url = url

    @property
    def auth_headers(self):
        return {"Authorization": "key {}".format(self.key)}

    def parse_response(self, response, many=False):
        r_json = response.json()
        if "status" in r_json:
            if r_json["status"] >= 400:
                raise APIError(r_json["message"], r_json)
        else:
            response.raise_for_status()
        data = r_json["data"]
        if isinstance(data, list):
            if many:
                return r_json["data"]
            elif data:
                return data[0]
        else:
            return data

    def get(self, endpoint, param):
        response = requests.get(
            "{}/{}".format(self.url, endpoint), params=param, headers=self.auth_headers
        )
        return self.parse_response(response)

    def create(self, endpoint, param):
        response = requests.post(
            "{}/{}".format(self.url, endpoint), json=param, headers=self.auth_headers
        )
        return self.parse_response(response)

    def require_person(self, user):
        person = self.get("people", {"primary_email": user.email})
        if not person:
            person = self.create(
                "people",
                {
                    "primary_email": user.email,
                    "first_name": user.first_name,
                    "last_name": user.last_name,
                    "name": user.full_name,
                },
            )

        return person

    def create_ticket(self, ticket):
        person = self.require_person(ticket.user)
        ticket_response = self.create(
            "tickets",
            {
                "subject": ticket.subject,
                "person": {"id": person["id"]},
                "status": "awaiting_agent",
            },
        )

        self.create(
            "tickets/{}/messages".format(ticket_response["id"]),
            {
                "message": ticket.body.replace("\n", "<br />\n"),
                "person": person["id"],
                "format": "html",
            },
        )