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)