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

#/usr/bin/python

import logging
import itertools
import os.path
import phonenumbers
import phonenumbers.geocoder
import tornado.locale
import tornado.options
import tornado.web

import ipfire

from .handlers import *

from . import auth
from . import blog
from . import download
from . import location
from . import newsletter
from . import nopaste
from . import people
from . import ui_modules

class Application(tornado.web.Application):
	def __init__(self, config, **kwargs):
		# Initialize backend
		self.backend = ipfire.Backend(config)

		settings = {
			# Do not compress responses
			"gzip" : False,

			# Enable XSRF cookies
			"xsrf_cookies" : True,

			# Login
			"login_url" : "/login",

			# Setup directory structure
			"static_path"   : self.backend.config.get("global", "static_dir"),
			"template_path" : self.backend.config.get("global", "templates_dir"),

			# UI Modules
			"ui_methods" : {
				"format_month_name"            : self.format_month_name,
				"format_phone_number"          : self.format_phone_number,
				"format_phone_number_to_e164"  : self.format_phone_number_to_e164,
				"format_phone_number_location" : self.format_phone_number_location,
				"grouper"                      : grouper,
			},
			"ui_modules" : {
				# Blog
				"BlogHistoryNavigation": blog.HistoryNavigationModule,
				"BlogList"             : blog.ListModule,
				"BlogPost"             : blog.PostModule,
				"BlogPosts"            : blog.PostsModule,

				# Location
				"Map"                  : ui_modules.MapModule,

				# Talk
				"AccountsList"         : people.AccountsListModule,
				"CDR"                  : people.CDRModule,
				"Channels"             : people.ChannelsModule,
				"MOS"                  : people.MOSModule,
				"Registrations"        : people.RegistrationsModule,
				"SIPStatus"            : people.SIPStatusModule,

				# Nopaste
				"Code"                 : nopaste.CodeModule,

				# Old modules
				"LanguageName"         : ui_modules.LanguageNameModule,

				"MirrorItem"           : ui_modules.MirrorItemModule,
				"MirrorsTable"         : ui_modules.MirrorsTableModule,
				"NetBootMenuConfig"    : ui_modules.NetBootMenuConfigModule,
				"NetBootMenuHeader"    : ui_modules.NetBootMenuHeaderModule,
				"NetBootMenuSeparator" : ui_modules.NetBootMenuSeparatorModule,
				"ProgressBar"          : ui_modules.ProgressBarModule,
				"FireinfoDeviceTable"  : ui_modules.FireinfoDeviceTableModule,
				"FireinfoDeviceAndGroupsTable" : ui_modules.FireinfoDeviceAndGroupsTableModule,
				"FireinfoGeoTable"        : ui_modules.FireinfoGeoTableModule,
			},

			# Call this when a page wasn't found
			"default_handler_class" : NotFoundHandler,
		}
		settings.update(kwargs)

		tornado.web.Application.__init__(self, **settings)

		authentication_handlers = [
			(r"/login", auth.LoginHandler),
			(r"/logout", auth.LogoutHandler),
		]

		self.add_handlers(r"(dev|www)\.ipfire\.(at|org)", [
			# Entry site that lead the user to index
			(r"/", IndexHandler),

			# Download sites
			(r"/downloads", tornado.web.RedirectHandler, { "url" : "/download" }),
			(r"/download", download.IndexHandler),
			(r"/download/([0-9a-z\-\.]+)", download.ReleaseHandler),

			# Donate
			(r"/donate", DonateHandler),
			(r"/donation", tornado.web.RedirectHandler, { "url" : "/donate" }),

			# Newsletter
			(r"/newsletter/subscribe", newsletter.SubscribeHandler),

			# RSS feed
			(r"/news.rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),

			# Redirect news articles to blog
			(r"/news/(.*)", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/posts/{1}" }),

			# Static Pages
			(r"/chat", StaticHandler, { "template" : "chat.html" }),
			(r"/features", StaticHandler, { "template" : "features.html" }),
			(r"/legal", StaticHandler, { "template" : "legal.html" }),
			(r"/support", StaticHandler, { "template" : "support.html" }),

			# Handle old pages that have moved elsewhere
			(r"/imprint", tornado.web.RedirectHandler, { "url" : "/legal" }),
			(r"/(de|en)/(.*)", LangCompatHandler),

			# Export arbitrary error pages
			(r"/error/([45][0-9]{2})", ErrorHandler),

			# Block page
			(r"/blocked", BlockedHandler),
		])

		# blog.ipfire.org
		self.add_handlers(r"blog(\.dev)?\.ipfire\.org", [
			(r"/", blog.IndexHandler),
			(r"/authors/(\w+)", blog.AuthorHandler),
			(r"/compose", blog.ComposeHandler),
			(r"/drafts", blog.DraftsHandler),
			(r"/post/([0-9a-z\-\._]+)", blog.PostHandler),
			(r"/post/([0-9a-z\-\._]+)/edit", blog.EditHandler),
			(r"/post/([0-9a-z\-\._]+)/publish", blog.PublishHandler),
			(r"/search", blog.SearchHandler),
			(r"/tags/([0-9a-z\-\.]+)", blog.TagHandler),
			(r"/years/([0-9]+)", blog.YearHandler),

			# RSS Feed
			(r"/feed.xml", blog.FeedHandler),
		] + authentication_handlers)

		# downloads.ipfire.org
		self.add_handlers(r"downloads?(\.dev)?\.ipfire\.org", [
			(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/" }),
			(r"/(.*)", download.FileHandler),
		])

		# mirrors.ipfire.org
		self.add_handlers(r"mirrors(\.dev)?\.ipfire\.org", [
			(r"/", MirrorIndexHandler),
			(r"/mirror/(.*)", MirrorItemHandler),
		])

		# planet.ipfire.org
		self.add_handlers(r"planet(\.dev)?\.ipfire\.org", [
			(r"/", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/" }),
			(r"/post/([A-Za-z0-9_-]+)", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/posts/{1}" }),
			(r"/user/([a-z0-9_-]+)", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/authors/{1}" }),

			# RSS
			(r"/rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
			(r"/user/([a-z0-9_-]+)/rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/authors/{1}.rss" }),
			(r"/news.rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
		])

		# fireinfo.ipfire.org
		self.add_handlers(r"fireinfo(\.dev)?\.ipfire\.org", [
			(r"/", FireinfoIndexHandler),
			(r"/device/driver/(.*)", FireinfoDeviceDriverDetail),
			(r"/device/vendors", FireinfoDeviceVendorsHandler),
			(r"/device/(pci|usb)/([0-9a-f]{4})", FireinfoDeviceVendorHandler),
			(r"/device/(pci|usb)/([0-9a-f]{4})/([0-9a-f]{4})", FireinfoDeviceModelHandler),

			# Show profiles
			(r"/profile/random", FireinfoRandomProfileHandler),
			(r"/profile/([a-z0-9]{40})", FireinfoProfileDetailHandler),

			# Send profiles.
			(r"/send/([a-z0-9]+)", FireinfoProfileSendHandler),

			# Stats handlers
			(r"/statistics", FireinfoStatsHandler),
			(r"/statistics/processors", FireinfoStatsProcessorsHandler),
			(r"/statistics/processors/(arm|x86)", FireinfoStatsProcessorDetailHandler),
			(r"/statistics/geo-locations", FireinfoStatsGeoHandler),
			(r"/statistics/languages", FireinfoStatsLanguagesHandler),
			(r"/statistics/memory", FireinfoStatsMemoryHandler),
			(r"/statistics/networking", FireinfoStatsNetworkingHandler),
			(r"/statistics/releases", FireinfoStatsReleasesHandler),
			(r"/statistics/virtualization", FireinfoStatsVirtualHandler),

			# Compat handlers
			(r"/stats", tornado.web.RedirectHandler, { "url" : "/statistics" }),
			(r"/stats/cpus", tornado.web.RedirectHandler, { "url" : "/statistics/processors" }),
			(r"/stats/geo", tornado.web.RedirectHandler, { "url" : "/statistics/geo-locations" }),
			(r"/stats/network", tornado.web.RedirectHandler, { "url" : "/statistics/networking" }),
			(r"/stats/oses", tornado.web.RedirectHandler, { "url" : "/statistics/releases" }),
			(r"/stats/virtual", tornado.web.RedirectHandler, { "url" : "/statistics/virtualization" }),
			(r"/vendor/(pci|usb)/([0-9a-f]{4})", FireinfoDeviceVendorCompatHandler),
			(r"/model/(pci|usb)/([0-9a-f]{4})/([0-9a-f]{4})", FireinfoDeviceModelCompatHandler),
		])

		# i-use.ipfire.org
		self.add_handlers(r"i-use(\.dev)?\.ipfire\.org", [
			(r"/profile/([a-f0-9]{40})/([0-9]+).png", IUseImage),
		])

		# boot.ipfire.org
		BOOT_STATIC_PATH = os.path.join(self.settings["static_path"], "netboot")
		self.add_handlers(r"boot(\.dev)?\.ipfire\.org", [
			(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/download" }),

			# Configurations
			(r"/premenu.cfg", PremenuCfgHandler),
			(r"/menu.gpxe", MenuGPXEHandler),
			(r"/menu.cfg", MenuCfgHandler),

			# Static files
			(r"/(boot\.png|pxelinux\.0|menu\.c32|vesamenu\.c32)",
				tornado.web.StaticFileHandler, { "path" : BOOT_STATIC_PATH }),
		])

		# nopaste.ipfire.org
		self.add_handlers(r"nopaste(\.dev)?\.ipfire\.org", [
			(r"/", nopaste.CreateHandler),
			(r"/raw/(.*)", nopaste.RawHandler),
			(r"/view/(.*)", nopaste.ViewHandler),
		] + authentication_handlers)

		# location.ipfire.org
		self.add_handlers(r"location(\.dev)?\.ipfire\.org", [
			(r"/", location.IndexHandler),
			(r"/lookup/(.+)", location.LookupHandler),
		])

		# geoip.ipfire.org
		self.add_handlers(r"geoip(\.dev)?\.ipfire\.org", [
			(r"/", tornado.web.RedirectHandler, { "url" : "https://location.ipfire.org/" }),
		])

		# talk.ipfire.org
		self.add_handlers(r"talk(\.dev)?\.ipfire\.org", [
			(r"/", tornado.web.RedirectHandler, { "url" : "https://people.ipfire.org/" }),
		])

		# people.ipfire.org
		self.add_handlers(r"people(\.dev)?\.ipfire\.org", [
			(r"/", people.IndexHandler),
			(r"/conferences", people.ConferencesHandler),
			(r"/search", people.SearchHandler),
			(r"/users", people.UsersHandler),
			(r"/users/(\w+)", people.UserHandler),
			(r"/users/(\w+)\.jpg", people.AvatarHandler),
			(r"/users/(\w+)/calls/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})", people.CallHandler),
			(r"/users/(\w+)/calls(?:/(\d{4}-\d{2}-\d{2}))?", people.CallsHandler),
			(r"/users/(\w+)/edit", people.UserEditHandler),
			(r"/users/(\w+)/passwd", people.UserPasswdHandler),
			(r"/users/(\w+)/ssh-keys", people.SSHKeysIndexHandler),
			(r"/users/(\w+)/ssh-keys/(SHA256\:.*)/delete", people.SSHKeysDeleteHandler),
			(r"/users/(\w+)/ssh-keys/(SHA256\:.*)", people.SSHKeysDownloadHandler),
			(r"/users/(\w+)/ssh-keys/upload", people.SSHKeysUploadHandler),
			(r"/users/(\w+)/sip", people.SIPHandler),
		]  + authentication_handlers)

		# ipfire.org
		self.add_handlers(r"ipfire\.org", [
			(r".*", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org" })
		])

		logging.info("Successfully initialied application")

	def format_month_name(self, handler, month):
		_ = handler.locale.translate

		if month == 1:
			return _("January")
		elif month == 2:
			return _("February")
		elif month == 3:
			return _("March")
		elif month == 4:
			return _("April")
		elif month == 5:
			return _("May")
		elif month == 6:
			return _("June")
		elif month == 7:
			return _("July")
		elif month == 8:
			return _("August")
		elif month == 9:
			return _("September")
		elif month == 10:
			return _("October")
		elif month == 11:
			return _("November")
		elif month == 12:
			return _("December")

		return month

	def format_phone_number(self, handler, number):
		if not isinstance(number, phonenumbers.PhoneNumber):
			try:
				number = phonenumbers.parse(number, None)
			except phonenumbers.phonenumberutil.NumberParseException:
				return number

		return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)

	def format_phone_number_to_e164(self, handler, number):
		return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)

	def format_phone_number_location(self, handler, number):
		s = [
			phonenumbers.geocoder.description_for_number(number, handler.locale.code),
			phonenumbers.region_code_for_number(number),
		]

		return ", ".join((e for e in s if e))


def grouper(handler, iterator, n):
	"""
		Returns groups of n from the iterator
	"""
	i = iter(iterator)

	while True:
		ret = list(itertools.islice(i, 0, n))
		if not ret:
			break

		yield ret
Commit	Line	Data
	1	#/usr/bin/python
	2
	3	import logging
	4	import itertools
	5	import os.path
	6	import phonenumbers
	7	import phonenumbers.geocoder
	8	import tornado.locale
	9	import tornado.options
	10	import tornado.web
	11
	12	import ipfire
	13
	14	from .handlers import *
	15
	16	from . import auth
	17	from . import blog
	18	from . import download
	19	from . import location
	20	from . import newsletter
	21	from . import nopaste
	22	from . import people
	23	from . import ui_modules
	24
	25	class Application(tornado.web.Application):
	26	def __init__(self, config, **kwargs):
	27	# Initialize backend
	28	self.backend = ipfire.Backend(config)
	29
	30	settings = {
	31	# Do not compress responses
	32	"gzip" : False,
	33
	34	# Enable XSRF cookies
	35	"xsrf_cookies" : True,
	36
	37	# Login
	38	"login_url" : "/login",
	39
	40	# Setup directory structure
	41	"static_path" : self.backend.config.get("global", "static_dir"),
	42	"template_path" : self.backend.config.get("global", "templates_dir"),
	43
	44	# UI Modules
	45	"ui_methods" : {
	46	"format_month_name" : self.format_month_name,
	47	"format_phone_number" : self.format_phone_number,
	48	"format_phone_number_to_e164" : self.format_phone_number_to_e164,
	49	"format_phone_number_location" : self.format_phone_number_location,
	50	"grouper" : grouper,
	51	},
	52	"ui_modules" : {
	53	# Blog
	54	"BlogHistoryNavigation": blog.HistoryNavigationModule,
	55	"BlogList" : blog.ListModule,
	56	"BlogPost" : blog.PostModule,
	57	"BlogPosts" : blog.PostsModule,
	58
	59	# Location
	60	"Map" : ui_modules.MapModule,
	61
	62	# Talk
	63	"AccountsList" : people.AccountsListModule,
	64	"CDR" : people.CDRModule,
	65	"Channels" : people.ChannelsModule,
	66	"MOS" : people.MOSModule,
	67	"Registrations" : people.RegistrationsModule,
	68	"SIPStatus" : people.SIPStatusModule,
	69
	70	# Nopaste
	71	"Code" : nopaste.CodeModule,
	72
	73	# Old modules
	74	"LanguageName" : ui_modules.LanguageNameModule,
	75
	76	"MirrorItem" : ui_modules.MirrorItemModule,
	77	"MirrorsTable" : ui_modules.MirrorsTableModule,
	78	"NetBootMenuConfig" : ui_modules.NetBootMenuConfigModule,
	79	"NetBootMenuHeader" : ui_modules.NetBootMenuHeaderModule,
	80	"NetBootMenuSeparator" : ui_modules.NetBootMenuSeparatorModule,
	81	"ProgressBar" : ui_modules.ProgressBarModule,
	82	"FireinfoDeviceTable" : ui_modules.FireinfoDeviceTableModule,
	83	"FireinfoDeviceAndGroupsTable" : ui_modules.FireinfoDeviceAndGroupsTableModule,
	84	"FireinfoGeoTable" : ui_modules.FireinfoGeoTableModule,
	85	},
	86
	87	# Call this when a page wasn't found
	88	"default_handler_class" : NotFoundHandler,
	89	}
	90	settings.update(kwargs)
	91
	92	tornado.web.Application.__init__(self, **settings)
	93
	94	authentication_handlers = [
	95	(r"/login", auth.LoginHandler),
	96	(r"/logout", auth.LogoutHandler),
	97	]
	98
	99	self.add_handlers(r"(dev\|www)\.ipfire\.(at\|org)", [
	100	# Entry site that lead the user to index
	101	(r"/", IndexHandler),
	102
	103	# Download sites
	104	(r"/downloads", tornado.web.RedirectHandler, { "url" : "/download" }),
	105	(r"/download", download.IndexHandler),
	106	(r"/download/([0-9a-z\-\.]+)", download.ReleaseHandler),
	107
	108	# Donate
	109	(r"/donate", DonateHandler),
	110	(r"/donation", tornado.web.RedirectHandler, { "url" : "/donate" }),
	111
	112	# Newsletter
	113	(r"/newsletter/subscribe", newsletter.SubscribeHandler),
	114
	115	# RSS feed
	116	(r"/news.rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	117
	118	# Redirect news articles to blog
	119	(r"/news/(.*)", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/posts/{1}" }),
	120
	121	# Static Pages
	122	(r"/chat", StaticHandler, { "template" : "chat.html" }),
	123	(r"/features", StaticHandler, { "template" : "features.html" }),
	124	(r"/legal", StaticHandler, { "template" : "legal.html" }),
	125	(r"/support", StaticHandler, { "template" : "support.html" }),
	126
	127	# Handle old pages that have moved elsewhere
	128	(r"/imprint", tornado.web.RedirectHandler, { "url" : "/legal" }),
	129	(r"/(de\|en)/(.*)", LangCompatHandler),
	130
	131	# Export arbitrary error pages
	132	(r"/error/([45][0-9]{2})", ErrorHandler),
	133
	134	# Block page
	135	(r"/blocked", BlockedHandler),
	136	])
	137
	138	# blog.ipfire.org
	139	self.add_handlers(r"blog(\.dev)?\.ipfire\.org", [
	140	(r"/", blog.IndexHandler),
	141	(r"/authors/(\w+)", blog.AuthorHandler),
	142	(r"/compose", blog.ComposeHandler),
	143	(r"/drafts", blog.DraftsHandler),
	144	(r"/post/([0-9a-z\-\._]+)", blog.PostHandler),
	145	(r"/post/([0-9a-z\-\._]+)/edit", blog.EditHandler),
	146	(r"/post/([0-9a-z\-\._]+)/publish", blog.PublishHandler),
	147	(r"/search", blog.SearchHandler),
	148	(r"/tags/([0-9a-z\-\.]+)", blog.TagHandler),
	149	(r"/years/([0-9]+)", blog.YearHandler),
	150
	151	# RSS Feed
	152	(r"/feed.xml", blog.FeedHandler),
	153	] + authentication_handlers)
	154
	155	# downloads.ipfire.org
	156	self.add_handlers(r"downloads?(\.dev)?\.ipfire\.org", [
	157	(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/" }),
	158	(r"/(.*)", download.FileHandler),
	159	])
	160
	161	# mirrors.ipfire.org
	162	self.add_handlers(r"mirrors(\.dev)?\.ipfire\.org", [
	163	(r"/", MirrorIndexHandler),
	164	(r"/mirror/(.*)", MirrorItemHandler),
	165	])
	166
	167	# planet.ipfire.org
	168	self.add_handlers(r"planet(\.dev)?\.ipfire\.org", [
	169	(r"/", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/" }),
	170	(r"/post/([A-Za-z0-9_-]+)", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/posts/{1}" }),
	171	(r"/user/([a-z0-9_-]+)", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/authors/{1}" }),
	172
	173	# RSS
	174	(r"/rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	175	(r"/user/([a-z0-9_-]+)/rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/authors/{1}.rss" }),
	176	(r"/news.rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	177	])
	178
	179	# fireinfo.ipfire.org
	180	self.add_handlers(r"fireinfo(\.dev)?\.ipfire\.org", [
	181	(r"/", FireinfoIndexHandler),
	182	(r"/device/driver/(.*)", FireinfoDeviceDriverDetail),
	183	(r"/device/vendors", FireinfoDeviceVendorsHandler),
	184	(r"/device/(pci\|usb)/([0-9a-f]{4})", FireinfoDeviceVendorHandler),
	185	(r"/device/(pci\|usb)/([0-9a-f]{4})/([0-9a-f]{4})", FireinfoDeviceModelHandler),
	186
	187	# Show profiles
	188	(r"/profile/random", FireinfoRandomProfileHandler),
	189	(r"/profile/([a-z0-9]{40})", FireinfoProfileDetailHandler),
	190
	191	# Send profiles.
	192	(r"/send/([a-z0-9]+)", FireinfoProfileSendHandler),
	193
	194	# Stats handlers
	195	(r"/statistics", FireinfoStatsHandler),
	196	(r"/statistics/processors", FireinfoStatsProcessorsHandler),
	197	(r"/statistics/processors/(arm\|x86)", FireinfoStatsProcessorDetailHandler),
	198	(r"/statistics/geo-locations", FireinfoStatsGeoHandler),
	199	(r"/statistics/languages", FireinfoStatsLanguagesHandler),
	200	(r"/statistics/memory", FireinfoStatsMemoryHandler),
	201	(r"/statistics/networking", FireinfoStatsNetworkingHandler),
	202	(r"/statistics/releases", FireinfoStatsReleasesHandler),
	203	(r"/statistics/virtualization", FireinfoStatsVirtualHandler),
	204
	205	# Compat handlers
	206	(r"/stats", tornado.web.RedirectHandler, { "url" : "/statistics" }),
	207	(r"/stats/cpus", tornado.web.RedirectHandler, { "url" : "/statistics/processors" }),
	208	(r"/stats/geo", tornado.web.RedirectHandler, { "url" : "/statistics/geo-locations" }),
	209	(r"/stats/network", tornado.web.RedirectHandler, { "url" : "/statistics/networking" }),
	210	(r"/stats/oses", tornado.web.RedirectHandler, { "url" : "/statistics/releases" }),
	211	(r"/stats/virtual", tornado.web.RedirectHandler, { "url" : "/statistics/virtualization" }),
	212	(r"/vendor/(pci\|usb)/([0-9a-f]{4})", FireinfoDeviceVendorCompatHandler),
	213	(r"/model/(pci\|usb)/([0-9a-f]{4})/([0-9a-f]{4})", FireinfoDeviceModelCompatHandler),
	214	])
	215
	216	# i-use.ipfire.org
	217	self.add_handlers(r"i-use(\.dev)?\.ipfire\.org", [
	218	(r"/profile/([a-f0-9]{40})/([0-9]+).png", IUseImage),
	219	])
	220
	221	# boot.ipfire.org
	222	BOOT_STATIC_PATH = os.path.join(self.settings["static_path"], "netboot")
	223	self.add_handlers(r"boot(\.dev)?\.ipfire\.org", [
	224	(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/download" }),
	225
	226	# Configurations
	227	(r"/premenu.cfg", PremenuCfgHandler),
	228	(r"/menu.gpxe", MenuGPXEHandler),
	229	(r"/menu.cfg", MenuCfgHandler),
	230
	231	# Static files
	232	(r"/(boot\.png\|pxelinux\.0\|menu\.c32\|vesamenu\.c32)",
	233	tornado.web.StaticFileHandler, { "path" : BOOT_STATIC_PATH }),
	234	])
	235
	236	# nopaste.ipfire.org
	237	self.add_handlers(r"nopaste(\.dev)?\.ipfire\.org", [
	238	(r"/", nopaste.CreateHandler),
	239	(r"/raw/(.*)", nopaste.RawHandler),
	240	(r"/view/(.*)", nopaste.ViewHandler),
	241	] + authentication_handlers)
	242
	243	# location.ipfire.org
	244	self.add_handlers(r"location(\.dev)?\.ipfire\.org", [
	245	(r"/", location.IndexHandler),
	246	(r"/lookup/(.+)", location.LookupHandler),
	247	])
	248
	249	# geoip.ipfire.org
	250	self.add_handlers(r"geoip(\.dev)?\.ipfire\.org", [
	251	(r"/", tornado.web.RedirectHandler, { "url" : "https://location.ipfire.org/" }),
	252	])
	253
	254	# talk.ipfire.org
	255	self.add_handlers(r"talk(\.dev)?\.ipfire\.org", [
	256	(r"/", tornado.web.RedirectHandler, { "url" : "https://people.ipfire.org/" }),
	257	])
	258
	259	# people.ipfire.org
	260	self.add_handlers(r"people(\.dev)?\.ipfire\.org", [
	261	(r"/", people.IndexHandler),
	262	(r"/conferences", people.ConferencesHandler),
	263	(r"/search", people.SearchHandler),
	264	(r"/users", people.UsersHandler),
	265	(r"/users/(\w+)", people.UserHandler),
	266	(r"/users/(\w+)\.jpg", people.AvatarHandler),
	267	(r"/users/(\w+)/calls/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})", people.CallHandler),
	268	(r"/users/(\w+)/calls(?:/(\d{4}-\d{2}-\d{2}))?", people.CallsHandler),
	269	(r"/users/(\w+)/edit", people.UserEditHandler),
	270	(r"/users/(\w+)/passwd", people.UserPasswdHandler),
	271	(r"/users/(\w+)/ssh-keys", people.SSHKeysIndexHandler),
	272	(r"/users/(\w+)/ssh-keys/(SHA256\:.*)/delete", people.SSHKeysDeleteHandler),
	273	(r"/users/(\w+)/ssh-keys/(SHA256\:.*)", people.SSHKeysDownloadHandler),
	274	(r"/users/(\w+)/ssh-keys/upload", people.SSHKeysUploadHandler),
	275	(r"/users/(\w+)/sip", people.SIPHandler),
	276	] + authentication_handlers)
	277
	278	# ipfire.org
	279	self.add_handlers(r"ipfire\.org", [
	280	(r".*", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org" })
	281	])
	282
	283	logging.info("Successfully initialied application")
	284
	285	def format_month_name(self, handler, month):
	286	_ = handler.locale.translate
	287
	288	if month == 1:
	289	return _("January")
	290	elif month == 2:
	291	return _("February")
	292	elif month == 3:
	293	return _("March")
	294	elif month == 4:
	295	return _("April")
	296	elif month == 5:
	297	return _("May")
	298	elif month == 6:
	299	return _("June")
	300	elif month == 7:
	301	return _("July")
	302	elif month == 8:
	303	return _("August")
	304	elif month == 9:
	305	return _("September")
	306	elif month == 10:
	307	return _("October")
	308	elif month == 11:
	309	return _("November")
	310	elif month == 12:
	311	return _("December")
	312
	313	return month
	314
	315	def format_phone_number(self, handler, number):
	316	if not isinstance(number, phonenumbers.PhoneNumber):
	317	try:
	318	number = phonenumbers.parse(number, None)
	319	except phonenumbers.phonenumberutil.NumberParseException:
	320	return number
	321
	322	return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
	323
	324	def format_phone_number_to_e164(self, handler, number):
	325	return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
	326
	327	def format_phone_number_location(self, handler, number):
	328	s = [
	329	phonenumbers.geocoder.description_for_number(number, handler.locale.code),
	330	phonenumbers.region_code_for_number(number),
	331	]
	332
	333	return ", ".join((e for e in s if e))
	334
	335
	336	def grouper(handler, iterator, n):
	337	"""
	338	Returns groups of n from the iterator
	339	"""
	340	i = iter(iterator)
	341
	342	while True:
	343	ret = list(itertools.islice(i, 0, n))
	344	if not ret:
	345	break
	346
	347	yield ret