users: Connect to Asterisk and show any ongoing calls

[ipfire.org.git] / src / web / users.py

#!/usr/bin/python

import PIL
import imghdr
import io
import ldap
import logging
import os.path
import tornado.web

from .. import countries

from . import base
from . import ui_modules

COLOUR_LIGHT = (237,232,232)
COLOUR_DARK  = (49,53,60)

class IndexHandler(base.BaseHandler):
	@tornado.web.authenticated
	def get(self):
		results = None

		# Query Term
		q = self.get_argument("q", None)

		# Peform search
		if q:
			results = self.backend.accounts.search(q)

		self.render("users/index.html", q=q, results=results)


class ShowHandler(base.BaseHandler):
	@tornado.web.authenticated
	async def get(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Fetch SIP channels
		sip_channels = await account.get_sip_channels()

		self.render("users/show.html", account=account, sip_channels=sip_channels)


class AvatarHandler(base.BaseHandler):
	def get(self, uid):
		# Get the desired size of the avatar file
		size = self.get_argument("size", None)

		try:
			size = int(size)
		except (TypeError, ValueError):
			size = None

		logging.debug("Querying for avatar of %s" % uid)

		# Fetch user account
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Allow downstream to cache this for a year
		self.set_expires(31536000)

		# Resize avatar
		avatar = account.get_avatar(size)

		# If there is no avatar, we serve a default image
		if not avatar:
			logging.debug("No avatar uploaded for %s" % account)

			# Generate a random avatar with only one letter
			avatar = self._get_avatar(account, size=size)

		# Guess content type
		type = imghdr.what(None, avatar)

		# If we could not guess the type, we will try something else
		if not type:
			# Could this be an SVG file?
			if avatar.startswith(b"<"):
				type = "svg+xml"

		# Set headers about content
		self.set_header("Content-Disposition", "inline; filename=\"%s.%s\"" % (account.uid, type))
		if type:
			self.set_header("Content-Type", "image/%s" % type)

		# Deliver payload
		self.finish(avatar)

	def _get_avatar(self, account, size=None, **args):
		letter = ("%s" % account)[0].upper()

		if size is None:
			size = 256

		# The generated avatar cannot be larger than 1024px
		if size >= 2048:
			size = 2048

		# Cache key
		key = "avatar:letter:%s:%s" % (letter, size)

		# Fetch avatar from the cache
		avatar = self.memcached.get(key)
		if not avatar:
			avatar = self._make_avatar(letter, size=size, **args)

			# Cache for forever
			self.memcached.set(key, avatar)

		return avatar

	def _make_avatar(self, letter, format="PNG", size=None, **args):
		# Generate an image of the correct size
		image = PIL.Image.new("RGBA", (size, size), COLOUR_LIGHT)

		# Have a canvas
		draw = PIL.ImageDraw.Draw(image)

		# Load font
		font = PIL.ImageFont.truetype(os.path.join(
			self.application.settings.get("static_path", ""),
			"fonts/Prompt-Bold.ttf"
		), size, encoding="unic")

		# Determine size of the printed letter
		w, h = font.getsize(letter)

		# Mukta seems to be very broken and the height needs to be corrected
		h //= 0.7

		# Draw the letter in the center
		draw.text(((size - w) / 2, (size - h) / 2), letter,
			font=font, fill=COLOUR_DARK)

		with io.BytesIO() as f:
			# If writing out the image does not work with optimization,
			# we try to write it out without any optimization.
			try:
				image.save(f, format, optimize=True, **args)
			except:
				image.save(f, format, **args)

			return f.getvalue()


class EditHandler(base.BaseHandler):
	@tornado.web.authenticated
	def get(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Check for permissions
		if not account.can_be_managed_by(self.current_user):
			raise tornado.web.HTTPError(403, "%s cannot manage %s" % (self.current_user, account))

		self.render("users/edit.html", account=account, countries=countries.get_all())

	@tornado.web.authenticated
	def post(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Check for permissions
		if not account.can_be_managed_by(self.current_user):
			raise tornado.web.HTTPError(403, "%s cannot manage %s" % (self.current_user, account))

		# Unfortunately this cannot be wrapped into a transaction
		try:
			account.first_name   = self.get_argument("first_name")
			account.last_name    = self.get_argument("last_name")
			account.nickname     = self.get_argument("nickname", None)
			account.street       = self.get_argument("street", None)
			account.city         = self.get_argument("city", None)
			account.postal_code  = self.get_argument("postal_code", None)
			account.country_code = self.get_argument("country_code", None)
			account.description  = self.get_argument("description", None)

			# Avatar
			try:
				filename, data, mimetype = self.get_file("avatar")

				if not mimetype.startswith("image/"):
					raise tornado.web.HTTPError(400, "Avatar is not an image file: %s" % mimetype)

				account.upload_avatar(data)
			except TypeError:
				pass

			# Email
			account.mail_routing_address = self.get_argument("mail_routing_address", None)

			# Telephone
			account.phone_numbers = self.get_argument("phone_numbers", "").splitlines()
			account.sip_routing_address = self.get_argument("sip_routing_address", None)
		except ldap.STRONG_AUTH_REQUIRED as e:
			raise tornado.web.HTTPError(403, "%s" % e) from e

		# Redirect back to user page
		self.redirect("/users/%s" % account.uid)


class DeleteHandler(base.BaseHandler):
	@tornado.web.authenticated
	def get(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Check for permissions
		if not account.can_be_deleted_by(self.current_user):
			raise tornado.web.HTTPError(403, "%s cannot delete %s" % (self.current_user, account))

		self.render("users/delete.html", account=account)

	@tornado.web.authenticated
	async def post(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Check for permissions
		if not account.can_be_deleted_by(self.current_user):
			raise tornado.web.HTTPError(403, "%s cannot delete %s" % (self.current_user, account))

		# Delete!
		with self.db.transaction():
			await account.delete(self.current_user)

		self.render("users/deleted.html", account=account)


class PasswdHandler(base.BaseHandler):
	@tornado.web.authenticated
	def get(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Check for permissions
		if not account.can_be_managed_by(self.current_user):
			raise tornado.web.HTTPError(403, "%s cannot manage %s" % (self.current_user, account))

		self.render("users/passwd.html", account=account)

	@tornado.web.authenticated
	def post(self, uid):
		account = self.backend.accounts.get_by_uid(uid)
		if not account:
			raise tornado.web.HTTPError(404, "Could not find account %s" % uid)

		# Check for permissions
		if not account.can_be_managed_by(self.current_user):
			raise tornado.web.HTTPError(403, "%s cannot manage %s" % (self.current_user, account))

		# Get current password
		password = self.get_argument("password")

		# Get new password
		password1 = self.get_argument("password1")
		password2 = self.get_argument("password2")

		# Passwords must match
		if not password1 == password2:
			raise tornado.web.HTTPError(400, "Passwords do not match")

		# XXX Check password complexity

		# Check if old password matches
		if not account.check_password(password):
			raise tornado.web.HTTPError(403, "Incorrect password for %s" % account)

		# Save new password
		account.passwd(password1)

		# Redirect back to user's page
		self.redirect("/users/%s" % account.uid)


class GroupIndexHandler(base.BaseHandler):
	@tornado.web.authenticated
	def get(self):
		# Only staff can see other groups
		if not self.current_user.is_staff():
			raise tornado.web.HTTPError(403)

		self.render("users/groups/index.html")


class GroupShowHandler(base.BaseHandler):
	@tornado.web.authenticated
	def get(self, gid):
		# Only staff can see other groups
		if not self.current_user.is_staff():
			raise tornado.web.HTTPError(403)

		# Fetch group
		group = self.backend.groups.get_by_gid(gid)
		if not group:
			raise tornado.web.HTTPError(404, "Could not find group %s" % gid)

		self.render("users/groups/show.html", group=group)


class ListModule(ui_modules.UIModule):
	def render(self, accounts, show_created_at=False):
		return self.render_string("users/modules/list.html", accounts=accounts,
			show_created_at=show_created_at)