Пример #1
0
def get_alt_src_langs(request, profile, translation_project):
    language = translation_project.language
    project = translation_project.project
    source_language = project.source_language

    langs = profile.alt_src_langs.exclude(id__in=(language.id, source_language.id)).filter(
        translationproject__project=project
    )

    if not profile.alt_src_langs.count():
        from pootle_language.models import Language

        accept = request.META.get("HTTP_ACCEPT_LANGUAGE", "")
        for accept_lang, unused in parse_accept_lang_header(accept):
            if accept_lang == "*":
                continue
            normalized = to_locale(data.normalize_code(data.simplify_to_common(accept_lang)))
            code = to_locale(accept_lang)
            if normalized in ("en", "en_US", source_language.code, language.code) or code in (
                "en",
                "en_US",
                source_language.code,
                language.code,
            ):
                continue
            langs = Language.objects.filter(code__in=(normalized, code), translationproject__project=project)
            if langs.count():
                break
    return langs
Пример #2
0
 def matches(self, other, ignore_dialect=True):
     return (
         (to_locale(self.code)
          == to_locale(other.code))
         or (ignore_dialect
             and (self.base_code
                  == (other.base_code))))
Пример #3
0
def perform_login(request, user, redirect_url=None, signup=False, **kwargs):
    """
    Keyword arguments:

    signup -- Indicates whether or not sending the
    email is essential (during signup), or if it can be skipped (e.g. in
    case email verification is optional and we are only logging in).
    """
    # not is_active: social users are redirected to a template
    # local users are stopped due to form validation checking is_active
    # assert user.is_active
    # the user have a verified email
    has_verified_email = EmailAddress.objects.filter(user=user, verified=True).exists()

    if not has_verified_email:
        email = user.email
        set_user_message(request, messages.WARNING, 'confirmation',
                         'please check your email to active your account ' + email)
        send_email_confirmation(request, user, signup=signup)
        return render(request,
                      "tverification_sent.html",
                      {"email": email})
    else :
        # authentication backend, but I fail to see any added benefit
        # whereas I do see the downsides (having to bother the integrator
        # to set up authentication backend in settings.py
        if not hasattr(user, 'backend'):
            user.backend = "django.contrib.auth.backends.ModelBackend"
        login(request, user)
        to_locale(user.profile.lang.code or get_language())
        return HttpResponseRedirect(get_login_redirect_url(request))
Пример #4
0
def javascript_catalog(request, domain='djangojs', packages=None):
    """
    Returns the selected language catalog as a javascript library.

    Receives the list of packages to check for translations in the
    packages parameter either from an infodict or as a +-delimited
    string from the request. Default is 'django.conf'.

    Additionally you can override the gettext domain for this view,
    but usually you don't want to do that, as JavaScript messages
    go to the djangojs domain. But this might be needed if you
    deliver your JavaScript source from Django templates.
    """
    locale = to_locale(get_language())

    if request.GET and 'language' in request.GET:
        if check_for_language(request.GET['language']):
            locale = to_locale(request.GET['language'])

    if packages is None:
        packages = ['django.conf']
    if isinstance(packages, six.string_types):
        packages = packages.split('+')

    catalog, plural = get_javascript_catalog(locale, domain, packages)
    return render_javascript_catalog(catalog, plural)
Пример #5
0
def javascript_catalog(request, domain='djangojs', packages=None):
    """
Returns the selected language catalog as a javascript library.

Receives the list of packages to check for translations in the
packages parameter either from an infodict or as a +-delimited
string from the request. Default is 'django.conf'.

Additionally you can override the gettext domain for this view,
but usually you don't want to do that, as JavaScript messages
go to the djangojs domain. But this might be needed if you
deliver your JavaScript source from Django templates.
"""
    locale = to_locale(get_language())

    if request.GET and 'language' in request.GET:
        if check_for_language(request.GET['language']):
            locale = to_locale(request.GET['language'])

    if packages is None:
        packages = ['django.conf']
    if isinstance(packages, six.string_types):
        packages = packages.split('+')

    catalog = None
    try:
        catalog, plural = get_javascript_catalog(locale, domain, packages)
    except TranslationError as ex:
        # We know how to handle one specific type of error - so let's do
        # something useful there.
        if re.match(r'.*duplicate message definition', ex.args[0]):
            return render_duplicate_error_js(ex.args[0])

        raise Exception(ex.msg)
    return render_javascript_catalog(catalog, plural)
Пример #6
0
def get_alt_src_langs(request, user, translation_project):
    if request.user.is_anonymous:
        return
    language = translation_project.language
    project = translation_project.project
    source_language = project.source_language
    langs = list(
        user.alt_src_langs.exclude(
            id__in=(language.id, source_language.id)
        ).filter(
            translationproject__project=project))
    if langs:
        return langs
    accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
    for accept_lang, __ in parse_accept_lang_header(accept):
        if accept_lang == '*':
            continue
        normalized = to_locale(
            data.normalize_code(
                data.simplify_to_common(accept_lang)))
        code = to_locale(accept_lang)
        is_source_lang = any(
            langcode in ('en', 'en_US', source_language.code, language.code)
            for langcode in [code, normalized])
        if is_source_lang:
            continue

        langs = list(
            Language.objects.filter(
                code__in=(normalized, code),
                translationproject__project=project))
        if langs:
            return langs
Пример #7
0
 def test_to_locale(self):
     """
     Tests the to_locale function and the special case of Serbian Latin
     (refs #12230 and r11299)
     """
     self.assertEqual(to_locale("en-us"), "en_US")
     self.assertEqual(to_locale("sr-lat"), "sr_Lat")
Пример #8
0
 def test_to_locale(self):
     """
     Tests the to_locale function and the special case of Serbian Latin
     (refs #12230 and r11299)
     """
     self.assertEqual(to_locale('en-us'), 'en_US')
     self.assertEqual(to_locale('sr-lat'), 'sr_Lat')
Пример #9
0
def get_alt_src_langs(request, user, translation_project):
    language = translation_project.language
    project = translation_project.project
    source_language = project.source_language

    langs = user.alt_src_langs.exclude(
        id__in=(language.id, source_language.id)
    ).filter(translationproject__project=project)

    if not user.alt_src_langs.count():
        from pootle_language.models import Language
        accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')

        for accept_lang, unused in parse_accept_lang_header(accept):
            if accept_lang == '*':
                continue

            simplified = data.simplify_to_common(accept_lang)
            normalized = to_locale(data.normalize_code(simplified))
            code = to_locale(accept_lang)
            if (normalized in
                    ('en', 'en_US', source_language.code, language.code) or
                code in ('en', 'en_US', source_language.code, language.code)):
                continue

            langs = Language.objects.filter(
                code__in=(normalized, code),
                translationproject__project=project,
            )
            if langs.count():
                break

    return langs
