def __init__(self, request):
self.request = request
self.session = self.request.db_session
self.request.template_helper.rendering_type = 'static'
self.request.template_helper.section = 'admin'
self.log = logging.getLogger("%s.%s" % ( self.__class__.__module__,
self.__class__.__name__))
self.log.debug("handle request for %s", request.path_info)
lang = request.params.get('lang')
country = request.params.get('country')
if bool(lang) ^ bool(country):
# either the request contains no lang options or both.
# if the request contains only one of the two, it's a bad request
raise HTTPBadRequest()
elif lang:
self.log.debug('Setting language to %s', lang)
request.language = Language.get_by_lang(request.db_session, lang)
def get_negotiated_language(request):
""" This function returns a Language from database that
best matches one of those requested by the client.
If a match cannot be found, it simply returns the first
language available
"""
# Get all the registered and enabled languages of the system.
available = [str(locale)
for locale in Language.get_locales(request.db_session,
enabled=True)]
# Get client preferred languages.
preferred = [str(locale) for locale in request.accepted_locales]
# Choose the best one.
negotiated = Locale.negotiate(preferred, available)
if negotiated is None:
lang = available[0][:2]
else:
lang = negotiated.language
return Language.get_by_lang(request.db_session, lang)
def test_get_by_lang(self):
languages = [
Language(id=1, lang=u'it', country=u'IT', enabled=True),
Language(id=2, lang=u'it', country=u'CH', enabled=False)]
for language in languages:
self.session.add(language)
self.session.commit()
self.assertIn(Language.get_by_lang(self.session, u'it'), languages)
self.assertIn(Language.get_by_lang(self.session, u'IT'), languages)
self.assertIn(Language.get_by_lang(self.session, u'It'), languages)
self.assertIn(Language.get_by_lang(self.session, u'iT'), languages)
self.session.add(Language(id=3, lang=u'en', country=u'GB',
enabled=True))
self.session.commit()
self.assertNotIn(Language.get_by_lang(self.session, u'en'), languages)
self.assertNotIn(Language.get_by_lang(self.session, u'EN'), languages)
self.assertNotIn(Language.get_by_lang(self.session, u'En'), languages)
self.assertNotIn(Language.get_by_lang(self.session, u'eN'), languages)
def enable(self):
"""
Enable the language identified by 'lang_id'.
"""
try:
def_lang = self.request.registry.settings['default_locale_name']
def_lang = Language.get_by_lang(self.session, def_lang)
language = Language.enable(self.session,
int(self.request.params['lang_id']),
def_lang.id)
self.session.flush()
except QuotaError as e:
self.log.exception(e)
self.session.rollback()
success = False
msg = self.request.translate(
'Hai raggiunto il numero massimo di lingue acquistate.')
except Exception as e:
self.log.exception('Cannot enable requested language: %s', e)
self.session.rollback()
success = False
msg=self.request.translate(
u"Errore durante la procedura di aggiunta della lingua.")
else:
self.log.debug('Enabled: %s', language)
self.session.commit()
name = language.locale.get_display_name().title()
success = True
msg = self.request.translate(
u'Lingua %s aggiunta con successo.' % name)
self.proxy.invalidate(language=language)
finally:
return dict(success=success, msg=msg)
def get_root_resource(request):
path_info = request.path_info
log.debug('get_root_resource: %s', path_info)
# Getting url_parts and for each part associating a Resource
# On request.path_info applying strip('/') remove the initial / so
# with the following split('/') we obtain a list just with parts
url_parts = [UrlPart(part=url_part, resource=Resource())
for url_part in path_info.strip('/').split('/')
if url_part]
log.debug('url_parts: %s', url_parts)
if not url_parts:
# URL is '/'.
log.debug('Return NoLanguage context.')
return NoLanguage()
need_auth = False
if url_parts[0].part == 'admin':
log.debug("Admin Panel Request: removing admin.")
url_parts = url_parts[1:]
path_info = path_info.replace('/admin', '')
need_auth = True
language = Language.get_by_lang(request.db_session, url_parts[0].part)
if language is None:
# language not found, return a 404
log.debug("No language found.")
raise HTTPNotFound()
else:
request.language = language
if len(url_parts) == 1:
# URL is like '/{lang}'.
log.debug('Get Context by Language %s.', url_parts[0].part)
url_parts[0] = UrlPart(part=url_parts[0].part,
resource=request.language)
else:
# URL is like '/{lang}/{node}/[...]/{page}[.ext]
# Get the NodeInfo from database using path_info.
log.debug('Get Context by NodeInfo %s.', path_info)
try:
# Remove '.ext' from the url.
url_parts[-1] = url_parts[-1].part
resource = PageInfo.get_by_url(request.db_session,
path_info.rsplit('.', 1)[0])
url_parts[-1] = UrlPart(part=url_parts[-1], resource=resource)
except NoResultFound:
raise HTTPNotFound()
else:
log.debug('Found: %s', url_parts[-1])
log.debug('UrlParts: %s', url_parts)
# Create the resources tree.
# The last element in resources tree is the request context.
tmp = root = Resource()
parent = None
acl = [(Allow, Everyone, ALL_PERMISSIONS)]
if need_auth:
acl = Authenticated.__acl__
for url_part, resource in url_parts:
log.debug('Urlpart: %s, Resource: %s', url_part, resource)
resource.__parent__ = parent
resource.__acl__ = acl
parent = resource
tmp[url_part] = resource
tmp = tmp[url_part]
log.debug("Resource: %s, acl: %s, parent: %s",
resource, resource.__acl__, resource.__parent__)
log.debug(root)
return root
def handle_contact_form(request):
log.debug("Building contacts form")
result = dict(
vars={},
error={},
success=True,
message=u"Grazie per averci contattato. Le risponderemo al più presto."
)
form_keys = ('name', 'surname', 'email', 'phone', 'agreement', 'message')
log.debug("Form has been submitted, validating fields")
res = validate_name('name', request.params.get('name', '').title())
result['success'] = res['success']
result['error'].update(res['error'])
res = validate_name('surname', request.params.get('surname', '').title())
result['success'] = res['success']
result['error'].update(res['error'])
response_field = request.params.get('recaptcha_response_field', '')
challenge_field = request.params.get('recaptcha_challenge_field', '')
res = validate_captcha(response_field, challenge_field, request.remote_addr)
result['success'] = res['success']
result['error'].update(res['error'])
if not email_re.match(request.params.get('email','')):
result['error']['email'] = u"Inserisci un indirizzo email valido."
result['success'] = False
if not phone_re.match(request.params.get('phone', '')):
result['error']['phone'] = u"Inserisci un numero di telefono valido."
result['success'] = False
if len(request.params.get('message', '')) < 10:
result['error']['message'] = u"Inserisci almeno 10 caratteri."
result['success'] = False
if not request.params.get('agreement', '') == 'on':
result['error']['agreement'] = u"Devi accettare i termini di Privacy"
result['success'] = False
recipients = request.db_session.query(Setting)\
.filter(Setting.name.like(u'contact_dst_email_%')).all()
log.debug("Recipients: %s", recipients)
if len(recipients) > 0:
# FIXME: use a template!
body = u"Nome : %s \n" % (request.params.get('name'))
body = u"%sCognome : %s \n" % (body, request.params.get('surname'))
body = u"%sTelefono : %s \n\n" % (body, request.params.get('phone'))
# add additional post data in the message body
for key, value in request.params.iteritems():
if key not in form_keys and not key.startswith("recaptcha") and\
not key == '_lang':
p = key.decode('utf8')
body = u"%s%s : %s \n" % (body, p.title(), value)
result['vars'][key] = value
body = u"%sMessaggio : \n%s\n" % (body, request.params.get('message'))
subject = u'[%s] Nuovo messaggio dal form di contatto' % (request.host)
message = Message(subject=subject,
sender=request.params.get('email'),
body=body,
recipients=[r.value for r in recipients[0:1]],
cc=[r.value for r in recipients[1:]])
if result['success']:
log.debug('Form is valid, sending emails')
try:
mailer = get_mailer(request)
mailer.send_immediately(message, fail_silently=False)
except:
log.exception("Errore nell'invio del messaggio. \n")
result['message'] = \
u"Errore nell'invio del messaggio. " + \
u"Si prega di riprovare più tardi."
result['success'] = False
else:
result['message'] = u"Errore nell'invio del form. " +\
u"Ricontrollare i campi e riprovare."
# get lang to translate messages
def_lang = request.registry.settings.get('default_locale_name', 'it')
lang = request.params.get('_lang', def_lang)
try:
request.language = Language.get_by_lang(request.db_session, lang)
except:
request.language = Language.get_by_lang(request.db_session, def_lang)
# translate error message
for err in result['error']:
result['error'][err] = request.translate(result['error'][err])
log.debug("Result: %s", result)
return result
