Add blocked page

[ipfire.org.git] / src / backend / talk.py

#!/usr/bin/python

import ipaddress
import logging
import re
import time

from . import database

from .misc import Object
from .decorators import *

class Freeswitch(Object):
	@lazy_property
	def db(self):
		credentials = {
			"host"     : self.settings.get("freeswitch_database_host"),
			"database" : self.settings.get("freeswitch_database_name", "freeswitch"),
			"user"     : self.settings.get("freeswitch_database_user"),
			"password" : self.settings.get("freeswitch_database_password"),
		}

		return database.Connection(**credentials)

	def get_sip_registrations(self, sip_uri):
		logging.debug("Fetching SIP registrations for %s" % sip_uri)

		user, delim, domain = sip_uri.partition("@")

		res = self.db.query("SELECT * FROM sip_registrations \
			WHERE sip_user = %s AND sip_host = %s AND expires >= EXTRACT(epoch FROM CURRENT_TIMESTAMP) \
			ORDER BY contact", user, domain)

		for row in res:
			yield SIPRegistration(self, data=row)

	def get_sip_channels(self, account):
		res = self.db.query("SELECT * FROM channels \
			WHERE (direction = %s AND cid_num = %s) OR \
				(direction = %s AND (callee_num = %s OR callee_num = ANY(%s))) \
				ORDER BY created_epoch",
			"inbound", account.sip_id, "outbound", account.sip_id,
			account._all_telephone_numbers)

		channels = []

		for row in res:
			c = Channel(self, data=row)
			channels.append(c)

		return channels

	def get_cdr_by_account(self, account, date=None, limit=None):
		res = self.db.query("SELECT * FROM cdr \
			WHERE ((caller_id_number = ANY(%s) AND bleg_uuid IS NOT NULL) \
				OR (destination_number = ANY(%s) AND bleg_uuid IS NULL)) \
				AND (%s IS NULL OR start_stamp::date = %s) \
			ORDER BY end_stamp DESC LIMIT %s", account._all_telephone_numbers,
			account._all_telephone_numbers, date, date, limit)

		for row in res:
			yield CDR(self, data=row)

	def get_call_by_uuid(self, uuid):
		res = self.db.get("SELECT * FROM cdr \
			WHERE uuid = %s", uuid)

		if res:
			return CDR(self, data=res)


class SIPRegistration(object):
	def __init__(self, freeswitch, data):
		self.freeswitch = freeswitch
		self.data = data

	@lazy_property
	def protocol(self):
		m = re.match(r"Registered\(([A-Z]+)(\-NAT)?\)", self.data.status)

		if m:
			return m.group(1)

	@property
	def network_ip(self):
		return ipaddress.ip_address(self.data.network_ip)

	@property
	def network_port(self):
		return self.data.network_port

	@property
	def user_agent(self):
		return self.data.user_agent

	def is_reachable(self):
		return self.data.ping_status == "Reachable"

	@lazy_property
	def latency(self):
		if self.is_reachable() and self.data.ping_time:
			return self.data.ping_time / 1000.0


class Channel(object):
	def __init__(self, freeswitch, data):
		self.freeswitch = freeswitch
		self.data = data

	@property
	def backend(self):
		return self.freeswitch.backend

	@property
	def uuid(self):
		return self.data.uuid

	@property
	def direction(self):
		return self.data.direction

	@lazy_property
	def caller(self):
		return self.backend.accounts.get_by_sip_id(self.caller_number)

	@property
	def caller_name(self):
		return self.data.cid_name

	@property
	def caller_number(self):
		return self.data.cid_num

	@lazy_property
	def callee(self):
		return self.backend.accounts.get_by_sip_id(self.callee_number)

	@property
	def callee_name(self):
		return self.data.callee_name

	@property
	def callee_number(self):
		return self.data.callee_num

	@property
	def called_number(self):
		return self.data.dest

	@property
	def application(self):
		return self.data.application

	@property
	def application_data(self):
		return self.data.application_data

	@property
	def duration(self):
		return time.time() - self.data.created_epoch

	@property
	def codec(self):
		# We always assume a symmetric codec
		return format_codec(self.data.write_codec, int(self.data.write_rate or 0), int(self.data.write_bit_rate or 0))

	def is_secure(self):
		if self.data.secure:
			return True

		return False

	@property
	def secure(self):
		try:
			transport_protocol, key_negotiation, cipher_suite = self.data.secure.split(":")
		except:
			return

		return "%s: %s" % (key_negotiation.upper(), cipher_suite.replace("_", "-"))