Пример #10
0
    def process_request(self, request):
        # Under Windows, locale names are different and setlocale()
        # with regular locale names will fail;
        # so just set the default locale and quit early
        if os.name == 'nt':
            locale.setlocale(locale.LC_ALL, '')
            return

        #FIXME: some languages like arabic don't have a language only
        # locale for no good reason. we need a function to pick default
        # locale for these
        lang = translation.to_locale(translation.get_language())
        try:
            if lang == 'tr' or lang.startswith('tr_'):
                raise ValueError("Turkish locale broken due to changed meaning of lower()")
            locale.setlocale(locale.LC_ALL, (lang, 'UTF-8'))
        except:
            logging.debug('Failed to set locale to %s; using Pootle default', lang)
            lang = translation.to_locale(settings.LANGUAGE_CODE)
            try:
                if lang == 'tr' or lang.startswith('tr_'):
                    raise ValueError("Turkish locale broken due to changed meaning of lower()")
                locale.setlocale(locale.LC_ALL, (lang, 'UTF-8'))
            except:
                logging.debug('Failed to set locale to Pootle default (%s); loading system default', lang)
                locale.setlocale(locale.LC_ALL, '')
Пример #11
0
def get_locale_conv(loc=None):
    if loc is None:
        loc = to_locale(get_language())
    startloc = loc

    # '-' is a language delimiter, not a locale, but people often mess that up
    if loc.find("-") > -1:
        loc = to_locale(loc)

    try:
        # log.debug('setting locale: %s', loc.encode('utf-8'))
        locale.setlocale(locale.LC_ALL, locale.normalize(loc))
        return locale.localeconv()
    except (locale.Error, ValueError):
        # darn, try a different path
        pos = loc.find("_")
        if pos > -1:
            loc = loc[:pos]
            return get_locale_conv(loc)
        else:
            loc = to_locale(settings.LANGUAGE_CODE)
            if loc != startloc and loc[: loc.find("_")] != startloc:
                log.warn(
                    u"Cannot set locale to '%s'. Using default locale '%s'.",
                    startloc.encode("utf-8"),
                    loc.encode("utf-8"),
                )
                return get_locale_conv(loc)
            else:
                log.fatal(u"Cannot set locale to default locale '%s'. Something is misconfigured.", loc.encode("utf-8"))
                raise ImproperlyConfigured("bad settings.LANGUAGE_CODE")
Пример #12
0
def _get_format():
    lang = translation.get_language()
    try:
        locale = Locale(translation.to_locale(lang))
    except UnknownLocaleError:
        locale = Locale(translation.to_locale(settings.BABEL_FALLBACK.get(
            lang, 'en-US')))
    return Format(locale)
Пример #13
0
def djangular_catalog(request):
    locale = to_locale(get_language_from_request(request))

    if request.GET and 'lang' in request.GET:
        if check_for_language(request.GET['lang']):
            locale = to_locale(request.GET['lang'])
    catalog, plural = get_javascript_catalog(locale, 'djangular',
                                             ['django.conf'])
    return JsonResponse(catalog)
    def render_to_fragment(self, request, course_id, user_access, **kwargs):
        """
        Renders a course message fragment for the specified course.
        """
        course_key = CourseKey.from_string(course_id)
        course = get_course_with_access(request.user, 'load', course_key)

        # Get time until the start date, if already started, or no start date, value will be zero or negative
        now = datetime.now(UTC)
        already_started = course.start and now > course.start
        days_until_start_string = "started" if already_started else format_timedelta(
            course.start - now, locale=to_locale(get_language())
        )
        course_start_data = {
            'course_start_date': format_date(course.start, locale=to_locale(get_language())),
            'already_started': already_started,
            'days_until_start_string': days_until_start_string
        }

        # Register the course home messages to be loaded on the page
        _register_course_home_messages(request, course, user_access, course_start_data)

        # Register course date alerts
        for course_date_block in get_course_date_blocks(course, request.user):
            course_date_block.register_alerts(request, course)

        # Register a course goal message, if appropriate
        # Only show the set course goal message for enrolled, unverified
        # users that have not yet set a goal in a course that allows for
        # verified statuses.
        user_goal = get_course_goal(auth.get_user(request), course_key)
        is_already_verified = CourseEnrollment.is_enrolled_as_verified(request.user, course_key)
        if has_course_goal_permission(request, course_id, user_access) and not is_already_verified and not user_goal:
            _register_course_goal_message(request, course)

        # Grab the relevant messages
        course_home_messages = list(CourseHomeMessages.user_messages(request))

        # Pass in the url used to set a course goal
        goal_api_url = get_goal_api_url(request)

        # Grab the logo
        image_src = 'course_experience/images/home_message_author.png'

        context = {
            'course_home_messages': course_home_messages,
            'goal_api_url': goal_api_url,
            'image_src': image_src,
            'course_id': course_id,
            'username': request.user.username,
        }

        html = render_to_string('course_experience/course-messages-fragment.html', context)
        return Fragment(html)
Пример #15
0
def locale_html(translatedfield):
    """HTML attributes for languages different than the site language"""
    if not translatedfield:
        return ""

    site_locale = translation.to_locale(translation.get_language())
    locale = translation.to_locale(translatedfield.locale)
    if locale == site_locale:
        return ""
    else:
        rtl_locales = map(translation.to_locale, settings.RTL_LANGUAGES)
        textdir = "rtl" if locale in rtl_locales else "ltr"
        return jinja2.Markup(' lang="%s" dir="%s"' % (jinja2.escape(translatedfield.locale), textdir))
Пример #16
0
 def process_request(self, request):
     #FIXME: some languages like arabic don't have a language only
     # locale for no good reason. we need a function to pick default
     # locale for these
     lang = translation.to_locale(translation.get_language())
     try:
         locale.setlocale(locale.LC_ALL, (lang, 'UTF-8'))
     except:
         logging.debug('failed to set locale to %s; using Pootle default', lang)
         lang = translation.to_locale(settings.LANGUAGE_CODE)
         try:
             locale.setlocale(locale.LC_ALL, (lang, 'UTF-8'))
         except:
             logging.debug('failed to set locale to pootle default (%s); loading system default', lang)
             locale.setlocale(locale.LC_ALL, '')
