[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
import ipfire.countries

from .handlers import *

from . import auth
from . import blog
from . import boot
from . import donate
from . import download
from . import fireinfo
from . import iuse
from . import location
from . import mirrors
from . import nopaste
from . import people
from . import ui_modules
from . import wiki

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 Methods
			"ui_methods" : {
				"format_country_name"          : self.format_country_name,
				"format_language_name"         : self.format_language_name,
				"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
			"ui_modules" : {
				# Blog
				"BlogHistoryNavigation": blog.HistoryNavigationModule,
				"BlogList"             : blog.ListModule,
				"BlogPost"             : blog.PostModule,
				"BlogPosts"            : blog.PostsModule,

				# Boot
				"BootMenuConfig"       : boot.MenuConfigModule,
				"BootMenuHeader"       : boot.MenuHeaderModule,
				"BootMenuSeparator"    : boot.MenuSeparatorModule,

				# People
				"AccountsList"         : people.AccountsListModule,
				"Agent"                : people.AgentModule,
				"CDR"                  : people.CDRModule,
				"Channels"             : people.ChannelsModule,
				"MOS"                  : people.MOSModule,
				"NewAccounts"          : people.NewAccountsModule,
				"Password"             : people.PasswordModule,
				"Registrations"        : people.RegistrationsModule,
				"SIPStatus"            : people.SIPStatusModule,

				# Nopaste
				"Code"                 : nopaste.CodeModule,

				# Fireinfo
				"FireinfoDeviceTable"  : fireinfo.DeviceTableModule,
				"FireinfoDeviceAndGroupsTable"
				                       : fireinfo.DeviceAndGroupsTableModule,

				# Wiki
				"WikiDiff"             : wiki.WikiDiffModule,
				"WikiNavbar"           : wiki.WikiNavbarModule,
				"WikiList"             : wiki.WikiListModule,

				# Misc
				"ChristmasBanner"      : ui_modules.ChristmasBannerModule,
				"Markdown"             : ui_modules.MarkdownModule,
				"Map"                  : ui_modules.MapModule,
				"ProgressBar"          : ui_modules.ProgressBarModule,
			},

			# Call this when a page wasn't found
			"default_handler_class" : base.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\.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", donate.DonateHandler),
			(r"/donate/thank-you", donate.ThankYouHandler),
			(r"/donate/error", donate.ErrorHandler),
			(r"/donation", tornado.web.RedirectHandler, { "url" : "/donate" }),

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

			# Redirect news articles to blog
			(r"/news/(.*)", handlers.NewsHandler),

			# Static Pages
			(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})", base.ErrorHandler),

			# Block page
			(r"/blocked", base.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\-\._]+)/delete", blog.DeleteHandler),
			(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"/release/(.*)", download.ReleaseRedirectHandler),
			(r"/(.*)", download.FileHandler),
		])

		# mirrors.ipfire.org
		self.add_handlers(r"mirrors(\.dev)?\.ipfire\.org", [
			(r"/", mirrors.IndexHandler),
			(r"/mirrors/(.*)", mirrors.MirrorHandler),
		])

		# 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_-]+)", handlers.PlanetPostHandler),
			(r"/user/([a-z0-9_-]+)", handlers.PlanetUserHandler),

			# 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/feed.xml" }),
			(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"/", fireinfo.IndexHandler),

			# Admin
			(r"/admin", fireinfo.AdminIndexHandler),

			# Vendors
			(r"/vendors", fireinfo.VendorsHandler),
			(r"/vendors/(pci|usb)/([0-9a-f]{4})", fireinfo.VendorHandler),

			# Driver
			(r"/drivers/(.*)", fireinfo.DriverDetail),

			# Show profiles
			(r"/profile/random", fireinfo.RandomProfileHandler),
			(r"/profile/([a-z0-9]{40})", fireinfo.ProfileHandler),

			# Stats
			(r"/processors", fireinfo.ProcessorsHandler),
			(r"/releases", fireinfo.ReleasesHandler),

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

		# i-use.ipfire.org
		self.add_handlers(r"i-use(\.dev)?\.ipfire\.org", [
			(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/" }),
			(r"/profile/([a-f0-9]{40})/([0-9]+).png", iuse.ImageHandler),
		])

		# 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://wiki.ipfire.org/installation/pxe" }),

			# Configurations
			(r"/premenu.cfg", boot.PremenuCfgHandler),
			(r"/menu.gpxe", boot.MenuGPXEHandler),
			(r"/menu.cfg", boot.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"/how\-to\-use", StaticHandler, { "template" : "../location/how-to-use.html" }),
			(r"/lookup/(.+)/blacklists", location.BlacklistsHandler),
			(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"/activate/([a-z_][a-z0-9_-]{0,31})/(\w+)", auth.ActivateHandler),
			(r"/conferences", people.ConferencesHandler),
			(r"/groups", people.GroupsHandler),
			(r"/groups/([a-z_][a-z0-9_-]{0,31})", people.GroupHandler),
			(r"/register", auth.RegisterHandler),
			(r"/search", people.SearchHandler),
			(r"/users", people.UsersHandler),
			(r"/users/([a-z_][a-z0-9_-]{0,31})", people.UserHandler),
			(r"/users/([a-z_][a-z0-9_-]{0,31})\.jpg", people.AvatarHandler),
			(r"/users/([a-z_][a-z0-9_-]{0,31})/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/([a-z_][a-z0-9_-]{0,31})/calls(?:/(\d{4}-\d{2}-\d{2}))?", people.CallsHandler),
			(r"/users/([a-z_][a-z0-9_-]{0,31})/edit", people.UserEditHandler),
			(r"/users/([a-z_][a-z0-9_-]{0,31})/passwd", people.UserPasswdHandler),
			(r"/users/([a-z_][a-z0-9_-]{0,31})/sip", people.SIPHandler),

			# Promotional Consent Stuff
			(r"/subscribe", people.SubscribeHandler),
			(r"/unsubscribe", people.UnsubscribeHandler),

			# Single-Sign-On for Discourse
			(r"/sso/discourse", people.SSODiscourse),

			# Password Reset
			(r"/password\-reset", auth.PasswordResetInitiationHandler),
			(r"/password\-reset/([a-z_][a-z0-9_-]{0,31})/(\w+)", auth.PasswordResetHandler),

			# Stats
			(r"/stats", people.StatsHandler),

			# API
			(r"/api/check/email", auth.APICheckEmail),
			(r"/api/check/uid", auth.APICheckUID),
		]  + authentication_handlers)

		# wiki.ipfire.org
		self.add_handlers(r"wiki(\.dev)?\.ipfire\.org",
			authentication_handlers + [

			# Actions
			(r"((?:[A-Za-z0-9\-_\/]+)?(?:.*)\.(?:\w+))/_delete", wiki.ActionDeleteHandler),
			(r"([A-Za-z0-9\-_\/]+)?/_edit", wiki.ActionEditHandler),
			(r"([A-Za-z0-9\-_\/]+)?/_render", wiki.ActionRenderHandler),
			(r"([A-Za-z0-9\-_\/]+)?/_(watch|unwatch)", wiki.ActionWatchHandler),
			(r"/actions/restore", wiki.ActionRestoreHandler),
			(r"/actions/upload", wiki.ActionUploadHandler),

			# Handlers
			(r"/recent\-changes", wiki.RecentChangesHandler),
			(r"/search", wiki.SearchHandler),
			(r"/watchlist", wiki.WatchlistHandler),

			# Media
			(r"([A-Za-z0-9\-_\/]+)?/_files", wiki.FilesHandler),
			(r"((?!/static)(?:[A-Za-z0-9\-_\/]+)?(?:.*)\.(?:\w+))$", wiki.FileHandler),

			# Render pages
			(r"([A-Za-z0-9\-_\/]+)?", wiki.PageHandler),
		])

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

		logging.info("Successfully initialied application")

	def format_country_name(self, handler, country_code):
		return ipfire.countries.get_name(country_code)

	def format_language_name(self, handler, language):
		_ = handler.locale.translate

		if language == "de":
			return _("German")
		elif language == "en":
			return _("English")
		elif language == "es":
			return _("Spanish")
		elif language == "fr":
			return _("French")
		elif language == "it":
			return _("Italian")
		elif language == "nl":
			return _("Dutch")
		elif language == "pl":
			return _("Polish")
		elif language == "pt":
			return _("Portuguese")
		elif language == "ru":
			return _("Russian")
		elif language == "tr":
			return _("Turkish")

		return language

	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	import ipfire.countries
	14
	15	from .handlers import *
	16
	17	from . import auth
	18	from . import blog
	19	from . import boot
	20	from . import donate
	21	from . import download
	22	from . import fireinfo
	23	from . import iuse
	24	from . import location
	25	from . import mirrors
	26	from . import nopaste
	27	from . import people
	28	from . import ui_modules
	29	from . import wiki
	30
	31	class Application(tornado.web.Application):
	32	def __init__(self, config, **kwargs):
	33	# Initialize backend
	34	self.backend = ipfire.Backend(config)
	35
	36	settings = {
	37	# Do not compress responses
	38	"gzip" : False,
	39
	40	# Enable XSRF cookies
	41	"xsrf_cookies" : True,
	42
	43	# Login
	44	"login_url" : "/login",
	45
	46	# Setup directory structure
	47	"static_path" : self.backend.config.get("global", "static_dir"),
	48	"template_path" : self.backend.config.get("global", "templates_dir"),
	49
	50	# UI Methods
	51	"ui_methods" : {
	52	"format_country_name" : self.format_country_name,
	53	"format_language_name" : self.format_language_name,
	54	"format_month_name" : self.format_month_name,
	55	"format_phone_number" : self.format_phone_number,
	56	"format_phone_number_to_e164" : self.format_phone_number_to_e164,
	57	"format_phone_number_location" : self.format_phone_number_location,
	58	"grouper" : grouper,
	59	},
	60
	61	# UI Modules
	62	"ui_modules" : {
	63	# Blog
	64	"BlogHistoryNavigation": blog.HistoryNavigationModule,
	65	"BlogList" : blog.ListModule,
	66	"BlogPost" : blog.PostModule,
	67	"BlogPosts" : blog.PostsModule,
	68
	69	# Boot
	70	"BootMenuConfig" : boot.MenuConfigModule,
	71	"BootMenuHeader" : boot.MenuHeaderModule,
	72	"BootMenuSeparator" : boot.MenuSeparatorModule,
	73
	74	# People
	75	"AccountsList" : people.AccountsListModule,
	76	"Agent" : people.AgentModule,
	77	"CDR" : people.CDRModule,
	78	"Channels" : people.ChannelsModule,
	79	"MOS" : people.MOSModule,
	80	"NewAccounts" : people.NewAccountsModule,
	81	"Password" : people.PasswordModule,
	82	"Registrations" : people.RegistrationsModule,
	83	"SIPStatus" : people.SIPStatusModule,
	84
	85	# Nopaste
	86	"Code" : nopaste.CodeModule,
	87
	88	# Fireinfo
	89	"FireinfoDeviceTable" : fireinfo.DeviceTableModule,
	90	"FireinfoDeviceAndGroupsTable"
	91	: fireinfo.DeviceAndGroupsTableModule,
	92
	93	# Wiki
	94	"WikiDiff" : wiki.WikiDiffModule,
	95	"WikiNavbar" : wiki.WikiNavbarModule,
	96	"WikiList" : wiki.WikiListModule,
	97
	98	# Misc
	99	"ChristmasBanner" : ui_modules.ChristmasBannerModule,
	100	"Markdown" : ui_modules.MarkdownModule,
	101	"Map" : ui_modules.MapModule,
	102	"ProgressBar" : ui_modules.ProgressBarModule,
	103	},
	104
	105	# Call this when a page wasn't found
	106	"default_handler_class" : base.NotFoundHandler,
	107	}
	108	settings.update(kwargs)
	109
	110	tornado.web.Application.__init__(self, **settings)
	111
	112	authentication_handlers = [
	113	(r"/login", auth.LoginHandler),
	114	(r"/logout", auth.LogoutHandler),
	115	]
	116
	117	self.add_handlers(r"(dev\|www)\.ipfire\.org", [
	118	# Entry site that lead the user to index
	119	(r"/", IndexHandler),
	120
	121	# Download sites
	122	(r"/downloads", tornado.web.RedirectHandler, { "url" : "/download" }),
	123	(r"/download", download.IndexHandler),
	124	(r"/download/([0-9a-z\-\.]+)", download.ReleaseHandler),
	125
	126	# Donate
	127	(r"/donate", donate.DonateHandler),
	128	(r"/donate/thank-you", donate.ThankYouHandler),
	129	(r"/donate/error", donate.ErrorHandler),
	130	(r"/donation", tornado.web.RedirectHandler, { "url" : "/donate" }),
	131
	132	# RSS feed
	133	(r"/news.rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	134
	135	# Redirect news articles to blog
	136	(r"/news/(.*)", handlers.NewsHandler),
	137
	138	# Static Pages
	139	(r"/features", StaticHandler, { "template" : "features.html" }),
	140	(r"/legal", StaticHandler, { "template" : "legal.html" }),
	141	(r"/support", StaticHandler, { "template" : "support.html" }),
	142
	143	# Handle old pages that have moved elsewhere
	144	(r"/imprint", tornado.web.RedirectHandler, { "url" : "/legal" }),
	145	(r"/(de\|en)/(.*)", LangCompatHandler),
	146
	147	# Export arbitrary error pages
	148	(r"/error/([45][0-9]{2})", base.ErrorHandler),
	149
	150	# Block page
	151	(r"/blocked", base.BlockedHandler),
	152	])
	153
	154	# blog.ipfire.org
	155	self.add_handlers(r"blog(\.dev)?\.ipfire\.org", [
	156	(r"/", blog.IndexHandler),
	157	(r"/authors/(\w+)", blog.AuthorHandler),
	158	(r"/compose", blog.ComposeHandler),
	159	(r"/drafts", blog.DraftsHandler),
	160	(r"/post/([0-9a-z\-\._]+)", blog.PostHandler),
	161	(r"/post/([0-9a-z\-\._]+)/delete", blog.DeleteHandler),
	162	(r"/post/([0-9a-z\-\._]+)/edit", blog.EditHandler),
	163	(r"/post/([0-9a-z\-\._]+)/publish", blog.PublishHandler),
	164	(r"/search", blog.SearchHandler),
	165	(r"/tags/([0-9a-z\-\.]+)", blog.TagHandler),
	166	(r"/years/([0-9]+)", blog.YearHandler),
	167
	168	# RSS Feed
	169	(r"/feed.xml", blog.FeedHandler),
	170	] + authentication_handlers)
	171
	172	# downloads.ipfire.org
	173	self.add_handlers(r"downloads?(\.dev)?\.ipfire\.org", [
	174	(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/" }),
	175	(r"/release/(.*)", download.ReleaseRedirectHandler),
	176	(r"/(.*)", download.FileHandler),
	177	])
	178
	179	# mirrors.ipfire.org
	180	self.add_handlers(r"mirrors(\.dev)?\.ipfire\.org", [
	181	(r"/", mirrors.IndexHandler),
	182	(r"/mirrors/(.*)", mirrors.MirrorHandler),
	183	])
	184
	185	# planet.ipfire.org
	186	self.add_handlers(r"planet(\.dev)?\.ipfire\.org", [
	187	(r"/", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/" }),
	188	(r"/post/([A-Za-z0-9_-]+)", handlers.PlanetPostHandler),
	189	(r"/user/([a-z0-9_-]+)", handlers.PlanetUserHandler),
	190
	191	# RSS
	192	(r"/rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	193	(r"/user/([a-z0-9_-]+)/rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	194	(r"/news.rss", tornado.web.RedirectHandler, { "url" : "https://blog.ipfire.org/feed.xml" }),
	195	])
	196
	197	# fireinfo.ipfire.org
	198	self.add_handlers(r"fireinfo(\.dev)?\.ipfire\.org", [
	199	(r"/", fireinfo.IndexHandler),
	200
	201	# Admin
	202	(r"/admin", fireinfo.AdminIndexHandler),
	203
	204	# Vendors
	205	(r"/vendors", fireinfo.VendorsHandler),
	206	(r"/vendors/(pci\|usb)/([0-9a-f]{4})", fireinfo.VendorHandler),
	207
	208	# Driver
	209	(r"/drivers/(.*)", fireinfo.DriverDetail),
	210
	211	# Show profiles
	212	(r"/profile/random", fireinfo.RandomProfileHandler),
	213	(r"/profile/([a-z0-9]{40})", fireinfo.ProfileHandler),
	214
	215	# Stats
	216	(r"/processors", fireinfo.ProcessorsHandler),
	217	(r"/releases", fireinfo.ReleasesHandler),
	218
	219	# Send profiles
	220	(r"/send/([a-z0-9]+)", fireinfo.ProfileSendHandler),
	221	] + authentication_handlers)
	222
	223	# i-use.ipfire.org
	224	self.add_handlers(r"i-use(\.dev)?\.ipfire\.org", [
	225	(r"/", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org/" }),
	226	(r"/profile/([a-f0-9]{40})/([0-9]+).png", iuse.ImageHandler),
	227	])
	228
	229	# boot.ipfire.org
	230	BOOT_STATIC_PATH = os.path.join(self.settings["static_path"], "netboot")
	231	self.add_handlers(r"boot(\.dev)?\.ipfire\.org", [
	232	(r"/", tornado.web.RedirectHandler, { "url" : "https://wiki.ipfire.org/installation/pxe" }),
	233
	234	# Configurations
	235	(r"/premenu.cfg", boot.PremenuCfgHandler),
	236	(r"/menu.gpxe", boot.MenuGPXEHandler),
	237	(r"/menu.cfg", boot.MenuCfgHandler),
	238
	239	# Static files
	240	(r"/(boot\.png\|pxelinux\.0\|menu\.c32\|vesamenu\.c32)",
	241	tornado.web.StaticFileHandler, { "path" : BOOT_STATIC_PATH }),
	242	])
	243
	244	# nopaste.ipfire.org
	245	self.add_handlers(r"nopaste(\.dev)?\.ipfire\.org", [
	246	(r"/", nopaste.CreateHandler),
	247	(r"/raw/(.*)", nopaste.RawHandler),
	248	(r"/view/(.*)", nopaste.ViewHandler),
	249	] + authentication_handlers)
	250
	251	# location.ipfire.org
	252	self.add_handlers(r"location(\.dev)?\.ipfire\.org", [
	253	(r"/", location.IndexHandler),
	254	(r"/how\-to\-use", StaticHandler, { "template" : "../location/how-to-use.html" }),
	255	(r"/lookup/(.+)/blacklists", location.BlacklistsHandler),
	256	(r"/lookup/(.+)", location.LookupHandler),
	257	])
	258
	259	# geoip.ipfire.org
	260	self.add_handlers(r"geoip(\.dev)?\.ipfire\.org", [
	261	(r"/", tornado.web.RedirectHandler, { "url" : "https://location.ipfire.org/" }),
	262	])
	263
	264	# talk.ipfire.org
	265	self.add_handlers(r"talk(\.dev)?\.ipfire\.org", [
	266	(r"/", tornado.web.RedirectHandler, { "url" : "https://people.ipfire.org/" }),
	267	])
	268
	269	# people.ipfire.org
	270	self.add_handlers(r"people(\.dev)?\.ipfire\.org", [
	271	(r"/", people.IndexHandler),
	272	(r"/activate/([a-z_][a-z0-9_-]{0,31})/(\w+)", auth.ActivateHandler),
	273	(r"/conferences", people.ConferencesHandler),
	274	(r"/groups", people.GroupsHandler),
	275	(r"/groups/([a-z_][a-z0-9_-]{0,31})", people.GroupHandler),
	276	(r"/register", auth.RegisterHandler),
	277	(r"/search", people.SearchHandler),
	278	(r"/users", people.UsersHandler),
	279	(r"/users/([a-z_][a-z0-9_-]{0,31})", people.UserHandler),
	280	(r"/users/([a-z_][a-z0-9_-]{0,31})\.jpg", people.AvatarHandler),
	281	(r"/users/([a-z_][a-z0-9_-]{0,31})/calls/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})", people.CallHandler),
	282	(r"/users/([a-z_][a-z0-9_-]{0,31})/calls(?:/(\d{4}-\d{2}-\d{2}))?", people.CallsHandler),
	283	(r"/users/([a-z_][a-z0-9_-]{0,31})/edit", people.UserEditHandler),
	284	(r"/users/([a-z_][a-z0-9_-]{0,31})/passwd", people.UserPasswdHandler),
	285	(r"/users/([a-z_][a-z0-9_-]{0,31})/sip", people.SIPHandler),
	286
	287	# Promotional Consent Stuff
	288	(r"/subscribe", people.SubscribeHandler),
	289	(r"/unsubscribe", people.UnsubscribeHandler),
	290
	291	# Single-Sign-On for Discourse
	292	(r"/sso/discourse", people.SSODiscourse),
	293
	294	# Password Reset
	295	(r"/password\-reset", auth.PasswordResetInitiationHandler),
	296	(r"/password\-reset/([a-z_][a-z0-9_-]{0,31})/(\w+)", auth.PasswordResetHandler),
	297
	298	# Stats
	299	(r"/stats", people.StatsHandler),
	300
	301	# API
	302	(r"/api/check/email", auth.APICheckEmail),
	303	(r"/api/check/uid", auth.APICheckUID),
	304	] + authentication_handlers)
	305
	306	# wiki.ipfire.org
	307	self.add_handlers(r"wiki(\.dev)?\.ipfire\.org",
	308	authentication_handlers + [
	309
	310	# Actions
	311	(r"((?:[A-Za-z0-9\-_\/]+)?(?:.*)\.(?:\w+))/_delete", wiki.ActionDeleteHandler),
	312	(r"([A-Za-z0-9\-_\/]+)?/_edit", wiki.ActionEditHandler),
	313	(r"([A-Za-z0-9\-_\/]+)?/_render", wiki.ActionRenderHandler),
	314	(r"([A-Za-z0-9\-_\/]+)?/_(watch\|unwatch)", wiki.ActionWatchHandler),
	315	(r"/actions/restore", wiki.ActionRestoreHandler),
	316	(r"/actions/upload", wiki.ActionUploadHandler),
	317
	318	# Handlers
	319	(r"/recent\-changes", wiki.RecentChangesHandler),
	320	(r"/search", wiki.SearchHandler),
	321	(r"/watchlist", wiki.WatchlistHandler),
	322
	323	# Media
	324	(r"([A-Za-z0-9\-_\/]+)?/_files", wiki.FilesHandler),
	325	(r"((?!/static)(?:[A-Za-z0-9\-_\/]+)?(?:.*)\.(?:\w+))$", wiki.FileHandler),
	326
	327	# Render pages
	328	(r"([A-Za-z0-9\-_\/]+)?", wiki.PageHandler),
	329	])
	330
	331	# ipfire.org
	332	self.add_handlers(r"ipfire\.org", [
	333	(r".*", tornado.web.RedirectHandler, { "url" : "https://www.ipfire.org" })
	334	])
	335
	336	logging.info("Successfully initialied application")
	337
	338	def format_country_name(self, handler, country_code):
	339	return ipfire.countries.get_name(country_code)
	340
	341	def format_language_name(self, handler, language):
	342	_ = handler.locale.translate
	343
	344	if language == "de":
	345	return _("German")
	346	elif language == "en":
	347	return _("English")
	348	elif language == "es":
	349	return _("Spanish")
	350	elif language == "fr":
	351	return _("French")
	352	elif language == "it":
	353	return _("Italian")
	354	elif language == "nl":
	355	return _("Dutch")
	356	elif language == "pl":
	357	return _("Polish")
	358	elif language == "pt":
	359	return _("Portuguese")
	360	elif language == "ru":
	361	return _("Russian")
	362	elif language == "tr":
	363	return _("Turkish")
	364
	365	return language
	366
	367	def format_month_name(self, handler, month):
	368	_ = handler.locale.translate
	369
	370	if month == 1:
	371	return _("January")
	372	elif month == 2:
	373	return _("February")
	374	elif month == 3:
	375	return _("March")
	376	elif month == 4:
	377	return _("April")
	378	elif month == 5:
	379	return _("May")
	380	elif month == 6:
	381	return _("June")
	382	elif month == 7:
	383	return _("July")
	384	elif month == 8:
	385	return _("August")
	386	elif month == 9:
	387	return _("September")
	388	elif month == 10:
	389	return _("October")
	390	elif month == 11:
	391	return _("November")
	392	elif month == 12:
	393	return _("December")
	394
	395	return month
	396
	397	def format_phone_number(self, handler, number):
	398	if not isinstance(number, phonenumbers.PhoneNumber):
	399	try:
	400	number = phonenumbers.parse(number, None)
	401	except phonenumbers.phonenumberutil.NumberParseException:
	402	return number
	403
	404	return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
	405
	406	def format_phone_number_to_e164(self, handler, number):
	407	return phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
	408
	409	def format_phone_number_location(self, handler, number):
	410	s = [
	411	phonenumbers.geocoder.description_for_number(number, handler.locale.code),
	412	phonenumbers.region_code_for_number(number),
	413	]
	414
	415	return ", ".join((e for e in s if e))
	416
	417
	418	def grouper(handler, iterator, n):
	419	"""
	420	Returns groups of n from the iterator
	421	"""
	422	i = iter(iterator)
	423
	424	while True:
	425	ret = list(itertools.islice(i, 0, n))
	426	if not ret:
	427	break
	428
	429	yield ret