class CDR(object):
	def __init__(self, freeswitch, data):
		self.freeswitch = freeswitch
		self.data = data

	@property
	def backend(self):
		return self.freeswitch.backend

	@property
	def db(self):
		return self.freeswitch.db

	@property
	def uuid(self):
		return self.data.uuid

	@lazy_property
	def bleg(self):
		if self.data.bleg_uuid:
			return self.freeswitch.get_call_by_uuid(self.data.bleg_uuid)

		# If we are the bleg, we need to search for one where UUID is the bleg
		res = self.db.get("SELECT * FROM cdr WHERE bleg_uuid = %s", self.uuid)

		if res:
			return CDR(self.freeswitch, data=res)

	@property
	def direction(self):
		if self.data.bleg_uuid:
			return "inbound"

		return "outbound"

	@lazy_property
	def caller(self):
		return self.backend.accounts.get_by_phone_number(self.data.caller_id_number)

	@property
	def caller_number(self):
		return self.data.caller_id_number

	@lazy_property
	def callee(self):
		return self.backend.accounts.get_by_phone_number(self.data.destination_number)

	@property
	def callee_number(self):
		return self.data.destination_number

	@property
	def time_start(self):
		return self.data.start_stamp

	@property
	def time_answered(self):
		return self.data.answer_stamp

	@property
	def duration(self):
		return self.data.duration

	@property
	def codec(self):
		return format_codec(self.data.write_codec, int(self.data.write_rate or 0), int(self.data.write_bit_rate or 0))

	@property
	def user_agent(self):
		if self.data.user_agent:
			return self.data.user_agent.replace("_", " ")

	@property
	def size(self):
		return sum((self.data.rtp_audio_in_raw_bytes or 0, self.data.rtp_audio_out_raw_bytes or 0))

	@property
	def mos(self):
		return self.data.rtp_audio_in_mos


class Talk(Object):
	def init(self):
		# Connect to FreeSWITCH
		self.freeswitch = Freeswitch(self.backend)

	# Conferences

	@property
	def conferences(self):
		conferences = []

		for no in range(1, 10):
			conference = Conference(self.backend, no)
			conferences.append(conference)

		return conferences

	def get_conference(self, id):
		for c in self.conferences:
			if not c.sip_id == id:
				continue

			return c


class Conference(Object):
	def __init__(self, backend, no):
		Object.__init__(self, backend)
		self.no = no

	def __cmp__(self, other):
		return cmp(self.no, other.no)

	@property
	def name(self):
		return "IPFire Conference Room %s" % self.no

	@property
	def sip_id(self):
		return "%s" % (9000 + self.no)

	@property
	def sip_url(self):
		return "%s@ipfire.org" % self.sip_id

	@property
	def participants(self):
		if not hasattr(self, "_participants"):
			self._participants = self.backend.talk.get_ongoing_calls(sip_id=self.sip_id)

		return self._participants


def format_codec(name, bit_rate, bandwidth):
	s = [
		name,
	]

	if bit_rate:
		s.append("%.0f kHz" % (bit_rate / 1000.0))

	if bandwidth:
		s.append("%.0f kBit/s" % (bandwidth / 1000.0))
	else:
		s.append("VBR")

	return " ".join(s)