Пример #17
0
def get_locale_data():
    language = get_language()
    if not language:
        language = settings.LANGUAGE_CODE
    locale_code = to_locale(language)
    locale = None
    try:
        locale = Locale.parse(locale_code)
    except (ValueError, UnknownLocaleError):
        # Invalid format or unknown locale
        # Fallback to the default language
        language = settings.LANGUAGE_CODE
        locale_code = to_locale(language)
        locale = Locale.parse(locale_code)
    return locale, locale_code
Пример #18
0
def lang_choices():
    """generated locale choices for drop down lists in forms"""
    choices = []
    for code, name in supported_langs():
        name = data.tr_lang(translation.to_locale('en'))(name)
        tr_name = data.tr_lang(translation.to_locale(code))(name)
        if tr_name != name:
            # We have to use the LRO (left-to-right override) to ensure that 
            # brackets in the English part of the name is rendered correctly
            # in an RTL layout like Arabic. We can't use markup because this 
            # is used inside an option tag.
            name = u"%s | \u202d%s" % (tr_name, name)
        choices.append((code, name))
    choices.sort(cmp=locale.strcoll, key=lambda choice: unicode(choice[1]))
    return choices
Пример #19
0
def set_user_language(user):
    try:
        lang = user.get_profile().language
        if lang:
            language = translation.to_locale(lang)
            translation.activate(language)
        else:
            # if user has no language and current is not default, then set the default
            # this is to avoid using the last selected language
            if not translation.get_language() == settings.LANGUAGE_CODE:
                language = translation.to_locale(settings.LANGUAGE_CODE)
                translation.activate(language)
    except:
        # in case of fail do nothing
        pass
Пример #20
0
def get_locale_from_lang(lang):
    """Pass in a language (u'en-US') get back a Locale object courtesy of
    Babel.  Use this to figure out currencies, bidi, names, etc."""
    # Special fake language can just act like English for formatting and such
    if not lang or lang == 'dbg':
        lang = 'en'
    return Locale(translation.to_locale(lang))
Пример #21
0
def InitBlogData():
    global g_blog
    OptionSet.setValue('PluginActive',[u'googleAnalytics', u'wordpress', u'sys_plugin'])

    g_blog = Blog(key_name = 'default')
    g_blog.domain=os.environ['HTTP_HOST']
    g_blog.baseurl="http://"+g_blog.domain
    g_blog.feedurl=g_blog.baseurl+"/feed"
    g_blog.admin_essential = False
    if os.environ.has_key('HTTP_ACCEPT_LANGUAGE'):
        lang=os.environ['HTTP_ACCEPT_LANGUAGE'].split(',')[0]
    from django.utils.translation import  activate,to_locale
    g_blog.language=to_locale(lang)
    g_blog.admin_essential=False
    from django.conf import settings
    settings._target = None
    activate(g_blog.language)
    g_blog.save()

    entry=Entry(title="Hello world!".decode('utf8'))
    entry.content='<p>Welcome to micolog %s. This is your first post. Edit or delete it, then start blogging!</p>'%g_blog.version
    entry.save(True)
    link=Link(href='http://xuming.net',linktext="Xuming's blog".decode('utf8'))
    link.put()
    link=Link(href='http://eric.cloud-mes.com/',linktext="Eric Guo's blog".decode('utf8'))
    link.put()
    return g_blog
Пример #22
0
    def handle(self, *args, **options):
        for module in options['module']:
            for domain in DOMAINS:
                for language in options['language']:
                    locale = translation.to_locale(language)

                    pofile = POFILE.format(module=module,
                                           locale=locale,
                                           domain=domain)

                    pofile_dir = os.path.dirname(pofile)
                    if not os.path.exists(pofile_dir):
                        os.makedirs(pofile_dir)

                    new_po = requests.get((POFILE_URL).format(
                        language=language,
                        project=options['project'],
                        branch=options['branch'],
                        module=module,
                        domain=domain))

                    # Ensure to use UTF-8 encoding
                    new_po.encoding = 'utf-8'

                    with open(pofile, 'w+') as f:
                        f.write(new_po.text.encode('utf-8'))
Пример #23
0
 def _switch_locale(self):
     if self.source_locale:
         lang = self.source_locale
     else:
         lang = self.addon.default_locale
     tower.activate(lang)
     return Locale(translation.to_locale(lang))
Пример #24
0
 def _format_date(self):
     """
     Return this block's date in a human-readable format. If the date
     is None, returns the empty string.
     """
     if self.date is None:
         return ''
     locale = to_locale(get_language())
     delta = self.date - datetime.now(utc)
     try:
         relative_date = format_timedelta(delta, locale=locale)
     # Babel doesn't have translations for Esperanto, so we get
     # a KeyError when testing translations with
     # ?preview-lang=eo. This should not happen with any other
     # languages. See https://github.com/python-babel/babel/issues/107
     except KeyError:
         relative_date = format_timedelta(delta)
     date_has_passed = delta.days < 0
     # Translators: 'absolute' is a date such as "Jan 01,
     # 2020". 'relative' is a fuzzy description of the time until
     # 'absolute'. For example, 'absolute' might be "Jan 01, 2020",
     # and if today were December 5th, 2020, 'relative' would be "1
     # month".
     date_format = _(u"{relative} ago - {absolute}") if date_has_passed else _(u"in {relative} - {absolute}")
     return date_format.format(
         relative=relative_date,
         absolute=self.date.astimezone(self.time_zone).strftime(self.date_format.encode('utf-8')).decode('utf-8'),
     )
Пример #25
0
    def InitBlogData(self):
        OptionSet.setValue('PluginActive',[u'googleAnalytics', u'wordpress', u'sys_plugin'])
        self.domain=os.environ['HTTP_HOST']
        self.feedurl=self.baseurl+"/feed"


        if os.environ.has_key('HTTP_ACCEPT_LANGUAGE'):
            lang=os.environ['HTTP_ACCEPT_LANGUAGE'].split(',')[0]
        else:
            lang='zh-CN'
        from django.utils.translation import  to_locale
        self.language=to_locale(lang)


        self.put_async()

        entry=Entry(title="Hello world!".decode('utf8'))
        entry.content='<p>Welcome to micolog %s. This is your first post. Edit or delete it, then start blogging!</p>'%self.version
        entry.published=True
        entry.put_async()
        link=Link()
        link.populate(href='http://xuming.net',linktext="Xuming's blog".decode('utf8'))
        link.put_async()
        link=Link()
        link.populate(href='http://eric.cloud-mes.com/',linktext="Eric Guo's blog".decode('utf8'))
        link.put_async()
