def login_user(request):
state = "Login Below...."
username = password = ''
if request.POST:
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
state = None
#state = "You're successfully logged in!"
else:
state = "Your account is not active, please contact the site admin."
else:
state = "Your username and/or password were incorrect."
# print "========="
# print state
print "=" * 50
print request.LANGUAGE_CODE
print translation.get_language_from_request(request)
#translation.activate('de')
print translation.get_language()
print "=" * 50
if state:
return render_to_response('auth.html', locals(), context_instance=RequestContext(request))
return render_to_response('chat.html', locals(), context_instance=RequestContext(request))
def process_request(self, request):
from django.utils import translation
path_tuple = request.path_info.split("/")
if len(path_tuple) > 1:
if path_tuple[1] in settings.NOT_LANG_URLS:
return
if check_for_language(path_tuple[1]):
lang = path_tuple[1]
if hasattr(request, 'session'):
request.session['django_language'] = lang
request.COOKIES['django_language'] = lang
set_default_language(lang)
request.path_info = "/" + "/".join(path_tuple[2:])
return
if hasattr(request, "session") and "django_language" in request.session:
lang = request.session["django_language"]
elif hasattr(request, "COOKIE") and "django_language" in request.COOKIE:
lang = request.COOKIE["django_language"]
elif check_for_language(get_language_from_request(request)):
set_default_language(get_language_from_request(request))
lang = get_language_from_request(request)
else:
lang = settings.LANGUAGES[settings.DEFAULT_LANGUAGE][0]
return HttpResponseRedirect('/%s%s' % (lang, request.path_info))
def get_language_from_request (self,request):
supported = dict(settings.LANGUAGES)
lang = settings.LANGUAGE_CODE[:2]
langs = "|".join(map(lambda l: l[0], settings.LANGUAGES))
check = re.match(r"^/(%s)/.*" % langs, request.path_info)
changed = False
if check is not None:
request.path = request.path[3:]
request.path_info = request.path_info[3:]
t = check.group(1)
if t in supported:
lang = t
if hasattr(request, "session"):
request.session["django_language"] = lang
else:
request.set_cookie("django_language", lang)
changed = True
else:
lang = translation.get_language_from_request(request)
if not changed:
if hasattr(request, "session"):
lang = request.session.get("django_language", None)
if lang in supported and lang is not None:
return lang
elif "django_language" in request.COOKIES.keys():
lang = request.COOKIES.get("django_language", None)
if lang in supported and lang is not None:
return lang
if not lang:
lang = translation.get_language_from_request(request)
return lang
def get_language_from_request(self,request):
changed = False
prefix = has_lang_prefix(request.path_info)
pages_root = urllib.unquote(reverse("home"))
if prefix:
request.path = request.path.split("/")
del request.path[pages_root.count('/')]
request.path = "/".join(request.path)
request.path_info = "/" + "/".join(request.path_info.split("/")[2:])
t = prefix
if t in SUPPORTED:
lang = t
if hasattr(request, "session"):
request.session["django_language"] = lang
changed = True
else:
lang = translation.get_language_from_request(request)
if not changed:
if hasattr(request, "session"):
lang = request.session.get("django_language", None)
if lang in SUPPORTED and lang is not None:
return lang
elif "django_language" in request.COOKIES.keys():
lang = request.COOKIES.get("django_language", None)
if lang in SUPPORTED and lang is not None:
return lang
if not lang:
lang = translation.get_language_from_request(request)
lang = get_default_language(lang)
return lang
def get_language_from_request (self,request):
changed = False
prefix = has_lang_prefix(request.path_info)
if prefix:
request.path = "/" + "/".join(request.path.split("/")[2:])
request.path_info = "/" + "/".join(request.path_info.split("/")[2:])
t = prefix
if t in self.SUPPORTED:
lang = t
if hasattr(request, "session"):
request.session["django_language"] = lang
changed = True
else:
lang = translation.get_language_from_request(request)
if not changed:
if hasattr(request, "session"):
lang = request.session.get("django_language", None)
if lang in self.SUPPORTED and lang is not None:
return lang
elif "django_language" in request.COOKIES.keys():
lang = request.COOKIES.get("django_language", None)
if lang in self.SUPPORTED and lang is not None:
return lang
if not lang:
lang = translation.get_language_from_request(request)
lang = 'tr'#get_default_language(lang)
return lang
def get_language_from_request(self,request):
changed = False
prefix = has_lang_prefix(request.path_info)
lang = None
if prefix:
request.path = "/" + "/".join((request.META.get('SCRIPT_URL', "") or request.path).split("/")[2:])
request.path_info = "/" + "/".join((request.META.get('SCRIPT_URL', "") or request.path_info).split("/")[2:])
t = prefix
if t in SUPPORTED:
lang = t
if hasattr(request, "session"):
request.session["django_language"] = lang
changed = True
else:
lang = translation.get_language_from_request(request)
if not changed:
if hasattr(request, "session"):
lang = request.session.get("django_language", None)
if lang in SUPPORTED and lang is not None:
return lang
elif "django_language" in request.COOKIES.keys():
lang = request.COOKIES.get("django_language", None)
if lang in SUPPORTED and lang is not None:
return lang
if not lang:
lang = translation.get_language_from_request(request)
if not lang:
lang = settings.LANGUAGE_CODE
return lang
def get_language_from_request(self, request):
changed = False
prefix = self.has_lang_prefix(request.path_info)
if prefix:
request.path = "/" + "/".join(request.path.split("/")[2:])
request.path_info = request.path
t = prefix
if t in self.get_supported_languages():
lang = t
if hasattr(request, "session") and request.session.get("django_language", None) != lang:
request.session["django_language"] = lang
changed = True
else:
lang = translation.get_language_from_request(request)
if not changed:
if hasattr(request, "session"):
lang = request.session.get("django_language", None)
if lang in self.get_supported_languages() and lang is not None:
return lang
elif "django_language" in request.COOKIES.keys():
lang = request.COOKIES.get("django_language", None)
if lang in self.get_supported_languages() and lang is not None:
return lang
if not lang:
lang = translation.get_language_from_request(request)
return lang
def _get_user_lang(self, request, profile):
try:
lang = profile.language
except:
lang = translation.get_language_from_request(request)
else:
supported = dict(settings.LANGUAGES)
if lang not in supported:
lang = translation.get_language_from_request(request)
return lang
def process_request(self, request):
if request.session.get('django_language'):
language = translation.get_language_from_request(request)
elif request.COOKIES.get('django_language'):
language = translation.get_language_from_request(request)
else:
language = 'nl'
#language = translation.get_language_from_request(request)
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
def form_valid(self, form):
lang = translation.get_language_from_request(self.request)
# Update translation in editing user's language
for an in form.instance.names.filter(language=lang):
an.altername = form.instance.name
an.save()
return super(UpdateLocationView, self).form_valid(form)
def form_valid(self, form):
# Create user instance with fixed username
form.instance.username = create_username(
form.instance.first_name,
form.instance.last_name
)
form.instance.is_active = False
form.instance.set_password(form.cleaned_data['password1'])
form.instance.save()
# Create token for mobile API
Token.objects.create(user=form.instance)
# Create registration link and save along with request params
salt = hashlib.md5()
salt.update(settings.SECRET_KEY + str(datetime.datetime.now().time))
register_demand = RegisterDemand.objects.create(
activation_link = salt.hexdigest(),
ip_address = ip.get_ip(self.request),
user = form.instance,
email = form.instance.email,
lang = translation.get_language_from_request(self.request)
)
# Create full link to activation page for new user
site_url = self.request.build_absolute_uri('/user/activate/')
link = site_url + str(register_demand.activation_link)
# Send email in user's own language if possible
email = emails.ActivationLink()
email_context = {'link': link}
if translation.check_for_language(register_demand.lang):
email_context.update({'lang': register_demand.lang})
email.send(register_demand.email, email_context)
return render(self.request, 'userspace/register-success.html',
{'title': _("Message send"),})
def get_context_data(self, **kwargs):
context = super(NavigationMixin, self).get_context_data(**kwargs)
language = get_language_from_request(self.request, check_path=True)
events_by_year = build_events_by_year(
events=(
Event.objects.namespace(self.namespace)
.future()
.active_translations(language)
.language(language)
)
)
context['events_by_year'] = events_by_year
archived_events_by_year = build_events_by_year(
events=(
Event.objects.namespace(self.namespace)
.archive()
.active_translations(language)
.language(language)
),
is_archive_view=True,
)
context['archived_events_by_year'] = archived_events_by_year
context['event_year'] = self.kwargs.get('year')
context['event_month'] = self.kwargs.get('month')
context['event_day'] = self.kwargs.get('day')
return context
def render(self, context, instance, placeholder):
self.render_template = (
'aldryn_events/plugins/list/%s/list.html' % instance.style
)
language = (
instance.language or
get_language_from_request(context['request'], check_path=True)
)
context['instance'] = instance
namespace = instance.app_config_id and instance.app_config.namespace
# check if we can reverse list view for configured namespace
# if no prepare a message to admin users.
if not is_valid_namespace(namespace):
# add message, should be properly handled in template
context['plugin_configuration_error'] = NO_APPHOOK_ERROR_MESSAGE
return context
# With Django 1.5 and because a bug in SortedManyToManyField
# we can not use instance.events or we get a error like:
# DatabaseError:
# no such column: aldryn_events_eventlistplugin_events.sort_value
events = (Event.objects.namespace(namespace)
.active_translations(language)
.language(language)
.filter(eventlistplugin__pk=instance.pk))
context['events'] = events
return context
def __init__(self, request=None):
self.user = AnonymousUser()
self.timezone = settings.TIME_ZONE
if request is not None:
self.language = get_language_from_request(request)
else:
self.language = settings.LANGUAGE_CODE
def get_nodes(self, request):
nodes = []
language = get_language_from_request(request, check_path=True)
# NOTE: It is important that we only get objects that have an active
# translation, otherwise, object.get_absolute_url() may return
# NoReverseMatch exceptions that we will have to catch, if we want to
# prevent errors from appearing on-screen.
things = (Thing.objects.published()
.language(language)
.active_translations(language))
if hasattr(self, 'instance') and self.instance: # pragma: no cover
# If self has a property `instance`, then we're using django CMS
# 3.0.12 or later, which supports using CMSAttachMenus on multiple,
# apphook'ed pages, each with their own apphook configuration. So,
# here we modify the queryset to reflect this.
app = apphook_pool.get_apphook(self.instance.application_urls)
if app:
things = things.namespace(self.instance.application_namespace)
for thing in things:
# This try/except seems like overkill here, but if this fails for
# any reason, this **and any further menus, even from other apps**
# may not get loaded, so we're extra careful.
try:
url = thing.get_absolute_url(language=language)
node = NavigationNode(thing.name, url, thing.pk)
nodes.append(node)
except NoReverseMatch: # pragma: no cover
pass
return nodes
def __init__(self, request=None):
self.user = AnonymousUser()
self.timezone = settings.TIME_ZONE
if request is None:
self.language = settings.LANGUAGE_CODE
else:
self.language = translation.get_language_from_request(request, check_path=True)
def render(self, context, instance, placeholder):
# translated filter the events, language set current language
language = get_language_from_request(context['request'],
check_path=True)
namespace = instance.app_config_id and instance.app_config.namespace
self.render_template = (
'aldryn_events/plugins/upcoming/%s/upcoming.html' % instance.style
)
context['instance'] = instance
# check if we can reverse list view for configured namespace
# if no prepare a message to admin users.
if not is_valid_namespace(namespace):
# add message, should be properly handled in template
context['plugin_configuration_error'] = NO_APPHOOK_ERROR_MESSAGE
return context
events = (Event.objects.namespace(namespace)
.active_translations(language)
.language(language))
if instance.past_events:
events = events.past(count=instance.latest_entries)
else:
events = events.upcoming(count=instance.latest_entries)
context['events'] = events
return context
def get_form_kwargs(self):
kwargs = super(EventDetailView, self).get_form_kwargs()
kwargs['event'] = self.event
kwargs['language_code'] = (
get_language_from_request(self.request, check_path=True)
)
return kwargs
def preferences(request):
if request.method == 'POST':
form = PreferencesForm(request.POST)
if form.is_valid():
try:
newdata = form.cleaned_data
request.user.language = newdata['language']
request.user.theme = newdata['theme']
request.user.pagesize = newdata['pagesize']
request.user.save()
# Switch to the new theme and language immediately
request.theme = newdata['theme']
if newdata['language'] == 'auto':
newdata['language'] = translation.get_language_from_request(request)
if translation.get_language() != newdata['language']:
translation.activate(newdata['language'])
request.LANGUAGE_CODE = translation.get_language()
messages.add_message(request, messages.INFO, force_unicode(_('Successfully updated preferences')))
except Exception as e:
logger.error("Failure updating preferences: %s" % e)
messages.add_message(request, messages.ERROR, force_unicode(_('Failure updating preferences')))
else:
pref = request.user
form = PreferencesForm({
'language': pref.language,
'theme': pref.theme,
'pagesize': pref.pagesize,
})
return render_to_response('common/preferences.html', {
'title': _('Edit my preferences'),
'form': form,
},
context_instance=RequestContext(request))
def get_queryset(self):
qs = (super(EventListView, self).get_queryset()
.namespace(self.namespace))
if not self.request.GET.get('all_languages', False):
language = get_language_from_request(self.request, check_path=True)
qs = qs.active_translations(language).language(language)
year = self.kwargs.get('year')
month = self.kwargs.get('month')
day = self.kwargs.get('day')
self.archive_qs = []
if year or month or day:
tz = get_current_timezone()
if year and month and day:
year, month, day = map(int, [year, month, day])
_date = date(year, month, day)
qs = qs.filter(
Q(start_date=_date, end_date__isnull=True) |
Q(start_date__lte=_date, end_date__gte=_date)
).published()
elif year and month:
year, month = map(int, [year, month])
date_start = date(year, month, 1)
date_end = date_start + relativedelta(months=1, days=-1)
qs = qs.filter(
Q(start_date__range=(date_start, date_end),
end_date__isnull=True) |
Q(start_date__range=(date_start, date_end),
end_date__lte=date_end) |
Q(start_date__lt=date_start,
end_date__range=(date_start, date_end)) |
Q(start_date__lt=date_start,
end_date__gte=date_end)
).published()
else:
year = int(year)
date_start = date(year, 1, 1)
date_end = date_start + relativedelta(years=1, days=-1)
qs = qs.filter(
Q(start_date__range=(date_start, date_end),
end_date__isnull=True) |
Q(start_date__range=(date_start, date_end),
end_date__lte=date_end) |
Q(start_date__lt=date_start,
end_date__range=(date_start, date_end))
).published()
else:
if self.archive:
qs = qs.archive()
else:
self.archive_qs = qs.archive().order_by(*ORDERING_FIELDS)
qs = qs.future()
return qs.order_by(*ORDERING_FIELDS).distinct()
def get_published_pagelist(self, request, *args, **kwargs):
"""
This view is used by the SearchLinkField as the user types to feed the autocomplete drop-down.
"""
if not request.is_ajax():
return HttpResponseForbidden()
query_term = request.GET.get('term','').strip('/')
language = get_language_from_request(request)
matching_published_pages = Page.objects.published().public().filter(
Q(title_set__title__icontains=query_term, title_set__language=language)
| Q(title_set__path__icontains=query_term, title_set__language=language)
| Q(title_set__menu_title__icontains=query_term, title_set__language=language)
| Q(title_set__page_title__icontains=query_term, title_set__language=language)
).distinct().order_by('title_set__title').iterator()
data = {'results': []}
for page in matching_published_pages:
title = page.get_title(language=language)
path = page.get_absolute_url(language=language)
data['results'].append({
'id': page.pk,
'text': format_page_link(title, path),
})
if len(data['results']) > 15:
break
return JsonResponse(data)
def process_request(self, request):
if request.user.is_authenticated():
try:
# Here we try to load profile, but can get error
# if user created during syncdb but profile model
# under south control. (Like pybb.Profile).
profile = util.get_pybb_profile(request.user)
except ObjectDoesNotExist:
# Ok, we should create new profile for this user
# and grant permissions for add posts
# It should be caused rarely, so we move import signal here
# to prevent circular import
from pybb.models import user_saved
user_saved(request.user, created=True)
profile = util.get_pybb_profile(request.user)
language = translation.get_language_from_request(request)
if not profile.language:
profile.language = language
profile.save()
if profile.language and profile.language != language:
request.session['django_language'] = profile.language
translation.activate(profile.language)
request.LANGUAGE_CODE = translation.get_language()
def process_request(self, request):
try:
language = request.COOKIES['language']
except:
language = translation.get_language_from_request(request)
translation.activate(language)
request.LANGUAGE_CODE = language
def get_obj_from_request(model, request,
pk_url_kwarg='pk',
slug_url_kwarg='slug',
slug_field='slug'):
"""
Given a model and the request, try to extract and return an object
from an available 'pk' or 'slug', or return None.
Note that no checking is done that the view's kwargs really are for objects
matching the provided model (how would it?) so use only where appropriate.
"""
language = get_language_from_request(request, check_path=True)
kwargs = request.resolver_match.kwargs
mgr = model.objects
if pk_url_kwarg in kwargs:
return mgr.filter(pk=kwargs[pk_url_kwarg]).first()
elif slug_url_kwarg in kwargs:
# If the model is translatable, and the given slug is a translated
# field, then find it the Parler way.
filter_kwargs = {slug_field: kwargs[slug_url_kwarg]}
translated_fields = model._parler_meta.get_translated_fields()
if (issubclass(model, TranslatableModel) and
slug_url_kwarg in translated_fields):
return mgr.active_translations(language, **filter_kwargs).first()
else:
# OK, do it the normal way.
return mgr.filter(**filter_kwargs).first()
else:
return None
def get_context_data(self, **kwargs):
ctx = super(EventDatesView, self).get_context_data(**kwargs)
today = timezone.now().date()
year = ctx.get('year', today.year)
month = ctx.get('month', today.month)
# Get plugin if possible so we can use language and namespace from
# plugin, if not possible get namespace from view, language from
# request
try:
pk = self.request.GET['plugin_pk'] or None
plugin = EventCalendarPlugin.objects.get(pk=pk)
except (EventCalendarPlugin.DoesNotExist, KeyError):
namespace = self.namespace
language = get_language_from_request(self.request, check_path=True)
else:
namespace = plugin.app_config.namespace
language = plugin.language
# calendar is the calendar tag
site_id = getattr(get_current_site(self.request), 'id')
ctx['calendar_tag'] = build_calendar_context(
year, month, language, namespace, site_id
)
return ctx
def process_request(self, request):
path=request.META["PATH_INFO"]
for nol in noLocalePath:
if path.find(nol)==0:
request.isLocaled=False
return
#print path
request.isLocaled=True
language = translation.get_language_from_request(request)
translation.activate(language)
try:
from mysite.urls import surl
from base.models import appOptions
from dbapp.urls import dbapp_url
request.surl=surl
request.dbapp_url=dbapp_url
cache_title=cache.get("browse_title")
if cache_title:
request.browse_title=cache_title
else:
request.browse_title=appOptions["browse_title"]
cache.set("browse_title",appOptions["browse_title"],24*60*60)
except Exception ,e:
from traceback import print_exc
print print_exc()
pass
def render_html(self, product, postfix):
"""
Return a HTML snippet containing a rendered summary for this product.
Build a template search path with `postfix` distinction.
"""
if not self.label:
msg = "The Product Serializer must be configured using a `label` field."
raise exceptions.ImproperlyConfigured(msg)
app_label = product._meta.app_label.lower()
product_type = product.__class__.__name__.lower()
request = self.context["request"]
cache_key = "product:{0}|{1}-{2}-{3}-{4}-{5}".format(
product.id, app_label, self.label, product_type, postfix, get_language_from_request(request)
)
content = cache.get(cache_key)
if content:
return mark_safe(content)
params = [
(app_label, self.label, product_type, postfix),
(app_label, self.label, "product", postfix),
("shop", self.label, "product", postfix),
]
try:
template = select_template(["{0}/products/{1}-{2}-{3}.html".format(*p) for p in params])
except TemplateDoesNotExist:
return SafeText("<!-- no such template: '{0}/products/{1}-{2}-{3}.html' -->".format(*params[0]))
# when rendering emails, we require an absolute URI, so that media can be accessed from
# the mail client
absolute_base_uri = request.build_absolute_uri("/").rstrip("/")
context = RequestContext(request, {"product": product, "ABSOLUTE_BASE_URI": absolute_base_uri})
content = strip_spaces_between_tags(template.render(context).strip())
cache.set(cache_key, content, shop_settings.CACHE_DURATIONS["product_html_snippet"])
return mark_safe(content)
def _find_remote_autoplay_language(self, request):
language = None
if request.user.is_anonymous() or request.user.preferred_language == '':
language = translation.get_language_from_request(request)
else:
language = request.user.preferred_language
return language if language != '' else None
def get_on_delete_redirect_url(self, event):
language = getattr(
self, 'current_lang', get_language_from_request(
self.request, check_path=True))
with force_language(language):
return reverse('{0}:events_list'.format(
event.app_config.namespace))
def get_context(self, request, **kwargs):
filter_kwargs = {'id': request.data.get('id')}
if hasattr(self.product_model, 'translations'):
filter_kwargs.update(translations__language_code=get_language_from_request(self.request))
queryset = self.product_model.objects.filter(self.limit_choices_to, **filter_kwargs)
product = get_object_or_404(queryset)
return {self.product_field: product, 'request': request}
def create(cls, request=None, **kwargs):
create_email = kwargs.pop("create_email", True)
confirm_email = kwargs.pop("confirm_email", None)
account = cls(**kwargs)
if "language" not in kwargs:
if request is None:
account.language = DEFAULT_LANGUAGE
else:
account.language = translation.get_language_from_request(request, check_path=True)
account.save()
if create_email and account.user.email:
kwargs = {"primary": True}
if confirm_email is not None:
kwargs["confirm"] = confirm_email
EmailAddress.objects.add_email(account.user, account.user.email, **kwargs)
return account
def get_form_kwargs(self, step=None):
"""This is called by self.get_form()"""
kwargs = super(WizardCreateView, self).get_form_kwargs()
kwargs['wizard_user'] = self.request.user
if self.is_second_step(step):
kwargs['wizard_page'] = self.get_origin_page()
kwargs['wizard_language'] = self.get_origin_language()
else:
page_pk = self.page_pk or self.request.GET.get('page', None)
if page_pk and page_pk != 'None':
kwargs['wizard_page'] = Page.objects.filter(pk=page_pk).first()
else:
kwargs['wizard_page'] = None
kwargs['wizard_language'] = self.request.GET.get(
'language', get_language_from_request(self.request))
return kwargs
def process_request(self, request):
if isinstance(request.user, AnonymousUser):
# Anonymous users don't have preferences
language = "auto"
request.theme = settings.DEFAULT_THEME
request.pagesize = settings.DEFAULT_PAGESIZE
else:
language = request.user.language
request.theme = request.user.theme or settings.DEFAULT_THEME
request.pagesize = request.user.pagesize or settings.DEFAULT_PAGESIZE
if language == "auto":
language = translation.get_language_from_request(request)
if translation.get_language() != language:
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
request.charset = settings.DEFAULT_CHARSET
def preferences(request):
if request.method == 'POST':
form = PreferencesForm(request.POST)
form.user = request.user
if form.is_valid():
try:
newdata = form.cleaned_data
request.user.language = newdata['language']
request.user.theme = newdata['theme']
request.user.pagesize = newdata['pagesize']
if newdata['cur_password']:
request.user.set_password(newdata["new_password1"])
# Updating the password logs out all other sessions for the user
# except the current one if
# django.contrib.auth.middleware.SessionAuthenticationMiddleware
# is enabled.
update_session_auth_hash(request, form.user)
request.user.save()
# Switch to the new theme and language immediately
request.theme = newdata['theme']
if newdata['language'] == 'auto':
newdata[
'language'] = translation.get_language_from_request(
request)
if translation.get_language() != newdata['language']:
translation.activate(newdata['language'])
request.LANGUAGE_CODE = translation.get_language()
messages.add_message(
request, messages.INFO,
force_text(_('Successfully updated preferences')))
except Exception as e:
logger.error("Failure updating preferences: %s" % e)
messages.add_message(
request, messages.ERROR,
force_text(_('Failure updating preferences')))
else:
pref = request.user
form = PreferencesForm({
'language': pref.language,
'theme': pref.theme,
'pagesize': pref.pagesize,
})
return render_to_response('common/preferences.html', {
'title': _('Edit my preferences'),
'form': form,
},
context_instance=RequestContext(request))
def list(self, request, version):
"""
Person search endpoint: pass query params to ElasticSearch so it filters
persons and returns a list of matching items
"""
# Instantiate the form to allow validation/cleaning
params_form = self._meta.indexer.form(data=request.query_params)
# Return a 400 with error information if the query params are not valid
if not params_form.is_valid():
return Response(status=400, data={"errors": params_form.errors})
limit, offset, query = params_form.build_es_query()
query["sort"] = [
{f"title_raw.{get_language_from_request(request)}": {"order": "asc"}}
]
# pylint: disable=unexpected-keyword-arg
search_query_response = ES_CLIENT.search(
_source=getattr(self._meta.indexer, "display_fields", "*"),
index=self._meta.indexer.index_name,
body=query,
# Directly pass meta-params through as arguments to the ES client
from_=offset,
size=limit or getattr(settings, "RICHIE_ES_PAGE_SIZE", ES_PAGE_SIZE),
)
# Format the response in a consumer-friendly way
# NB: if there are 0 hits the query response is formatted the exact same way, only the
# .hits.hits array is empty.
response_object = {
"meta": {
"count": len(search_query_response["hits"]["hits"]),
"offset": offset,
"total_count": search_query_response["hits"]["total"]["value"],
},
"objects": [
self._meta.indexer.format_es_object_for_api(
person,
# Get the best language to return multilingual fields
get_language_from_request(request),
)
for person in search_query_response["hits"]["hits"]
],
}
return Response(response_object)
def redirect_homepage(self, request):
if request.path not in settings.REDIRECTED_PATHS:
return
language = get_language_from_request(request)
if language not in self.LANGUAGES:
language = settings.DEFAULT_LANGUAGE
querystring = request.META.get('QUERY_STRING', '')
if querystring:
querystring = '?' + querystring
return HttpResponseRedirect(''.join([
'http://', language, '.', settings.BASE_DOMAIN, request.path,
querystring
]))
def cart_modal(request):
try:
translation.activate(translation.get_language_from_request(request))
cart_obj = CartService(request).cart_model
cart_products = cart_obj.products.all()
return HttpResponse(status=200,
content=render_to_string("cart/cart_modal.html",
context={
'cart':
cart_obj,
'cart_products':
cart_products
}))
except ObjectDoesNotExist:
return HttpResponseBadRequest()
def hobbies(request):
if 'color' in request.COOKIES.keys() and 'color2' in request.COOKIES.keys() and 'colorbw' in request.COOKIES.keys():
color = request.COOKIES['color']
color2 = request.COOKIES['color2']
colorbw = request.COOKIES['colorbw']
else:
resp = HttpResponse('')
color = '#9DCC1E'
color2 = '#4F660F'
colorbw = '#FFFFFF'
resp.set_cookie('color',color)
resp.set_cookie('color2',color2)
resp.set_cookie('color',colorbw)
rubix = video.objects.all().get(pk=4)
maxit = video.objects.all().get(pk=5)
lang = translation.get_language_from_request(request)
return render(request, 'hobbies.html', {'name':'Jan', 'color':color, 'color2':color2, 'colorbw':colorbw, 'rubix':rubix, 'maxit':maxit, 'lang':lang})
def get_extra_placeholder_menu_items(cls, request, placeholder):
data = {
'placeholder': placeholder.pk,
'language': get_language_from_request(request, check_path=True),
}
endpoint = add_url_parameters(admin_reverse(CREATE_ALIAS_URL_NAME),
**data)
menu_items = [
PluginMenuItem(
_('Create Alias'),
endpoint,
action='modal',
attributes={'icon': 'alias'},
),
]
return menu_items
def perform_mutate(cls, form, info):
request = info.context
scf = get_scaffolding(request)
if not scaffolding_has_rental_history_request_info(scf):
cls.log(
info,
"User has not completed the rental history form, aborting mutation."
)
return cls.make_error(
"You haven't completed all the previous steps yet.")
rhr = models.RentalHistoryRequest(
first_name=scf.first_name,
last_name=scf.last_name,
apartment_number=scf.apt_number,
phone_number=scf.phone_number,
address=scf.street,
address_verified=scf.address_verified,
borough=scf.borough,
zipcode=scf.zip_code,
)
rhr.set_user(request.user)
rhr.full_clean()
rhr.save()
slack.sendmsg_async(get_slack_notify_text(rhr), is_safe=True)
email = react_render_email(
SITE_CHOICES.JUSTFIX,
project.locales.DEFAULT,
"rh/email-to-dhcr.txt",
session=request.session,
)
email_dhcr.send_email_to_dhcr(email.subject, email.body)
trigger_followup_campaign_async(
f"{scf.first_name} {scf.last_name}",
scf.phone_number,
"RH",
locale=translation.get_language_from_request(request,
check_path=True),
)
# Note that we used to purge the scaffolding information here, but lots
# of users go on to create an account after this, and we don't want them
# to have to re-enter all their information, so we'll keep it around.
return cls.mutation_success()
def calendar(context, year, month, language=None, namespace=None):
template_name = 'aldryn_events/includes/calendar.html'
if not namespace:
namespace, config = get_app_instance(context['request'])
if not language:
language = get_language_from_request(context['request'],
check_path=True)
t = get_template(template_name)
try:
EventsConfig.objects.get(namespace=namespace)
except EventsConfig.DoesNotExist:
context['namespace_error'] = ERROR_MESSAGE.format(namespace)
else:
context['calendar_tag'] = build_calendar_context(
year, month, language, namespace)
rendered = t.render(context.flatten())
return rendered
def climate_for_city(request, city):
weather_object = None
language = get_language_from_request( request )
weather_service = OpenWeatherService( settings.OPENWEATHER_URL, q=city,
appid=settings.WEATHER_KEY, units="metric", lang=language )
loop = asyncio.new_event_loop()
asyncio.set_event_loop( loop )
weather_object = loop.run_until_complete( weather_service.get_async_data() )
if not weather_object:
messages.error( request, _( 'Please enter valid city name' ) )
return redirect( climate )
args = {
"weather_object": weather_object
}
return render( request, 'weather/climate-city.html', args )
def moduleview(request, course=None, module=None):
lang = get_language_from_request(request)
if course:
try:
c = Course.objects.language(lang).get(slug=course)
except Course.DoesNotExist:
c = None
else:
c = None
try:
m = Module.objects.language(lang).get(slug=module)
except Module.DoesNotExist:
return HttpResponseNotFound()
c = {"module": m, "instance": m, "course": c}
return render_to_response("courses/module.html",
c,
context_instance=RequestContext(request))
def populate(self):
# setup the extension toolbar with permissions and sanity checks
current_page_menu = self._setup_extension_toolbar()
# if it's all ok
if current_page_menu and self.toolbar.edit_mode:
# retrieves the instances of the current title extension (if any) and the toolbar item url
lang = get_language_from_request(self.request, check_path=True)
print lang
urls = self.get_title_extension_admin(lang)
print urls
# cycle through the title list
for title_extension, url in urls:
# adds toolbar items
current_page_menu.add_modal_item(
'SEO Keywords',
url=url,
disabled=not self.toolbar.edit_mode)
def save(self, commit=True):
social_account = super(AdvertSocialAccountForm,
self).save(commit=False)
social_network = SocialNetwork.get_social_network(
link=social_account.link)
social_account.social_network = social_network
external_logo = self.cleaned_data['external_logo']
if external_logo:
social_account.logo.save(external_logo._origin_name, external_logo,
False)
if social_account.pk is None or 'link' in self.changed_data:
if social_account.pk is None:
phrase_obj = Phrase.get_rand_phrase(
get_language_from_request(self.request))
if phrase_obj is not None:
social_account.confirmation_code = phrase_obj.phrase
else:
social_account.confirmation_code = get_random_string(
length=32)
social_account_confirm_link = self.request.session.get(
'social_account_confirm_link', None)
social_account_confirm_status = self.request.session.get(
'social_account_confirm_status', None)
if (social_account_confirm_link is not None
and social_account_confirm_status is not None
and social_account.link == social_account_confirm_link):
social_account.confirmed = bool(social_account_confirm_status)
else:
social_account.confirmed = False
if commit:
social_account.save()
if 'social_account_confirm_link' in self.request.session:
del self.request.session['social_account_confirm_link']
if 'social_account_confirm_status' in self.request.session:
del self.request.session['social_account_confirm_status']
return social_account
def get_extra_plugin_menu_items(cls, request, plugin):
if plugin.plugin_type == cls.__name__:
edit_endpoint = plugin.alias.get_absolute_url()
detach_endpoint = admin_reverse(
DETACH_ALIAS_PLUGIN_URL_NAME,
args=[plugin.pk],
)
plugin_menu_items = [
PluginMenuItem(
_('Edit Alias'),
edit_endpoint,
action='',
attributes={'icon': 'alias'},
),
]
if cls.can_detach(
request.user,
plugin.placeholder,
plugin.alias.get_plugins(),
):
plugin_menu_items.append(
PluginMenuItem(
_('Detach Alias'),
detach_endpoint,
action='modal',
attributes={'icon': 'alias'},
))
return plugin_menu_items
data = {
'plugin': plugin.pk,
'language': get_language_from_request(request, check_path=True),
}
endpoint = add_url_parameters(admin_reverse(CREATE_ALIAS_URL_NAME),
**data)
return [
PluginMenuItem(
_('Create Alias'),
endpoint,
action='modal',
attributes={'icon': 'alias'},
),
]
def dispatch(self, request, *args, **kwargs):
self.namespace, self.config = get_app_instance(request)
language = get_language_from_request(request, check_path=True)
self.queryset = (Event.objects.namespace(
self.namespace).published().language(language).order_by(
*ORDERING_FIELDS))
self.event = self.queryset.active_translations(
language, slug=kwargs['slug']).first()
if not self.event:
raise Http404("Event not found")
set_language_changer(request, self.event.get_absolute_url)
setattr(self.request, request_events_event_identifier, self.event)
if hasattr(request, 'toolbar'):
request.toolbar.set_object(self.event)
return super(EventDetailView, self).dispatch(request, *args, **kwargs)
def process_request(self, request):
if request.path_info in IGNORE:
return
locale, path = self.split_locale_from_request(request)
locale_path = utils.locale_path(path, locale or translation.get_language_from_request(request) \
or translation.get_language())
if locale_path != request.path_info:
if request.META.get("QUERY_STRING", ""):
locale_path = "%s?%s" % (locale_path,
request.META['QUERY_STRING'])
return HttpResponseRedirect(locale_path)
request.path_info = path
if not locale:
locale = translation.get_language() or settings.LANGUAGE_CODE
translation.activate(locale)
request.LANGUAGE_CODE = translation.get_language()
def language(request):
"""
Sets language depending on the profile.
"""
language = get_language_from_request(request)
content = {
'lan': language if language else settings.LANGUAGE_CODE,
'languages': dict(settings.LANGUAGES).keys(),
}
if request.user.is_authenticated:
# Optimizacion of language selector
language = Profile.objects.filter(user_id=request.user.id).values_list(
'language', flat=True).first()
content['lan'] = language
return content
return content
def process_request(request):
full_path_parts = request.get_full_path().split('/')
request_lang = None
if len(full_path_parts) > 2 and len(full_path_parts[1]) == 2:
request_lang = full_path_parts[1]
lang = (request_lang or translation.get_language_from_request(
request, check_path=False) or settings.DEFAULT_LANGUAGE).lower()
available_langs = settings.LANGUAGE_CODES_PUBLIC
if lang not in available_langs:
raise Http404(_('Язык "%s" не зарегистрирован в системе') % lang)
translation.activate(lang)
request.LANGUAGE_CODE = lang
request.session[settings.LANGUAGE_COOKIE_NAME] = lang
return None
def process_request(self, request):
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
(
i18n_patterns_used,
prefixed_default_language,
) = is_language_prefix_patterns_used(urlconf)
language = translation.get_language_from_request(
request, check_path=i18n_patterns_used
)
language_from_path = translation.get_language_from_path(request.path_info)
if (
not language_from_path
and i18n_patterns_used
and not prefixed_default_language
):
language = settings.LANGUAGE_CODE
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
def publish_post(self, request, pk):
"""
Admin view to publish a single post
:param request: request
:param pk: primary key of the post to publish
:return: Redirect to the post itself (if found) or fallback urls
"""
language = get_language_from_request(request, check_path=True)
try:
post = News.objects.get(pk=int(pk))
post.publish = True
post.save()
return HttpResponseRedirect(post.get_absolute_url(language))
except Exception:
try:
return HttpResponseRedirect(request.META['HTTP_REFERER'])
except KeyError:
return HttpResponseRedirect(reverse('oscar_news:posts-latest'))
def get_context_data(self, **kwargs):
context = super(NavigationMixin, self).get_context_data(**kwargs)
language = get_language_from_request(self.request, check_path=True)
events_by_year = build_events_by_year(
events=(Event.objects.namespace(self.namespace).future().
active_translations(language).language(language)))
context['events_by_year'] = events_by_year
archived_events_by_year = build_events_by_year(
events=(Event.objects.namespace(
self.namespace).archive().active_translations(
language).language(language)),
is_archive_view=True,
)
context['archived_events_by_year'] = archived_events_by_year
context['event_year'] = self.kwargs.get('year')
context['event_month'] = self.kwargs.get('month')
context['event_day'] = self.kwargs.get('day')
return context
def render_to_response(self, context, **response_kwargs):
try:
author = EtherpadAuthor.objects.get(user=self.request.user)
except EtherpadAuthor.DoesNotExist:
author = None
if author is None or not self.object.group in author.group.all():
raise PermissionDenied
response = super(EtherPadEditView,
self).render_to_response(context, **response_kwargs)
expires = datetime.datetime.utcnow() + datetime.timedelta(
seconds=SESS_LENGTH)
client = EtherpadLiteClient(
base_params={'apikey': settings.ETHERPAD_API_KEY},
base_url=settings.ETHERPAD_INTERNAL_URL)
result = client.createSession(groupID=self.object.group.etherpad_id,
authorID=author.etherpad_id,
validUntil=time.mktime(
expires.timetuple()).__str__())
# Delete the existing session first (if there is any)
if ('padSessionID' and 'sessionID' in self.request.COOKIES):
try:
client.deleteSession(
sessionID=self.request.COOKIES['sessionID'])
except EtherpadException:
pass
response.delete_cookie('sessionID')
response.delete_cookie('padSessionID')
# Set the new session cookie for both the server and the local site
# This will not work if etherpad-lite is running on external host.
# TODO: we probably should set cookie for server.external_url
response.set_cookie('sessionID',
value=result['sessionID'],
expires=expires,
httponly=False)
response.set_cookie('padSessionID',
value=result['sessionID'],
expires=expires,
httponly=False)
response.set_cookie('language',
value=translation.get_language_from_request(
self.request),
expires=expires,
httponly=False)
return response
def render(self,
request,
place,
context,
block_content_relation=None,
*args,
**kwargs):
language_get = request.GET.get('set_language', None)
# if we just change the language, get_language_from_request function does
# not work fine, so first we check if the language have changed now
language = language_get or get_language_from_request(request)
return self.render_block(
request,
template_name='googlesearch/block_googlesearch.html',
block_title=_('Search'),
context={
'plugin_config': self.get_config(),
'language': language
})
def test_admin_set_trad(self):
# Given no DifficultyLevel is present in the database
self.assertEquals(DifficultyLevel.objects.all().count(), 0)
# login
success = login_from_cred(self.client, self.cred)
self.assertTrue(success)
add_difficulty_url = admin_add_url_from_model(DifficultyLevel)
response = self.client.get(add_difficulty_url)
self.assertEquals(response.status_code, 200)
# Get data for DifficultyLevel creation and create it through admin view
data = self.get_dummy_data_trad()
response = self.client.post(add_difficulty_url, data, follow=True)
self.assertRedirects(response,
admin_list_url_from_model(DifficultyLevel))
self.assertEquals(response.status_code, 200)
iss = DifficultyLevel.objects.all()
self.assertEquals(
len(iss), 1, "One and only one DifficultyLevel should be created")
# This may test too much.
# Test language translation for DifficultyLevel.difficulty works
# Given the language set, it returns the appropriate version (fr, it, en)
orig_language = translation.get_language_from_request(
response._request)
restore_language = lambda: translation.activate(orig_language)
difficulty_trad = self.get_dummy_data_trad()
intervention_difficulty = iss[0]
for language in ('fr', 'it', 'en'):
translation.activate(language)
translated_difficulty = difficulty_trad['difficulty_%s' % language]
self.assertEquals(intervention_difficulty.difficulty,
translated_difficulty)
restore_language()
def create_order(request):
if request.method == 'POST':
if CartService.exists(request):
form = OrderForm(request.POST)
if form.is_valid():
cart_service = CartService(request)
lang_code = get_language_from_request(request)
cart_service.check_out(request)
OrderServices.create_order(cart_service.cart_model, form,
lang_code)
return redirect('successful_order')
else:
return HttpResponse(form.errors.as_json(), status=400)
else:
return HttpResponseBadRequest("cart not found")
else:
return HttpResponseBadRequest()
def process_request(self, request):
query_language = request.GET.get('hl')
if query_language:
language = query_language
lang_codes = set(lang[0][:2] for lang in settings.LANGUAGES)
if language[:2] not in lang_codes:
url = remove_query_param_from_url(request.get_full_path(),
'hl')
return render_to_response('404.html',
{'url_without_language': url},
status=404)
elif hasattr(
request, 'user'
) and request.user.is_authenticated and not request.user.is_anonymous:
language = request.user.userprofile.language
else:
language = translation.get_language_from_request(request)
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
def get_lang_version(self, request=None):
if request is not None:
lang = get_language_from_request(request)
try:
return self.language_versions.get(language=lang)
except NodeLanguageVersion.DoesNotExist:
pass
try:
return self.language_versions.get(language=get_language())
except NodeLanguageVersion.DoesNotExist:
pass
try:
return self.language_versions.get(language=settings.LANGUAGE_CODE)
except NodeLanguageVersion.DoesNotExist:
pass
return self.language_versions.first()
def process_request(self, request):
language = translation.get_language_from_request(request)
requested_language = request.REQUEST.get('language', None)
if requested_language and requested_language != language \
and check_for_language(requested_language):
language = requested_language
if hasattr(request, 'session'):
request.session['django_language'] = language
else:
next = request.REQUEST.get('next', None)
if not next:
next = request.META.get('HTTP_REFERER', None)
if not next:
next = '/'
response = HttpResponseRedirect(next)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language)
return response
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
