cache static pages

[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) ORDER BY created_epoch",
			"inbound", account.sip_id, "outbound", account.sip_id)

		channels = []

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

		return channels


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
		s = [
			"%s @ %s kHz" % (self.data.write_codec, int(self.data.write_rate) / 1000.0),
		]

		if self.data.write_bit_rate == "0":
			s.append("VBR")
		else:
			s.append("%.0f kBit/s" % (int(self.data.write_bit_rate) / 1000.0))

		return " ".join(s)

	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 Talk(Object):
	def init(self):
		# Connect to FreeSWITCH
		self.freeswitch = Freeswitch(self.backend)

	@property
	def accounts(self):
		for account in self.backend.accounts:
			if not account.is_talk_enabled():
				continue

			yield account

	def search(self, query):
		accounts = []

		for account in self.backend.accounts.search(query):
			if not account.is_talk_enabled():
				continue

			accounts.append(account)

		return accounts

	# 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