Пример #26
0
 def get_context(self):
     """Return the template context used to render this summary block."""
     date = ''
     if self.date is not None:
         # Translators: relative_date is a fuzzy description of the
         # time from now until absolute_date. For example,
         # absolute_date might be "Jan 01, 2020", and if today were
         # December 5th, 2020, relative_date would be "1 month".
         locale = to_locale(get_language())
         try:
             relative_date = format_timedelta(self.date - datetime.now(pytz.UTC), locale=locale)
         # Babel doesn't have translations for Esperanto, so we get
         # a KeyError when testing translations with
         # ?preview-lang=eo. This should not happen with any other
         # languages. See https://github.com/python-babel/babel/issues/107
         except KeyError:
             relative_date = format_timedelta(self.date - datetime.now(pytz.UTC))
         date = _("in {relative_date} - {absolute_date}").format(
             relative_date=relative_date,
             absolute_date=self.date.strftime(self.date_format),
         )
     return {
         'title': self.title,
         'date': date,
         'description': self.description,
         'css_class': self.css_class,
         'link': self.link,
         'link_text': self.link_text,
     }
Пример #27
0
 def __init__(self, block=None):
     """
     Attempt to load an XBlock-specific GNU gettext translator using the XBlock's own domain
     translation catalog, currently expected to be found at:
         <xblock_root>/conf/locale/<language>/LC_MESSAGES/<domain>.po|mo
     If we can't locate the domain translation catalog then we fall-back onto
     django.utils.translation, which will point to the system's own domain translation catalog
     This effectively achieves translations by coincidence for an XBlock which does not provide
     its own dedicated translation catalog along with its implementation.
     """
     self.translator = django.utils.translation
     if block:
         xblock_class = getattr(block, 'unmixed_class', block.__class__)
         xblock_resource = xblock_class.__module__
         xblock_locale_dir = '/translations'
         xblock_locale_path = resource_filename(xblock_resource, xblock_locale_dir)
         xblock_domain = 'text'
         selected_language = get_language()
         try:
             self.translator = gettext.translation(
                 xblock_domain,
                 xblock_locale_path,
                 [to_locale(selected_language if selected_language else settings.LANGUAGE_CODE)]
             )
         except IOError:
             # Fall back to the default Django translator if the XBlock translator is not found.
             pass
Пример #28
0
    def get_context_data(self, **kwargs):
        context = super(MapDetailMixin, self).get_context_data(**kwargs)
        properties = {
            'urls': _urls_for_js(),
            'tilelayers': self.get_tilelayers(),
            'allowEdit': self.is_edit_allowed(),
            'default_iconUrl': "%sstorage/src/img/marker.png" % settings.STATIC_URL,  # noqa
            'storage_id': self.get_storage_id(),
            'licences': dict((l.name, l.json) for l in Licence.objects.all()),
        }
        if self.get_short_url():
            properties['shortUrl'] = self.get_short_url()

        if settings.USE_I18N:
            locale = settings.LANGUAGE_CODE
            # Check attr in case the middleware is not active
            if hasattr(self.request, "LANGUAGE_CODE"):
                locale = self.request.LANGUAGE_CODE
            locale = to_locale(locale)
            properties['locale'] = locale
            context['locale'] = locale
        map_settings = self.get_geojson()
        if "properties" not in map_settings:
            map_settings['properties'] = {}
        map_settings['properties'].update(properties)
        map_settings['properties']['datalayers'] = self.get_datalayers()
        context['map_settings'] = json.dumps(map_settings,
                                             indent=settings.DEBUG)
        return context
Пример #29
0
    def get_context_data(self, **kwargs):
        context = super(MapDetailMixin, self).get_context_data(**kwargs)
        properties = {}
        properties['datalayers'] = self.get_datalayers()
        properties['urls'] = _urls_for_js()
        properties['tilelayers'] = self.get_tilelayers()
        if self.get_short_url():
            properties['shortUrl'] = self.get_short_url()

        if settings.USE_I18N:
            locale = settings.LANGUAGE_CODE
            # Check attr in case the middleware is not active
            if hasattr(self.request, "LANGUAGE_CODE"):
                locale = self.request.LANGUAGE_CODE
            locale = to_locale(locale)
            properties['locale'] = locale
            context['locale'] = locale
        properties['allowEdit'] = self.is_edit_allowed()
        properties["default_iconUrl"] = "%sstorage/src/img/marker.png" % settings.STATIC_URL
        properties['storage_id'] = self.get_storage_id()
        properties['licences'] = dict((l.name, l.json) for l in Licence.objects.all())
        # if properties['locateOnLoad']:
        #     properties['locate'] = {
        #         'setView': True,
        #         'enableHighAccuracy': True,
        #         'timeout': 3000
        #     }
        map_settings = self.get_geojson()
        if not "properties" in map_settings:
            map_settings['properties'] = {}
        map_settings['properties'].update(properties)
        context['map_settings'] = simplejson.dumps(map_settings, indent=settings.DEBUG)
        return context
Пример #30
0
def iter_format_modules(lang, format_module_path=None):
    """
    Does the heavy lifting of finding format modules.
    """
    if not check_for_language(lang):
        return

    if format_module_path is None:
        format_module_path = settings.FORMAT_MODULE_PATH

    format_locations = []
    if format_module_path:
        if isinstance(format_module_path, six.string_types):
            format_module_path = [format_module_path]
        for path in format_module_path:
            format_locations.append(path + '.%s')
    format_locations.append('django.conf.locale.%s')
    locale = to_locale(lang)
    locales = [locale]
    if '_' in locale:
        locales.append(locale.split('_')[0])
    for location in format_locations:
        for loc in locales:
            try:
                yield import_module('%s.formats' % (location % loc))
            except ImportError:
                pass
    def render_to_fragment(self, request, course_id, user_access, **kwargs):
        """
        Renders a course message fragment for the specified course.
        """
        course_key = CourseKey.from_string(course_id)
        course = get_course_with_access(request.user, 'load', course_key)

        # Get time until the start date, if already started, or no start date, value will be zero or negative
        now = datetime.now(UTC)
        already_started = course.start and now > course.start
        days_until_start_string = "started" if already_started else format_timedelta(
            course.start - now, locale=to_locale(get_language()))
        course_start_data = {
            'course_start_date':
            format_date(course.start, locale=to_locale(get_language())),
            'already_started':
            already_started,
            'days_until_start_string':
            days_until_start_string
        }

        # Register the course home messages to be loaded on the page
        _register_course_home_messages(request, course, user_access,
                                       course_start_data)

        # Register course date alerts
        for course_date_block in get_course_date_blocks(course, request.user):
            course_date_block.register_alerts(request, course)

        # Register a course goal message, if appropriate
        # Only show the set course goal message for enrolled, unverified
        # users that have not yet set a goal in a course that allows for
        # verified statuses.
        user_goal = get_course_goal(auth.get_user(request), course_key)
        is_already_verified = CourseEnrollment.is_enrolled_as_verified(
            request.user, course_key)
        if has_course_goal_permission(
                request, course_id,
                user_access) and not is_already_verified and not user_goal:
            _register_course_goal_message(request, course)

        # Grab the relevant messages
        course_home_messages = list(CourseHomeMessages.user_messages(request))

        # Pass in the url used to set a course goal
        goal_api_url = get_goal_api_url(request)

        # Grab the logo
        image_src = 'course_experience/images/home_message_author.png'

        context = {
            'course_home_messages': course_home_messages,
            'goal_api_url': goal_api_url,
            'image_src': image_src,
            'course_id': course_id,
            'username': request.user.username,
        }

        html = render_to_string(
            'course_experience/course-messages-fragment.html', context)
        return Fragment(html)
