def test_get_by_enabled(self):
languages = [
Language(id=1, lang=u'it', country=u'IT', enabled=True),
Language(id=2, lang=u'en', country=u'GB', enabled=True),
Language(id=3, lang=u'es', country=u'ES', enabled=True),
Language(id=4, lang=u'de', country=u'DE', enabled=False),
Language(id=5, lang=u'fr', country=u'FR', enabled=False),
Language(id=6, lang=u'ru', country=u'RU', enabled=False),
Language(id=7, lang=u'zh', country=u'CN', enabled=False)]
for language in languages:
self.session.add(language)
self.session.commit()
enabled = Language.get_by_enabled(self.session, True)
disabled = Language.get_by_enabled(self.session, False)
all = Language.get_by_enabled(self.session)
for i in xrange(0, 3):
self.assertIn(languages[i], enabled)
self.assertIn(languages[i], all)
self.assertNotIn(languages[i], disabled)
for i in xrange(3, 7):
self.assertIn(languages[i], disabled)
self.assertIn(languages[i], all)
self.assertNotIn(languages[i], enabled)
def test_create_translations(self):
self.populate(self.session)
en = self.session.query(Language).filter(Language.lang == 'en').one()
it = self.session.query(Language).filter(Language.lang == 'it').one()
q = self.session.query(PageInfo).filter(PageInfo.lang == en)
self.assertNotEqual(q.all(), [])
Language.disable(self.session, 2)
self.assertEqual(q.all(), [])
Language.enable(self.session, 2, 1)
translations = q.all()
self.assertNotEqual(translations, [])
self.assertEqual(set([t.lang for t in translations]), set([en]))
def test_str_and_repr(self):
language = Language(lang=u'it', country=u'it')
self.session.add(language)
self.session.flush()
self.assertEqual(str(language), '<Language it_IT [enabled]>')
language.enabled = True
self.session.flush()
self.assertEqual(str(language), '<Language it_IT [enabled]>')
language.enabled = False
self.session.flush()
self.assertEqual(str(language), '<Language it_IT [disabled]>')
def test_enable(self):
self.populate(self.session)
language = self.session.query(Language).\
filter(Language.lang==u'en').one()
language.enabled = False
src_language = self.session.query(Language).\
filter(Language.lang==u'it').one()
dst_language = self.session.query(Language).\
filter(Language.lang==u'de').one()
language = Language.enable(self.session,
dst_language.id,
src_language.id)
self.assertEqual(dst_language, language)
original = self.session.query(NodeInfo).\
filter(NodeInfo.lang.has(id=src_language.id)).count()
translations = self.session.query(NodeInfo).\
filter(NodeInfo.lang.has(id=dst_language.id)).count()
self.assertEqual(translations, original)
def disable(self):
"""
Disable the language identified by 'lang_id'.
"""
try:
lang_id = int(self.request.params['lang_id'])
language = Language.disable(self.session, lang_id)
self.session.flush()
except QuotaError as e:
self.log.exception(e)
self.session.rollback()
success = False
msg = self.request.translate(
u"Non è possibile rimuovere tutte le lingue")
except Exception as e:
self.session.rollback()
success = False
msg = self.request.translate(
u"Errore durante il tentativo di rimuovere la lingua.")
self.log.exception('Unable to remove the requested language: %s', e)
else:
self.session.commit()
success = True
msg = self.request.translate(u"Lingua rimossa con successo.")
self.log.debug("Language remove successfully.")
self.proxy.invalidate(language=language)
finally:
return dict(success=success, msg=msg)
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_disable(self):
self.populate(self.session)
language = self.session.query(Language).\
filter(Language.lang==u'it').one()
self.assertEqual(language, Language.disable(self.session, language.id))
criterion = NodeInfo.lang.has(id=language.id)
translations = self.session.query(NodeInfo).filter(criterion).count()
self.assertEqual(translations, 0)
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 __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 set_language_from_session_or_default(self):
# USE language.setter!
if self.user and 'lang' in self.session:
log.debug("Getting language from session")
lang = self.db_session.merge(self.session['lang'])
log.debug("Got language %s", lang)
else:
log.debug("Using default locale %s",
self._settings['default_locale_name'])
lang = Language.\
get_by_lang(self.db_session,
self._settings['default_locale_name'])
if not lang.enabled:
log.warn("Default locale is disabled")
lang = Language.get_by_enabled(self.db_session,
enabled=True,
start=0,
limit=1)[0]
log.info("Selected first enabled lang %s", lang)
self.language = 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 __init__(self, request):
self._request = request
self._settings = SettingProxy(self._request.db_session)
self._menus = MenuProxy(self._request.db_session)
self._languages = Language.get_by_enabled(self._request.db_session,
True)
self._rendering_type = 'dynamic'
# old heka legacy. Remove ASAP
self.section = None
self.subsection = None
self.page = None
self.backgrounds = Background.all(request.db_session)
if hasattr(self._request, "context"):
self._translation = self._request.context
node = getattr(self._translation, 'node', None)
if not node is None:
self._node = NodeProxy(node)
else:
self._node = None
else:
self._translation = NodeNotFound(request)
self._node = NodeProxy(self._translation)
def search(self):
response = self._response.copy()
try:
id_ = self.request.params['id']
language = Language.get(self.session, id_)
language = language.dictify(excludes=('__class__'))
except KeyError as e:
self.log.exception('Not ID param in the request.')
self.session.rollback()
self.request.response.status = 400
response['msg'] = self.request.translate("Missing parameter: 'id'.")
except NoResultFound as e:
self.log.exception('No Language: %s.', id_)
self.session.rollback()
self.request.response.status = 404
response['msg'] = self.request.translate("No Language found.")
except Exception as e:
self.log.exception('Uknown error.')
self.session.rollback()
self.request.response.status = 500
response['msg'] = str(e)
else:
self.session.commit()
response['success'] = True
response['dataset'] = [language]
response['dataset_length'] = len(response['dataset'])
response['msg'] = self.request.translate("Language found.")
finally:
return response
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
def languages(self):
return dict(page='languages', languages=Language.all(self.session))
def test_get_locales(self):
languages = [
Language(id=1, lang=u'it', country=u'IT', enabled=True),
Language(id=2, lang=u'en', country=u'GB', enabled=True),
Language(id=3, lang=u'es', country=u'ES', enabled=True),
Language(id=4, lang=u'de', country=u'DE', enabled=False),
Language(id=5, lang=u'fr', country=u'FR', enabled=False),
Language(id=6, lang=u'ru', country=u'RU', enabled=False),
Language(id=7, lang=u'zh', country=u'CN', enabled=False)]
for language in languages:
self.session.add(language)
self.session.commit()
enabled_locales = []
for language in Language.get_locales(self.session, enabled=True):
enabled_locales.append(language)
enabled_strict_locales = []
for language in Language.get_locales(self.session, enabled=True,
strict=True):
enabled_strict_locales.append(language)
disabled_locales = []
for language in Language.get_locales(self.session, enabled=False):
disabled_locales.append(language)
disabled_strict_locales = []
for language in Language.get_locales(self.session, enabled=False,
strict=True):
disabled_strict_locales.append(language)
all_locales = []
for language in Language.get_locales(self.session):
all_locales.append(language)
all_strict_locales = []
for language in Language.get_locales(self.session, strict=True):
all_strict_locales.append(language)
for language in languages:
full_locale = Locale(language.lang.lower(),
language.country.upper())
lang_locale = Locale(language.lang.lower())
if language.enabled:
self.assertIn(full_locale, enabled_locales)
self.assertIn(lang_locale, enabled_locales)
self.assertIn(full_locale, enabled_strict_locales)
self.assertNotIn(lang_locale, enabled_strict_locales)
else:
self.assertIn(full_locale, disabled_locales)
self.assertIn(lang_locale, disabled_locales)
self.assertIn(full_locale, disabled_strict_locales)
self.assertNotIn(lang_locale, disabled_strict_locales)
self.assertIn(full_locale, all_locales)
self.assertIn(lang_locale, all_locales)
self.assertIn(full_locale, all_strict_locales)
self.assertNotIn(lang_locale, all_strict_locales)
