def _get_allowed_sender_options(cls, user):
sender_options = {
'user': {
'email': user.email,
'checked': False,
'enabled': user.is_email_activated(),
'reason': _("Email isn't activated"),
},
'system': {
'email': config.get('adhocracy.email.from'),
'checked': False,
'enabled': config.get_bool(
'allow_system_email_in_mass_messages'),
'reason': _("Not permitted in system settings"),
},
'support': {
'email': config.get('adhocracy.registration_support_email'),
'checked': False,
'enabled': (config.get('adhocracy.registration_support_email')
is not None),
'reason': _("adhocracy.registration_support_email not set"),
}
}
if sender_options['user']['enabled']:
sender_options['user']['checked'] = True
elif sender_options['system']['enabled']:
sender_options['system']['checked'] = True
return sender_options
def staticpages_api_address():
ret = instance_staticpages_api_address()
if ret == '':
ret = config.get('adhocracy_service.staticpages.rest_api_address')
if ret == '':
ret = config.get('adhocracy_service.rest_api_address')
return ret
def _get_allowed_sender_options(cls, user):
sender_options = {
'user': {
'email': user.email,
'checked': False,
'enabled': user.is_email_activated(),
'reason': _("Email isn't activated"),
},
'system': {
'email': config.get('adhocracy.email.from'),
'checked': False,
'enabled':
config.get_bool('allow_system_email_in_mass_messages'),
'reason': _("Not permitted in system settings"),
},
'support': {
'email':
config.get('adhocracy.registration_support_email'),
'checked':
False,
'enabled': (config.get('adhocracy.registration_support_email')
is not None),
'reason':
_("adhocracy.registration_support_email not set"),
}
}
if sender_options['user']['enabled']:
sender_options['user']['checked'] = True
elif sender_options['system']['enabled']:
sender_options['system']['checked'] = True
return sender_options
def staticpages_api_address():
ret = instance_staticpages_api_address()
if ret == '':
ret = config.get('adhocracy_service.staticpages.rest_api_address')
if ret == '':
ret = config.get('adhocracy_service.rest_api_address')
return ret
def index(self, format='html'):
if c.instance:
redirect(h.entity_url(c.instance))
if format == 'rss':
return EventController().all(format='rss')
name = config.get('adhocracy.redirect_startpage_to_instance')
if name != u'':
# get_entity_or_abort does no work for instances
instance = model.Instance.find(name)
if instance is not None:
redirect(h.entity_url(instance))
data = {}
instances_in_root = config.get_int(
'adhocracy.startpage.instances.list_length')
if instances_in_root > 0:
data['instances'] = model.Instance.all(limit=instances_in_root)
elif instances_in_root == -1:
data['instances'] = model.Instance.all()
add_static_content(data, u'adhocracy.static_index_path')
c.body_css_classes += data.get('css_classes', [])
c.body_css_classes.append('added_static_content')
if data['title'] is None:
data['title'] = config.get('adhocracy.site.name')
proposals_number = config.get_int(
'adhocracy.startpage.proposals.list_length')
if proposals_number > 0:
proposals = model.Proposal.all_q()\
.join(model.Instance).filter(not_(
model.Instance.key.in_(model.Instance.SPECIAL_KEYS)))\
.order_by(model.Proposal.create_time.desc())
data['new_proposals_pager'] = pager.proposals(
proposals, size=proposals_number,
default_sort=sorting.entity_newest,
enable_pages=False,
enable_sorts=False)
else:
data['new_proposals_pager'] = None
if config.get_bool('adhocracy.show_stats_on_frontpage'):
data['stats_global'] = {
"members": model.User.all_q().count(),
"comments": model.Comment.all_q().count(),
"proposals": model.Proposal.all_q().count(),
"votes": model.Vote.all_q().count(),
}
if format == 'overlay':
return render('index.html', data, overlay=True)
else:
return render('index.html', data)
def create_oauth(key=None, secret=None):
token = None
if key and secret:
token = oauth.OAuthToken(key, secret)
return OAuthApi(
consumer_key=config.get('adhocracy.twitter.consumer_key'),
consumer_secret=config.get('adhocracy.twitter.consumer_secret'),
access_token=token)
def create_oauth(key=None, secret=None):
token = None
if key and secret:
token = oauth.OAuthToken(key, secret)
return OAuthApi(consumer_key=config.get('adhocracy.twitter.consumer_key'),
consumer_secret=config.get(
'adhocracy.twitter.consumer_secret'),
access_token=token)
def test_is_local_url_subdomain(self):
from adhocracy.lib import helpers as h
from adhocracy import config
self.assert_(h.site.relative_urls() ^ h.site.is_local_url(
u'//subdomain.' + config.get(u'adhocracy.domain')))
self.assert_(not h.site.is_local_url(
u'//subsub.sub.' + config.get(u'adhocracy.domain')))
def __init__(self):
self.staticpages_api_token = config.get(
'adhocracy_service.staticpages.rest_api_token',
config.get('adhocracy_service.rest_api_token'))
self.staticpages_api_address = staticpages_api_address()
self.staticpages_verify = config.get_bool(
'adhocracy_service.staticpages.verify_ssl',
config.get_bool('adhocracy_service.verify_ssl'))
self.staticpages_headers = {"X-API-Token": self.staticpages_api_token}
def test_is_local_url_subdomain(self):
from adhocracy.lib import helpers as h
from adhocracy import config
self.assert_(h.site.relative_urls()
^ h.site.is_local_url(u'//subdomain.' +
config.get(u'adhocracy.domain')))
self.assert_(not h.site.is_local_url(u'//subsub.sub.' +
config.get(u'adhocracy.domain')))
def __init__(self):
self.staticpages_api_token = config.get(
'adhocracy_service.staticpages.rest_api_token',
config.get('adhocracy_service.rest_api_token'))
self.staticpages_api_address = staticpages_api_address()
self.staticpages_verify = config.get_bool(
'adhocracy_service.staticpages.verify_ssl',
config.get_bool('adhocracy_service.verify_ssl'))
self.staticpages_headers = {"X-API-Token": self.staticpages_api_token}
def get_captchasdotnet():
return CaptchasDotNet(
client=config.get('captchasdotnet.user_name'),
secret=config.get('captchasdotnet.secret'),
alphabet=config.get('captchasdotnet.alphabet'),
letters=config.get_int('captchasdotnet.letters'),
width=240,
height=80,
random_repository=config.get('captchasdotnet.random_repository'),
cleanup_time=3600)
def velruse_url(path):
return (
aconfig.get("velruse.protocol")
+ "://"
+ aconfig.get("velruse.domain")
+ ":"
+ aconfig.get("velruse.port")
+ "/velruse/"
+ path.strip("/")
)
def post_login_url(user):
from adhocracy.lib.helpers import base_url
url = config.get('adhocracy.post_login_url')
if url is None:
return base_url('/user/%s/dashboard' % user.user_name)
instance = config.get('adhocracy.post_login_instance')
if instance is None:
return base_url(url)
else:
return base_url(url, Instance.find(instance))
def post_logout_url():
from adhocracy.lib.helpers import base_url
url = config.get('adhocracy.post_logout_url')
if url is None:
return base_url()
instance = config.get('adhocracy.post_logout_instance')
if instance is None:
return base_url(url)
else:
return base_url(url, Instance.find(instance))
def get_captchasdotnet():
return CaptchasDotNet(
client=config.get('captchasdotnet.user_name'),
secret=config.get('captchasdotnet.secret'),
alphabet=config.get('captchasdotnet.alphabet'),
letters=config.get_int('captchasdotnet.letters'),
width=240,
height=80,
random_repository=config.get('captchasdotnet.random_repository'),
cleanup_time=3600
)
def post_login_url(user):
from adhocracy.lib.helpers import base_url
url = config.get('adhocracy.post_login_url')
if url is None:
return base_url('/user/%s/dashboard' % user.user_name)
instance = config.get('adhocracy.post_login_instance')
if instance is None:
return base_url(url)
else:
return base_url(url, Instance.find(instance))
def get_captcha_type():
captcha_type = config.get('adhocracy.captcha_type')
if ((captcha_type == 'captchasdotnet'
and config.get('captchasdotnet.user_name')
and config.get('captchasdotnet.secret')) or
(captcha_type == 'recaptcha' and config.get('recaptcha.public_key')
and config.get('recaptcha.private_key'))):
return captcha_type
else:
return None
def make_key(iden, args, kwargs):
instance = args[0].instance
instance_w = instance and instance.thumbnailbadges_width or ""
instance_h = instance and instance.thumbnailbadges_height or ""
sig = iden[:200]\
+ cache.util.make_tag(config.get("adhocracy.thumbnailbadges.width"))\
+ cache.util.make_tag(config.get("adhocracy.thumbnailbadges.height"))\
+ cache.util.make_tag(instance_w)\
+ cache.util.make_tag(instance_h)\
+ cache.util.make_tag(args) \
+ cache.util.make_tag(kwargs)
return sha1(sig).hexdigest()
def make_key(iden, args, kwargs):
instance = args[0].instance
instance_w = instance and instance.thumbnailbadges_width or ""
instance_h = instance and instance.thumbnailbadges_height or ""
sig = iden[:200]\
+ cache.util.make_tag(config.get("adhocracy.thumbnailbadges.width"))\
+ cache.util.make_tag(config.get("adhocracy.thumbnailbadges.height"))\
+ cache.util.make_tag(instance_w)\
+ cache.util.make_tag(instance_h)\
+ cache.util.make_tag(args) \
+ cache.util.make_tag(kwargs)
return sha1(sig).hexdigest()
def get_captcha_type():
captcha_type = config.get('adhocracy.captcha_type')
if ((captcha_type == 'captchasdotnet'
and config.get('captchasdotnet.user_name')
and config.get('captchasdotnet.secret'))
or
(captcha_type == 'recaptcha'
and config.get('recaptcha.public_key')
and config.get('recaptcha.private_key'))):
return captcha_type
else:
return None
def __init__(self, app, config):
self.app = app
dsn = aconfig.get('adhocracy.sentry.dsn', config=config)
if not dsn:
raise Exception(
'Sentry misconfigured. Please add adhocracy.sentry.dsn '
'to your adhocracy config.')
self.client = Client(dsn)
handler = SentryHandler(
self.client, level=aconfig.get('adhocracy.sentry.loglevel'))
setup_logging(handler)
def test_is_local_url_domain(self):
from adhocracy.lib import helpers as h
from adhocracy import config
self.assert_(
h.site.is_local_url('//' + config.get(u'adhocracy.domain')))
self.assert_(not h.site.is_local_url('http://evil.com'))
def get_session(self):
ses = session.get(SESSION_KEY, {})
if ses and config.get("adhocracy.session.implementation") == "cookie":
import pickle
ses = pickle.loads(ses)
return ses
def _export(self, o):
res = {}
if self._opt_personal:
res.update(
{
"id": o.id,
"user_name": o.user_name,
"display_name": o.display_name,
"bio": o.bio,
"email": o.email,
"gender": o.gender,
"locale": encode_locale(o.locale),
}
)
if config.get("adhocracy.user.optional_attributes"):
res["optional_attributes"] = o.optional_attributes
if self._opt_password:
res.update(
{
"adhocracy_activation_code": o.activation_code,
"adhocracy_reset_code": o.reset_code,
"adhocracy_password": o.password,
"adhocracy_banned": o.banned,
"adhocracy_welcome_code": o.welcome_code,
}
)
if self._opt_badges:
res["badges"] = [getattr(b, BadgeTransform._ID_KEY) for b in o.badges]
return res
def show(self, id, format=u'html'):
if not c.instance.display_category_pages:
abort(404)
require.proposal.index()
query = self.form_result.get('proposals_q')
category = get_entity_or_abort(model.CategoryBadge, id)
pages = model.Page.all_q(instance=c.instance,
functions=model.Page.LISTED) \
.join(model.DelegateableBadges) \
.filter(model.DelegateableBadges.badge_id == category.id) \
.all()
pages = filter(lambda p: p.parent is None, pages)
pages_pager = pager.NamedPager('pages',
pages,
tiles.page.smallrow,
enable_pages=False,
enable_sorts=False)
default_sorting = config.get(
'adhocracy.listings.instance_proposal.sorting')
proposals_pager = pager.solr_proposal_pager(
c.instance, {'text': query},
default_sorting=default_sorting,
extra_filter={'facet.delegateable.badgecategory': category.id})
data = {
'category': category,
'pages_pager': pages_pager,
'proposals_pager': proposals_pager,
}
return render('/category/show.html',
data,
overlay=format == u'overlay')
def create(cls, key, label, user, description=None, locale=None):
from group import Group
from membership import Membership
from page import Page
instance = Instance(unicode(key).lower(), label, user)
instance.description = description
instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT)
if locale is not None:
instance.locale = locale
meta.Session.add(instance)
supervisor_group = Group.by_code(Group.CODE_SUPERVISOR)
membership = Membership(user, instance, supervisor_group,
approved=True)
meta.Session.add(membership)
if config.get_bool('adhocracy.create_initial_instance_page'):
Page.create(instance, label, u"", user)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if (config_autojoin and
(config_autojoin == 'ALL' or
key in (k.strip() for k in config_autojoin.split(',')))):
users = adhocracy.model.User.all()
for u in users:
autojoin_membership = Membership(u, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
meta.Session.flush()
return instance
def user_language(user, fallbacks=[]):
# find out the locale
locale = None
if user and user.locale:
locale = user.locale
if locale is None:
locale = Locale.parse(Locale.negotiate(fallbacks, LOCALE_STRINGS_DASH,
sep='-',
aliases=A2_LOCALE_ALIASES)) \
or get_default_locale()
# determinate from which path we load the translations
translations_config = {
'pylons.paths': {
'root': _get_translations_root()
},
'pylons.package': config.get('pylons.package')
}
# set language and fallback
set_lang(str(locale), pylons_config=translations_config)
add_fallback(str(get_default_locale()), pylons_config=translations_config)
formencode.api.set_stdtranslation(domain="FormEncode",
languages=[locale.language])
return locale
def _export(self, o):
res = {}
if self._opt_personal:
res.update({
'id': o.id,
'user_name': o.user_name,
'display_name': o.display_name,
'bio': o.bio,
'email': o.email,
'gender': o.gender,
'locale': encode_locale(o.locale),
})
if config.get('adhocracy.user.optional_attributes'):
res['optional_attributes'] = o.optional_attributes
if self._opt_password:
res.update({
'adhocracy_activation_code': o.activation_code,
'adhocracy_reset_code': o.reset_code,
'adhocracy_password': o.password,
'adhocracy_banned': o.banned,
'adhocracy_welcome_code': o.welcome_code,
})
if self._opt_badges:
res['badges'] = [getattr(b, BadgeTransform._ID_KEY)
for b in o.badges]
return res
def create(cls, user_name, email, password=None, locale=None,
openid_identity=None, global_admin=False, display_name=None,
autojoin=True, shibboleth_persistent_id=None):
"""
Create a user. If user_name is None, a random user name is generated.
"""
from group import Group
from membership import Membership
import adhocracy.lib.util as util
if password is None:
password = util.random_token()
import adhocracy.i18n as i18n
if locale is None:
locale = i18n.get_default_locale()
while user_name is None:
# Note: This can theoretically lead to IntegrityErrors if the same
# username is generated at the same time. This is very unlikely
# though.
from adhocracy.lib.util import random_username
try_user_name = random_username()
if cls.find(try_user_name) is None:
user_name = try_user_name
from adhocracy.lib import helpers as h
h.flash(_('The random username %s has been assigned to you.') %
user_name, 'success')
user = User(user_name, email, password, locale,
display_name=display_name)
meta.Session.add(user)
# Add the global default group
default_group = Group.by_code(Group.CODE_DEFAULT)
default_membership = Membership(user, None, default_group)
meta.Session.add(default_membership)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if autojoin and config_autojoin:
user.fix_autojoin(commit=False)
if global_admin:
admin_group = Group.by_code(Group.CODE_ADMIN)
admin_membership = Membership(user, None, admin_group)
meta.Session.add(admin_membership)
if openid_identity is not None:
from adhocracy.model.openid import OpenID
openid = OpenID(unicode(openid_identity), user)
meta.Session.add(openid)
if shibboleth_persistent_id is not None:
from adhocracy.model.shibboleth import Shibboleth
shib = Shibboleth(shibboleth_persistent_id, user)
meta.Session.add(shib)
meta.Session.flush()
return user
def create(cls, key, label, user, description=None, locale=None):
from group import Group
from membership import Membership
from page import Page
instance = Instance(unicode(key).lower(), label, user)
instance.description = description
instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT)
if locale is not None:
instance.locale = locale
meta.Session.add(instance)
supervisor_group = Group.by_code(Group.CODE_SUPERVISOR)
membership = Membership(user, instance, supervisor_group,
approved=True)
meta.Session.add(membership)
if config.get_bool('adhocracy.create_initial_instance_page'):
Page.create(instance, label, u"", user)
# Autojoin the user in instances
config_autojoin = config.get('adhocracy.instances.autojoin')
if (config_autojoin and
(config_autojoin == 'ALL' or
key in (k.strip() for k in config_autojoin.split(',')))):
users = adhocracy.model.User.all()
for u in users:
autojoin_membership = Membership(u, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
meta.Session.flush()
return instance
def show(self, id, format=u'html'):
if not c.instance.display_category_pages:
abort(404)
require.proposal.index()
query = self.form_result.get('proposals_q')
category = get_entity_or_abort(model.CategoryBadge, id)
pages = model.Page.all_q(instance=c.instance,
functions=model.Page.LISTED) \
.join(model.DelegateableBadges) \
.filter(model.DelegateableBadges.badge_id == category.id) \
.all()
pages = filter(lambda p: p.parent is None, pages)
pages_pager = pager.NamedPager('pages', pages, tiles.page.smallrow,
enable_pages=False, enable_sorts=False)
default_sorting = config.get(
'adhocracy.listings.instance_proposal.sorting')
proposals_pager = pager.solr_proposal_pager(
c.instance,
{'text': query},
default_sorting=default_sorting,
extra_filter={'facet.delegateable.badgecategory': category.id})
data = {
'category': category,
'pages_pager': pages_pager,
'proposals_pager': proposals_pager,
}
return render('/category/show.html', data,
overlay=format == u'overlay')
def test_is_local_url_domain(self):
from adhocracy.lib import helpers as h
from adhocracy import config
self.assert_(h.site.is_local_url(
'//' + config.get(u'adhocracy.domain')))
self.assert_(not h.site.is_local_url('http://evil.com'))
def get_default_locale():
try:
if c.instance and c.instance.locale:
return c.instance.locale
locale = config.get('adhocracy.language')
return babel.Locale.parse(locale)
except TypeError:
return babel.Locale.parse('en_US')
def create_store():
log.debug("Creating SQL-based OpenID store...")
conn_str = config.get('sqlalchemy.url')
if conn_str is None:
raise ValueError("OpenID connection")
db_type = conn_str.split(':')[0]
store_cls = SQL_STORES.get(db_type)
return store_cls(meta.engine.raw_connection())
def get_default_locale():
try:
if c.instance and c.instance.locale:
return c.instance.locale
locale = config.get('adhocracy.language')
return babel.Locale.parse(locale)
except TypeError:
return babel.Locale.parse('en_US')
def email_subject(message, recipient, _format=None):
if _format is None:
_format = _(u"[{site_name}] Message from {sender_name}: {subject}")
return _format.format(**{
'subject': message.subject,
'sender_name': message.creator.name,
'site_name': config.get('adhocracy.site.name'),
})
def shorten_url(url):
try:
query = urlencode({
'login': config.get('adhocracy.bitly.login',
DEFAULT_SHORTENER_USER),
'apiKey': config.get('adhocracy.bitly.key',
DEFAULT_SHORTENER_KEY),
'longUrl': url.encode('utf-8'),
'format': 'json',
'version': '2.0.1'})
request_url = SHORTENER_URL + "?" + str(query)
data = json.loads(urlopen(request_url).read())
if not data['statusCode'] == 'OK':
return url
return data['results'][url]['shortUrl']
except:
return url
def create_store():
log.debug("Creating SQL-based OpenID store...")
conn_str = config.get('sqlalchemy.url')
if conn_str is None:
raise ValueError("OpenID connection")
db_type = conn_str.split(':')[0]
store_cls = SQL_STORES.get(db_type)
return store_cls(meta.engine.raw_connection())
def new(self, format=u'html'):
data = {}
protocol = config.get('adhocracy.protocol').strip()
domain = config.get('adhocracy.domain').strip()
if config.get_bool('adhocracy.relative_urls'):
data['url_pre'] = '%s://%s/i/' % (protocol, domain)
data['url_post'] = ''
data['url_right_align'] = False
else:
data['url_pre'] = '%s://' % protocol
data['url_post'] = '.%s' % domain
data['url_right_align'] = True
return render("/instance/new.html", data,
overlay=format == u'overlay')
def to_mail(to_name,
to_email,
subject,
body,
headers={},
decorate_body=True,
email_from=None,
reply_to=None,
name_from=None):
try:
if email_from is None:
email_from = config.get('adhocracy.email.from')
if name_from is None:
name_from = config.get('adhocracy.site.name')
if decorate_body:
body = (
_(u"Hi %s,") % to_name + u"\r\n\r\n%s\r\n\r\n" % body +
_(u"Cheers,\r\n\r\n"
u" the %s Team\r\n") % config.get('adhocracy.site.name'))
# wrap body, but leave long words (e.g. links) intact
body = u'\n'.join(
textwrap.fill(line, break_long_words=False, break_on_hyphens=False)
for line in body.split(u'\n'))
msg = MIMEText(body.encode(ENCODING), 'plain', ENCODING)
for k, v in headers.items():
msg[k] = v
subject = Header(subject.encode(ENCODING), ENCODING)
msg['Subject'] = subject
msg['From'] = _("%s <%s>") % (name_from, email_from)
to = Header(u"%s <%s>" % (to_name, to_email), ENCODING)
msg['To'] = to
if reply_to is not None:
msg['Reply-To'] = reply_to
msg['']
msg['Date'] = email.Utils.formatdate(time())
msg['X-Mailer'] = "Adhocracy SMTP %s" % version.get_version()
# log.debug("MAIL\r\n" + msg.as_string())
send(email_from, to_email, msg.as_string())
except Exception:
log.exception("Sending mail failed.")
def email_subject(message, recipient, _format=None):
if _format is None:
_format = _(u"[{site_name}] Message from {sender_name}: {subject}")
return _format.format(
**{
'subject': message.subject,
'sender_name': message.creator.name,
'site_name': config.get('adhocracy.site.name'),
})
def render_external_navigation(current_key):
if not use_external_navigation():
return None
api = RESTAPI()
base = config.get('adhocracy.external_navigation_base')
try:
result = api.staticpages_get(base=base)
except ConnectionError as e:
log.error('Error while connecting to static pages backend: %s' % e)
return None
if not result.ok:
log.error('Error while fetching static pages: %s %s'
% (result.status_code, result.reason))
return None
try:
nav = result.json()
except JSONDecodeError as e:
log.error('Error while decoding static pages: %s' % e)
return None
instance = c.instance if instance_staticpages_api_address() else None
if nav is None or not nav.get('children'):
log.error('External navigation not found for configured languages')
return None
def render_navigation_item(item, path='', toplevel=False):
from adhocracy.lib.templating import render_def
if path != '':
path = '%s/%s' % (path, item['name'])
else:
path = item['name']
url = _url.build(instance, 'static', path, format='html')
contains_current = (path == current_key)
if item['children']:
children, contained_list = izip(
*map(lambda child: render_navigation_item(child, path),
item['children']))
contains_current = contains_current or any(contained_list)
else:
children = []
html = render_def('static/tiles.html', 'navigation_item',
href=url,
title=item['title'],
current=toplevel and contains_current,
children=children)
return (html, contains_current)
html_list, _ = izip(
*map(lambda child: render_navigation_item(child, toplevel=True),
nav['children']))
return '\n'.join(html_list)
def _get_translations_root():
translations_module = config.get('adhocracy.translations')
translations_module_loader = pkgutil.get_loader(translations_module)
if translations_module_loader is None:
raise ValueError(('Cannot import the module "%s" configured for '
'"adhocracy.translations". Make sure it is an '
'importable module (and contains the '
'translation files in a subdirectory '
'"i18n"') % translations_module)
return translations_module_loader.filename
def _get_translations_root():
translations_module = config.get('adhocracy.translations')
translations_module_loader = pkgutil.get_loader(translations_module)
if translations_module_loader is None:
raise ValueError(('Cannot import the module "%s" configured for '
'"adhocracy.translations". Make sure it is an '
'importable module (and contains the '
'translation files in a subdirectory '
'"i18n"') % translations_module)
return translations_module_loader.filename
def render_footer_column(instance, column):
if not config.get_bool('adhocracy.customize_footer'):
return None
path = u'footer_' + unicode(column)
if instance and\
instance.key in config.get('adhocracy.instance_footers'):
path = u'%s_%s' % (path, instance.key)
page = staticpage.get_static_page(path)
if page is None:
return None
else:
return page.body
def shorten_url(url):
try:
query = urlencode({
'login':
config.get('adhocracy.bitly.login', DEFAULT_SHORTENER_USER),
'apiKey':
config.get('adhocracy.bitly.key', DEFAULT_SHORTENER_KEY),
'longUrl':
url.encode('utf-8'),
'format':
'json',
'version':
'2.0.1'
})
request_url = SHORTENER_URL + "?" + str(query)
data = json.loads(urlopen(request_url).read())
if not data['statusCode'] == 'OK':
return url
return data['results'][url]['shortUrl']
except:
return url
def to_mail(
to_name, to_email, subject, body, headers={}, decorate_body=True, email_from=None, reply_to=None, name_from=None
):
try:
if email_from is None:
email_from = config.get("adhocracy.email.from")
if name_from is None:
name_from = config.get("adhocracy.site.name")
if decorate_body:
body = (
_(u"Hi %s,") % to_name
+ u"\r\n\r\n%s\r\n\r\n" % body
+ _(u"Cheers,\r\n\r\n" u" the %s Team\r\n") % config.get("adhocracy.site.name")
)
# wrap body, but leave long words (e.g. links) intact
body = u"\n".join(
textwrap.fill(line, break_long_words=False, break_on_hyphens=False) for line in body.split(u"\n")
)
msg = MIMEText(body.encode(ENCODING), "plain", ENCODING)
for k, v in headers.items():
msg[k] = v
subject = Header(subject.encode(ENCODING), ENCODING)
msg["Subject"] = subject
msg["From"] = _("%s <%s>") % (name_from, email_from)
to = Header(u"%s <%s>" % (to_name, to_email), ENCODING)
msg["To"] = to
if reply_to is not None:
msg["Reply-To"] = reply_to
msg[""]
msg["Date"] = email.Utils.formatdate(time())
msg["X-Mailer"] = "Adhocracy SMTP %s" % version.get_version()
# log.debug("MAIL\r\n" + msg.as_string())
send(email_from, to_email, msg.as_string())
except Exception:
log.exception("Sending mail failed.")
def add_static_content(data, config_key, title_key=u"title", body_key=u"body", css_classes_key=u"css_classes"):
static_path = config.get(config_key)
if static_path is not None:
page = get_static_page(static_path)
if page is None:
data[title_key] = data[body_key] = None
else:
data[title_key] = page.title
data[body_key] = render_body(page.body)
data[css_classes_key] = page.css_classes
else:
data[title_key] = data[body_key] = None
def oembed(self, format=u'json'):
if 'url' not in request.params:
return ret_abort(u"Required parameter 'url' is missing", code=400)
u = urlparse.urlparse(request.params.get('url'))
# validate input url
if (u.scheme != config.get('adhocracy.protocol')
or u.netloc != config.get('adhocracy.domain')):
return ret_abort(u"URL not supported", code=404)
# set format to overlay
path = re.sub('(\.[^./]*)?$', '.overlay', u.path)
new_url = urlparse.ParseResult(u.scheme, u.netloc, path,
u.params, u.query, u.fragment)
new_url = urlparse.urlunparse(new_url)
width = min(640, int(request.params.get('maxwidth', 640)))
height = int(request.params.get('maxheight', 750))
html = ('<iframe src="%s" width="%i "height="%i"'
' frameborder="0"></iframe>' % (new_url, width, height))
data = {
'type': 'rich',
'version': '1.0',
'width': width,
'height': height,
'html': html,
'provider_name': config.get('adhocracy.site.name'),
'provider_url': h.base_url(instance=None, absolute=True),
}
if format == u'json':
return render_json(data)
else:
ret_abort(u"The format parameter must be one of: {json}.",
code=501)
def oembed(self, format=u'json'):
if 'url' not in request.params:
return ret_abort(u"Required parameter 'url' is missing", code=400)
u = urlparse.urlparse(request.params.get('url'))
# validate input url
if (u.scheme != config.get('adhocracy.protocol')
or u.netloc != config.get('adhocracy.domain')):
return ret_abort(u"URL not supported", code=404)
# set format to overlay
path = re.sub('(\.[^./]*)?$', '.overlay', u.path)
new_url = urlparse.ParseResult(u.scheme, u.netloc, path, u.params,
u.query, u.fragment)
new_url = urlparse.urlunparse(new_url)
width = min(640, int(request.params.get('maxwidth', 640)))
height = int(request.params.get('maxheight', 750))
html = ('<iframe src="%s" width="%i "height="%i"'
' frameborder="0"></iframe>' % (new_url, width, height))
data = {
'type': 'rich',
'version': '1.0',
'width': width,
'height': height,
'html': html,
'provider_name': config.get('adhocracy.site.name'),
'provider_url': h.base_url(instance=None, absolute=True),
}
if format == u'json':
return render_json(data)
else:
ret_abort(u"The format parameter must be one of: {json}.",
code=501)
def local_datetime(dt):
"""
Calculates a datetime object with the configured timezone information set
from a given datetime ``dt``.
"""
tz_setting = config.get('adhocracy.timezone', FALLBACK_TZ)
try:
tz = pytz.timezone(tz_setting)
except pytz.UnknownTimeZoneError:
log.warn('Invalid time zone setting: %s' % tz_setting)
tz = pytz.timezone(FALLBACK_TZ)
if dt.tzinfo is None:
return tz.fromutc(dt)
else:
return dt.astimezone(tz)
def local_datetime(dt):
"""
Calculates a datetime object with the configured timezone information set
from a given datetime ``dt``.
"""
tz_setting = config.get('adhocracy.timezone', FALLBACK_TZ)
try:
tz = pytz.timezone(tz_setting)
except pytz.UnknownTimeZoneError:
log.warn('Invalid time zone setting: %s' % tz_setting)
tz = pytz.timezone(FALLBACK_TZ)
if dt.tzinfo is None:
return tz.fromutc(dt)
else:
return dt.astimezone(tz)
def fix_autojoin(self):
config_autojoin = config.get('adhocracy.instances.autojoin')
if not config_autojoin:
return ret_abort('autojoin is not enabled')
users = model.User.all()
added = 0
for user in users:
added += user.fix_autojoin(commit=False)
if added > 0:
model.meta.Session.commit()
flash(
_('Autojoin fixed - added %s memberships.') % added, 'success')
else:
flash(_('No need to fix autojoin.'), 'success')
return redirect(base_url('/admin'))
def _register(self, persistent_id):
# initializing user data dict
user_data = {}
user_data['email'] = get_attribute(request, 'shib-email', None)
if config.get_bool('adhocracy.force_randomized_user_names'):
user_data['username'] = None
else:
user_data['username'] = get_attribute(request, 'shib-username')
user_data['display_name'] = self._get_display_name()
locale_attribute = config.get("adhocracy.shibboleth.locale.attribute")
if locale_attribute is not None:
user_data['locale'] = get_attribute(request, locale_attribute)
# what to do
if request.method == 'GET':
if config.get_bool('adhocracy.shibboleth.register_form'):
# render a form for missing uaser data
return self._register_form(defaults=user_data)
else:
# register_form is False -> user data should be complete
return self._create_user_and_login(persistent_id, **user_data)
else: # POST
check_csrf()
try:
form_result = ShibbolethRegisterForm().to_python(request.POST)
user_data['username'] = form_result.get(
'username', user_data['username'])
user_data['display_name'] = form_result.get(
'display_name', user_data['display_name'])
user_data['email'] = form_result.get('email',
user_data['email'])
return self._create_user_and_login(persistent_id, **user_data)
except formencode.Invalid, i:
return self._register_form(errors=i.unpack_errors())
def twitter_sink(pipeline):
twitter_enabled = bool(config.get('adhocracy.twitter.username', ''))
for notification in pipeline:
user = notification.user
if (twitter_enabled and user.twitter
and notification.priority >= user.twitter.priority):
notification.language_context()
short_url = microblog.shorten_url(notification.link)
remaining_length = TWITTER_LENGTH - \
(1 + len(short_url) + len(TRUNCATE_EXT))
tweet = text.truncate(notification.subject, remaining_length,
TRUNCATE_EXT, False)
tweet += ' ' + short_url
log.debug("twitter DM to %s: %s" %
(user.twitter.screen_name, tweet))
api = microblog.create_default()
api.PostDirectMessage(user.twitter.screen_name, tweet)
else:
yield notification
def fix_autojoin(self, commit=True):
from membership import Membership
config_autojoin = config.get('adhocracy.instances.autojoin')
if config_autojoin == 'ALL':
instances = Instance.all(include_hidden=True)
else:
instance_keys = [key.strip() for key in config_autojoin.split(",")]
instances = meta.Session.query(Instance)\
.filter(Instance.key.in_(instance_keys)).all()
to_join = set(instances)
added = 0
for m in self.memberships:
to_join.discard(m.instance)
for instance in to_join:
autojoin_membership = Membership(self, instance,
instance.default_group)
meta.Session.add(autojoin_membership)
added += 1
if commit:
meta.Session.commit()
return added