Пример #32
0
def date_filter(value):
    return format_date(
        value.astimezone(get_current_timezone()),
        format='full',
        locale=to_locale(get_language()),
    )
Пример #33
0
def locale(request):
    return {'LOCALE': to_locale(get_language())}
Пример #34
0
 def akismet_lang(self, language):
     """
     Convert a Django language name to an Akismet blog_lang identifier.
     E.g.: "en-US" to "en_us"
     """
     return translation.to_locale(language).lower()
Пример #35
0
    def __init__(self, video, statement, lti_user):
        """Compute a valid xapi satement.

        Parameters
        ----------
        video : Type[.models/videos]
            The video object used in the xAPI statement

        statement : dictionary
            Statement containing base information to send to the LRS
            An example of expected statement:
            {
                "verb": {
                    "id": "http://adlnet.gov/expapi/verbs/initialized",
                    "display": {
                        "en-US": "initialized"
                    }
                },
                "context": {
                    "extensions": {
                        "https://w3id.org/xapi/video/extensions/volume": 1,
                        "https://w3id.org/xapi/video/extensions/video-playback-size": "640x264",
                    }
                }
            }

        lti_user : Type[lti.LTIUser]
            Object representing data stored in the JWT Token and related to the user authenticated
            with LTI

        """
        try:
            user_id = lti_user.user_id
        except AttributeError:
            user_id = lti_user.session_id

        homepage = video.playlist.consumer_site.domain

        if re.match(r"^http(s?):\/\/.*", homepage) is None:
            homepage = f"http://{homepage}"

        if "id" not in statement:
            statement["id"] = str(uuid.uuid4())

        statement["timestamp"] = timezone.now().isoformat()
        statement["context"].update({
            "contextActivities": {
                "category": [{
                    "id": "https://w3id.org/xapi/video"
                }]
            }
        })

        statement["actor"] = {
            "objectType": "Agent",
            "account": {
                "name": user_id,
                "homePage": homepage
            },
        }

        statement["object"] = {
            "definition": {
                "type": "https://w3id.org/xapi/video/activity-type/video",
                "name": {
                    to_locale(settings.LANGUAGE_CODE).replace("_", "-"):
                    video.title
                },
            },
            "id": "uuid://{id}".format(id=str(video.id)),
            "objectType": "Activity",
        }

        object_extensions = {}
        if lti_user.course.get("school_name") is not None:
            object_extensions[
                "https://w3id.org/xapi/acrossx/extensions/school"] = lti_user.course[
                    "school_name"]

        if lti_user.course.get("course_name") is not None:
            object_extensions[
                "http://adlnet.gov/expapi/activities/course"] = lti_user.course[
                    "course_name"]

        if lti_user.course.get("course_run") is not None:
            object_extensions[
                "http://adlnet.gov/expapi/activities/module"] = lti_user.course[
                    "course_run"]

        if object_extensions:
            statement["object"]["definition"]["extensions"] = object_extensions

        self.statement = statement
    def render(self, context):
        args = [arg.resolve(context) for arg in self.args]
        kwargs = dict((smart_text(k, 'ascii'), v.resolve(context))
                      for k, v in self.kwargs.items())

        # If user didn't specify the language in the template tag arguments get
        # language from Django settings
        if 'language' not in kwargs:
            kwargs.update({'language': get_language()})

        # If user didn't specify the locale in the template tag, guess it from
        # the language
        if 'locale' not in kwargs:
            kwargs.update({'locale': to_locale(kwargs['language'])})

        # Push 'social_widgets_javascript' list into context. We use that list
        # to keep track of loaded external JavaScript files and don't load
        # the same file multiple times in one page when there are multiple
        # widgets from the same social network.
        if 'social_widgets_javascript' not in context.dicts[0]:
            context.dicts[0]['social_widgets_javascript'] = []

        kwargs.update({
            'social_widgets_javascript':
            context.dicts[0]['social_widgets_javascript'][:]
            })

        try:
            template_path = args[0]
        except IndexError:
            return ''

        template = 'social_widgets/%s' % template_path

        # We assume that if there are multiple widget templates in directory
        # (for example in there are 5 templates in "social_widgets/pinterest"
        # directory) then they are all using the same external JavaScript code
        # for loading and initializing.  We want to load this JavaScript code
        # only once when the first widget is rendered, so we use directory name
        # to track if code already had been used. Widget template must also
        # support this feature by checking.
        #
        # {% if not widget_service in social_widgets_javascript #}
        # <!-- Code to load external JavaScript file. -->
        # {% endif %}
        #
        # Alternatively you can disable external JavaScript loading by
        # specifying noscript=True in template tags parameters.
        try:
            widget_service = template_path.split('/')[0]
            kwargs['widget_service'] = widget_service
            if widget_service \
                    not in context.dicts[0]['social_widgets_javascript'] and \
                    not kwargs.get('noscript', False):
                context.dicts[0]['social_widgets_javascript']\
                    .append(widget_service)
        except IndexError:
            pass

        try:
            t = loader.get_template(template)
            return t.render(Context(kwargs))
        except TemplateDoesNotExist:
            return ''
Пример #37
0
def get_language_from_django():
    language = get_language()
    language = to_locale(language) if language is not None else "en_US"
    return language
Пример #38
0
def tr_lang(language_name):
    """Translates language names."""
    language_code = translation.to_locale(translation.get_language())

    return langdata.tr_lang(language_code)(language_name)
Пример #39
0
def javascript_catalog(request, domain='djangojs', packages=None):
    """
    Returns the selected language catalog as a javascript library.

    Receives the list of packages to check for translations in the
    packages parameter either from an infodict or as a +-delimited
    string from the request. Default is 'django.conf'.

    Additionally you can override the gettext domain for this view,
    but usually you don't want to do that, as JavaScript messages
    go to the djangojs domain. But this might be needed if you
    deliver your JavaScript source from Django templates.
    """
    if request.GET:
        if 'language' in request.GET:
            if check_for_language(request.GET['language']):
                activate(request.GET['language'])
    if packages is None:
        packages = ['django.conf']
    if isinstance(packages, six.string_types):
        packages = packages.split('+')
    packages = [
        p for p in packages
        if p == 'django.conf' or p in settings.INSTALLED_APPS
    ]
    default_locale = to_locale(settings.LANGUAGE_CODE)
    locale = to_locale(get_language())
    t = {}
    paths = []
    en_selected = locale.startswith('en')
    en_catalog_missing = True
    # paths of requested packages
    for package in packages:
        p = importlib.import_module(package)
        path = os.path.join(os.path.dirname(upath(p.__file__)), 'locale')
        paths.append(path)
    # add the filesystem paths listed in the LOCALE_PATHS setting
    paths.extend(list(reversed(settings.LOCALE_PATHS)))
    # first load all english languages files for defaults
    for path in paths:
        try:
            catalog = gettext_module.translation(domain, path, ['en'])
            t.update(catalog._catalog)
        except IOError:
            pass
        else:
            # 'en' is the selected language and at least one of the packages
            # listed in `packages` has an 'en' catalog
            if en_selected:
                en_catalog_missing = False
    # next load the settings.LANGUAGE_CODE translations if it isn't english
    if default_locale != 'en':
        for path in paths:
            try:
                catalog = gettext_module.translation(domain, path,
                                                     [default_locale])
            except IOError:
                catalog = None
            if catalog is not None:
                t.update(catalog._catalog)
    # last load the currently selected language, if it isn't identical to the default.
    if locale != default_locale:
        # If the currently selected language is English but it doesn't have a
        # translation catalog (presumably due to being the language translated
        # from) then a wrong language catalog might have been loaded in the
        # previous step. It needs to be discarded.
        if en_selected and en_catalog_missing:
            t = {}
        else:
            locale_t = {}
            for path in paths:
                try:
                    catalog = gettext_module.translation(
                        domain, path, [locale])
                except IOError:
                    catalog = None
                if catalog is not None:
                    locale_t.update(catalog._catalog)
            if locale_t:
                t = locale_t
    src = [LibHead]
    plural = None
    if '' in t:
        for l in t[''].split('\n'):
            if l.startswith('Plural-Forms:'):
                plural = l.split(':', 1)[1].strip()
    if plural is not None:
        # this should actually be a compiled function of a typical plural-form:
        # Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;
        plural = [
            el.strip() for el in plural.split(';')
            if el.strip().startswith('plural=')
        ][0].split('=', 1)[1]
        src.append(PluralIdx % plural)
    else:
        src.append(SimplePlural)
    csrc = []
    pdict = {}
    for k, v in t.items():
        if k == '':
            continue
        if isinstance(k, six.string_types):
            csrc.append("catalog['%s'] = '%s';\n" %
                        (javascript_quote(k), javascript_quote(v)))
        elif isinstance(k, tuple):
            if k[0] not in pdict:
                pdict[k[0]] = k[1]
            else:
                pdict[k[0]] = max(k[1], pdict[k[0]])
            csrc.append("catalog['%s'][%d] = '%s';\n" %
                        (javascript_quote(k[0]), k[1], javascript_quote(v)))
        else:
            raise TypeError(k)
    csrc.sort()
    for k, v in pdict.items():
        src.append("catalog['%s'] = [%s];\n" %
                   (javascript_quote(k), ','.join(["''"] * (v + 1))))
    src.extend(csrc)
    src.append(LibFoot)
    src.append(InterPolate)
    src.append(LibFormatHead)
    src.append(get_formats())
    src.append(LibFormatFoot)
    src = ''.join(src)
    return http.HttpResponse(src, 'text/javascript')
Пример #40
0
    def render(self, context):
        settings_code = []

        domain = self._get_setting(context, 'snapengage_domain',
                                   'SNAPENGAGE_DOMAIN')
        if domain is not None:
            settings_code.append(DOMAIN_CODE % domain)

        secure_connection = self._get_setting(context,
                                              'snapengage_secure_connection',
                                              'SNAPENGAGE_SECURE_CONNECTION',
                                              False)
        if secure_connection:
            settings_code.append(SECURE_CONNECTION_CODE)

        email = context.get('snapengage_email')
        if email is None:
            email = get_identity(context, 'snapengage', lambda u: u.email)
        if email is not None:
            if self._get_setting(context, 'snapengage_readonly_email',
                                 'SNAPENGAGE_READONLY_EMAIL', False):
                readonly_tail = ',true'
            else:
                readonly_tail = ''
            settings_code.append(SETEMAIL_CODE % (email, readonly_tail))

        locale = self._get_setting(context, 'snapengage_locale',
                                   'SNAPENGAGE_LOCALE')
        if locale is None:
            locale = translation.to_locale(translation.get_language())
        settings_code.append(SETLOCALE_CODE % locale)

        form_position = self._get_setting(context, 'snapengage_form_position',
                                          'SNAPENGAGE_FORM_POSITION')
        if form_position is not None:
            settings_code.append(FORM_POSITION_CODE % form_position)

        form_top_position = self._get_setting(context,
                                              'snapengage_form_top_position',
                                              'SNAPENGAGE_FORM_TOP_POSITION')
        if form_top_position is not None:
            settings_code.append(FORM_TOP_POSITION_CODE % form_top_position)

        show_offline = self._get_setting(context, 'snapengage_show_offline',
                                         'SNAPENGAGE_SHOW_OFFLINE', True)
        if not show_offline:
            settings_code.append(DISABLE_OFFLINE_CODE)

        screenshots = self._get_setting(context, 'snapengage_screenshots',
                                        'SNAPENGAGE_SCREENSHOTS', True)
        if not screenshots:
            settings_code.append(DISABLE_SCREENSHOT_CODE)

        offline_screenshots = self._get_setting(
            context, 'snapengage_offline_screenshots',
            'SNAPENGAGE_OFFLINE_SCREENSHOTS', True)
        if not offline_screenshots:
            settings_code.append(DISABLE_OFFLINE_SCREENSHOT_CODE)

        if not context.get('snapengage_proactive_chat', True):
            settings_code.append(DISABLE_PROACTIVE_CHAT_CODE)

        sounds = self._get_setting(context, 'snapengage_sounds',
                                   'SNAPENGAGE_SOUNDS', True)
        if not sounds:
            settings_code.append(DISABLE_SOUNDS_CODE)

        button_effect = self._get_setting(context, 'snapengage_button_effect',
                                          'SNAPENGAGE_BUTTON_EFFECT')
        if button_effect is not None:
            settings_code.append(BUTTONEFFECT_CODE % button_effect)

        button = self._get_setting(context, 'snapengage_button',
                                   'SNAPENGAGE_BUTTON', BUTTON_STYLE_DEFAULT)
        if button == BUTTON_STYLE_NONE:
            settings_code.append(INIT_CODE % self.widget_id)
        else:
            if not isinstance(button, int):
                # Assume button as a URL to a custom image
                settings_code.append(SETBUTTON_CODE % button)
            button_location = self._get_setting(context,
                                                'snapengage_button_location',
                                                'SNAPENGAGE_BUTTON_LOCATION',
                                                BUTTON_LOCATION_LEFT)
            button_offset = self._get_setting(
                context, 'snapengage_button_location_offset',
                'SNAPENGAGE_BUTTON_LOCATION_OFFSET', '55%')
            settings_code.append(
                ADDBUTTON_CODE % {
                    'id':
                    self.widget_id,
                    'location':
                    button_location,
                    'offset':
                    button_offset,
                    'dynamic_tail':
                    ',true' if (button == BUTTON_STYLE_LIVE) else '',
                })
        html = SETUP_CODE % {
            'widget_id': self.widget_id,
            'settings_code': " ".join(settings_code),
        }
        return html
Пример #41
0
def locale(request):
    """Convert the language string to a locale"""
    """Copied from: http://stackoverflow.com/a/6362929 """
    return {'LOCALE': to_locale(get_language())}
Пример #42
0
 def _get_language_code(self):
     """Return language code or None."""
     lang_code = translation.get_language()
     if lang_code:
         lang_code = translation.to_locale(lang_code).replace('_', '-')
     return lang_code
Пример #43
0
def current_locale():
    return to_locale(get_language())
Пример #44
0
 def time_remaining_string(self):
     """
     Returns the time remaining as a localized string.
     """
     locale = to_locale(get_language())
     return format_timedelta(self.date - self.current_time, locale=locale)
Пример #45
0
def get_javascript_catalog(locale, domain, packages):
    default_locale = to_locale(settings.LANGUAGE_CODE)
    packages = [p for p in packages if p == 'django.conf' or p in settings.INSTALLED_APPS]
    t = {}
    paths = []
    en_selected = locale.startswith('en')
    en_catalog_missing = True
    # paths of requested packages
    for package in packages:
        p = importlib.import_module(package)
        path = os.path.join(os.path.dirname(upath(p.__file__)), 'locale')
        paths.append(path)
    # add the filesystem paths listed in the LOCALE_PATHS setting
    paths.extend(list(reversed(settings.LOCALE_PATHS)))
    # first load all english languages files for defaults
    for path in paths:
        try:
            catalog = gettext_module.translation(domain, path, ['en'])
            t.update(catalog._catalog)
        except IOError:
            pass
        else:
            # 'en' is the selected language and at least one of the packages
            # listed in `packages` has an 'en' catalog
            if en_selected:
                en_catalog_missing = False
    # next load the settings.LANGUAGE_CODE translations if it isn't english
    if default_locale != 'en':
        for path in paths:
            try:
                catalog = gettext_module.translation(domain, path, [default_locale])
            except IOError:
                catalog = None
            if catalog is not None:
                t.update(catalog._catalog)
    # last load the currently selected language, if it isn't identical to the default.
    if locale != default_locale:
        # If the currently selected language is English but it doesn't have a
        # translation catalog (presumably due to being the language translated
        # from) then a wrong language catalog might have been loaded in the
        # previous step. It needs to be discarded.
        if en_selected and en_catalog_missing:
            t = {}
        else:
            locale_t = {}
            for path in paths:
                try:
                    catalog = gettext_module.translation(domain, path, [locale])
                except IOError:
                    catalog = None
                if catalog is not None:
                    locale_t.update(catalog._catalog)
            if locale_t:
                t = locale_t
    plural = None
    if '' in t:
        for l in t[''].split('\n'):
            if l.startswith('Plural-Forms:'):
                plural = l.split(':', 1)[1].strip()
    if plural is not None:
        # this should actually be a compiled function of a typical plural-form:
        # Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;
        plural = [el.strip() for el in plural.split(';') if el.strip().startswith('plural=')][0].split('=', 1)[1]

    pdict = {}
    maxcnts = {}
    catalog = {}
    for k, v in t.items():
        if k == '':
            continue
        if isinstance(k, six.string_types):
            catalog[k] = v
        elif isinstance(k, tuple):
            msgid = k[0]
            cnt = k[1]
            maxcnts[msgid] = max(cnt, maxcnts.get(msgid, 0))
            pdict.setdefault(msgid, {})[cnt] = v
        else:
            raise TypeError(k)
    for k, v in pdict.items():
        catalog[k] = [v.get(i, '') for i in range(maxcnts[msgid] + 1)]

    return catalog, plural
Пример #46
0
def _get_format():
    lang = translation.get_language()
    locale = Locale(translation.to_locale(lang))
    return Format(locale)
Пример #47
0
    def get(self, request, course_id, error=None):
        """Displays the course mode choice page.

        Args:
            request (`Request`): The Django Request object.
            course_id (unicode): The slash-separated course key.

        Keyword Args:
            error (unicode): If provided, display this error message
                on the page.

        Returns:
            Response

        """
        course_key = CourseKey.from_string(course_id)

        # Check whether the user has access to this course
        # based on country access rules.
        embargo_redirect = embargo_api.redirect_if_blocked(
            course_key,
            user=request.user,
            ip_address=get_ip(request),
            url=request.path)
        if embargo_redirect:
            return redirect(embargo_redirect)

        enrollment_mode, is_active = CourseEnrollment.enrollment_mode_for_user(
            request.user, course_key)
        modes = CourseMode.modes_for_course_dict(course_key)
        ecommerce_service = EcommerceService()

        # We assume that, if 'professional' is one of the modes, it should be the *only* mode.
        # If there are both modes, default to non-id-professional.
        has_enrolled_professional = (
            CourseMode.is_professional_slug(enrollment_mode) and is_active)
        if CourseMode.has_professional_mode(
                modes) and not has_enrolled_professional:
            purchase_workflow = request.GET.get("purchase_workflow", "single")
            verify_url = reverse('verify_student_start_flow',
                                 kwargs={'course_id': unicode(course_key)})
            redirect_url = "{url}?purchase_workflow={workflow}".format(
                url=verify_url, workflow=purchase_workflow)
            if ecommerce_service.is_enabled(request.user):
                professional_mode = modes.get(
                    CourseMode.NO_ID_PROFESSIONAL_MODE) or modes.get(
                        CourseMode.PROFESSIONAL)
                if purchase_workflow == "single" and professional_mode.sku:
                    redirect_url = ecommerce_service.get_checkout_page_url(
                        professional_mode.sku)
                if purchase_workflow == "bulk" and professional_mode.bulk_sku:
                    redirect_url = ecommerce_service.get_checkout_page_url(
                        professional_mode.bulk_sku)
            return redirect(redirect_url)

        course = modulestore().get_course(course_key)

        # If there isn't a verified mode available, then there's nothing
        # to do on this page.  Send the user to the dashboard.
        if not CourseMode.has_verified_mode(modes):
            return redirect(reverse('dashboard'))

        # If a user has already paid, redirect them to the dashboard.
        if is_active and (enrollment_mode in CourseMode.VERIFIED_MODES +
                          [CourseMode.NO_ID_PROFESSIONAL_MODE]):
            # If the course has started redirect to course home instead
            if course.has_started():
                return redirect(
                    reverse('openedx.course_experience.course_home',
                            kwargs={'course_id': course_key}))
            return redirect(reverse('dashboard'))

        donation_for_course = request.session.get("donation_for_course", {})
        chosen_price = donation_for_course.get(unicode(course_key), None)

        if CourseEnrollment.is_enrollment_closed(request.user, course):
            locale = to_locale(get_language())
            enrollment_end_date = format_datetime(course.enrollment_end,
                                                  'short',
                                                  locale=locale)
            params = urllib.urlencode({'course_closed': enrollment_end_date})
            return redirect('{0}?{1}'.format(reverse('dashboard'), params))

        # When a credit mode is available, students will be given the option
        # to upgrade from a verified mode to a credit mode at the end of the course.
        # This allows students who have completed photo verification to be eligible
        # for univerity credit.
        # Since credit isn't one of the selectable options on the track selection page,
        # we need to check *all* available course modes in order to determine whether
        # a credit mode is available.  If so, then we show slightly different messaging
        # for the verified track.
        has_credit_upsell = any(
            CourseMode.is_credit_mode(mode)
            for mode in CourseMode.modes_for_course(course_key,
                                                    only_selectable=False))
        course_id = course_key.to_deprecated_string()
        context = {
            "course_modes_choose_url":
            reverse("course_modes_choose", kwargs={'course_id': course_id}),
            "modes":
            modes,
            "has_credit_upsell":
            has_credit_upsell,
            "course_name":
            course.display_name_with_default_escaped,
            "course_org":
            course.display_org_with_default,
            "course_num":
            course.display_number_with_default,
            "chosen_price":
            chosen_price,
            "error":
            error,
            "responsive":
            True,
            "nav_hidden":
            True,
        }
        context.update(
            get_experiment_user_metadata_context(
                course,
                request.user,
            ))

        title_content = _(
            "Congratulations!  You are now enrolled in {course_name}").format(
                course_name=course.display_name_with_default_escaped)

        context["title_content"] = title_content

        if "verified" in modes:
            verified_mode = modes["verified"]
            context["suggested_prices"] = [
                decimal.Decimal(x.strip())
                for x in verified_mode.suggested_prices.split(",")
                if x.strip()
            ]
            context["currency"] = verified_mode.currency.upper()
            context["min_price"] = verified_mode.min_price
            context["verified_name"] = verified_mode.name
            context["verified_description"] = verified_mode.description

            if verified_mode.sku:
                context[
                    "use_ecommerce_payment_flow"] = ecommerce_service.is_enabled(
                        request.user)
                context[
                    "ecommerce_payment_page"] = ecommerce_service.payment_page_url(
                    )
                context["sku"] = verified_mode.sku
                context["bulk_sku"] = verified_mode.bulk_sku

        context['currency_data'] = []
        if waffle.switch_is_active('local_currency'):
            if 'edx-price-l10n' not in request.COOKIES:
                currency_data = get_currency_data()
                try:
                    context['currency_data'] = json.dumps(currency_data)
                except TypeError:
                    pass
        return render_to_response("course_modes/choose.html", context)
Пример #48
0
def format_date(date):
    locale = to_locale(get_language())
    return dates.format_date(date, format='medium', locale = locale)
Пример #49
0
def _get_locale(request):
    language = request.GET.get(LANGUAGE_QUERY_PARAMETER)
    if not (language and check_for_language(language)):
        language = get_language()
    return to_locale(language)
Пример #50
0
def prepare_pickup_conversation_message_notification(user, message):
    pickup = message.conversation.target
    group_tz = pickup.store.group.timezone

    language = user.language

    if not translation.check_for_language(language):
        language = 'en'

    with translation.override(language):
        with timezone.override(group_tz):
            weekday = format_date(
                pickup.date.astimezone(timezone.get_current_timezone()),
                'EEEE',
                locale=translation.to_locale(language),
            )
            time = format_time(
                pickup.date,
                format='short',
                locale=translation.to_locale(language),
                tzinfo=timezone.get_current_timezone(),
            )
            date = format_date(
                pickup.date.astimezone(timezone.get_current_timezone()),
                format='long',
                locale=translation.to_locale(language),
            )

            long_date = '{} {}, {}'.format(weekday, time, date)
            short_date = '{} {}'.format(weekday, time)

            reply_to_name = _('Pickup %(date)s') % {
                'date': short_date,
            }
            conversation_name = _('Pickup %(date)s') % {
                'date': long_date,
            }

            local_part = make_local_part(message.conversation, user)
            reply_to = formataddr(
                (reply_to_name,
                 '{}@{}'.format(local_part, settings.SPARKPOST_RELAY_DOMAIN)))
            from_email = formataddr(
                (message.author.display_name, settings.DEFAULT_FROM_EMAIL))

            return prepare_email('conversation_message_notification',
                                 from_email=from_email,
                                 user=user,
                                 reply_to=[reply_to],
                                 context={
                                     'conversation_name':
                                     conversation_name,
                                     'author':
                                     message.author,
                                     'message_content':
                                     message.content_rendered(),
                                     'conversation_url':
                                     pickup_detail_url(pickup),
                                     'mute_url':
                                     pickup_conversation_mute_url(
                                         pickup, message.conversation),
                                 })
Пример #51
0
def currency(number, currency = 'EUR'):
    locale = to_locale(get_language())
    if not number:
        return ""

    return format_currency(number, currency, locale = locale)