def send_existing_project_link_submission_notification_email(request, obj):
""" When someone has completed the form to submit a new existing challenge
site for the overview, let this know to all admins of the main project
params:
obj: a ProjectMetaData object, which is the database object which
has just been created by submitting the form
"""
title = 'Existing project form submitted:"{0}"'.format(obj.title)
mainproject = ComicSite.objects.get(short_name=settings.MAIN_PROJECT_NAME)
kwargs = {"obj": obj, "site": get_current_site(request), "mainproject": mainproject}
for admin in mainproject.get_admins():
if admin.email == "":
continue
kwargs["admin"] = admin
logger.info("Sending existing project submission notification email to '{}'".format(admin.email))
send_templated_email(
title,
"admin/emails/existing_project_link_submission_notification_email.txt",
kwargs,
[admin.email],
"noreply@" + get_current_site(request).domain,
fail_silently=False,
)
def share_survey(request):
survey_id = request.POST.get('survey_id');
email_data = request.POST.get('collaborators');
owner_message = request.POST.get('owner_message');
success_emails = []
fail_emails = []
emails = [e.strip() for e in email_data.split(',')]
for e in emails:
if is_valid_email(e):
success_emails.append(e)
else:
fail_emails.append(e)
survey = Survey.objects.get(id=survey_id)
survey_url = "http://%s%s" % (get_current_site(request).domain, survey.get_absolute_url())
if request.user.first_name and request.user.last_name:
message = "%s %s (%s) invites you to take the survey.\n\nFollow this link to open the survey:\n%s\n\n%s" % (
request.user.first_name, request.user.last_name, request.user.email, survey_url, owner_message)
else:
message = "%s (%s) invites you to take the survey.\n\nFollow this link to open the survey:\n%s\n\n%s" % (
request.user.username, request.user.email, survey_url, owner_message)
send_mail('You are invited to do a survey', message, "noreply@%s" % get_current_site(request).domain,
success_emails)
if len(fail_emails) > 0:
messages.error(request, "Email %s is invalid" % (', ').join(fail_emails))
if len(success_emails) > 0:
messages.success(request, 'You have successfully share with %s' % (', ').join(success_emails))
return HttpResponseRedirect("/account")
def save(self, *args, **kwargs):
"""
The save method should create a new OrganizationUser linking the User
matching the provided email address. If not matching User is found it
should kick off the registration process. It needs to create a User in
order to link it to the Organization.
"""
try:
user = get_user_model().objects.get(email__iexact=self.cleaned_data['email'])
except get_user_model().MultipleObjectsReturned:
raise forms.ValidationError(_("This email address has been used multiple times."))
except get_user_model().DoesNotExist:
user = invitation_backend().invite_by_email(
self.cleaned_data['email'],
**{'domain': get_current_site(self.request),
'organization': self.organization,
'sender': self.request.user})
else:
notification_backend().notify_by_email(self.cleaned_data['email'],
**{'domain': get_current_site(self.request),
'organization': self.organization,
'sender': self.request.user})
return OrganizationUser.objects.create(user=user,
organization=self.organization,
is_admin=self.cleaned_data['is_admin'])
def write(request, slug_story, activation_key, t='stories/write.html', d={}):
story = get_object_or_404(Story, slug=slug_story)
active_membership = story.active_membership()
d['story']=story
if not active_membership:
story.turn_membership()
return render(request, 'stories/done.html', d)
membership = get_object_or_404(Membership, activation_key=activation_key)
if active_membership.id != membership.id:
return render(request, 'stories/done.html', d)
new_line = Line(story=story)
if request.POST:
line_form=LineForm(request.POST, prefix='line', instance=new_line)
if line_form.is_valid():
line_form.save()
next = story.turn_membership()
mail_d = {
'story': story,
'site': get_current_site(request)
}
message = render_to_string('stories/email.txt', mail_d)
email = EmailMessage(
'Estas participando del concurso',
message,
to=[next.user.email])
email.send()
return render(request, 'stories/done.html', d)
else:
line_form=LineForm(prefix='line')
d = {
'form': line_form,
'story': story,
'site': get_current_site(request)
}
return render(request, t, d)
def get_current_domain(request=None):
from django.conf import settings
from django.contrib.sites.models import get_current_site
# Server name
if getattr(settings, 'FORCE_DOMAIN', None) is not None:
servername = settings.FORCE_DOMAIN
else:
try:
servername = get_current_site(request).domain.split(':', 1)[0]
except:
global _servername
if _servername is None:
_servername = socket.getfqdn()
servername = _servername
# Port
scheme = get_current_scheme(request)
if getattr(settings, 'FORCE_PORT', None) is not None:
port = int(settings.FORCE_PORT)
else:
try:
port = int(get_current_site(request).domain.split(':', 1)[1])
except:
port = 80 if scheme == 'http' else 443
if (scheme == 'http' and port != 80) or (scheme == 'https' and port != 443):
return servername + (':%s' % port)
else:
return servername
def to_json(self):
"""
Returns a json representation of an Assertion according to the OBI specifications
TODO: Make this not crash if the user doesn't have an associated email address
"""
sha = hashlib.sha256()
sha.update(self.userbadge.user.user.email)
identity_hash = "sha256$" + sha.digest()
badge_url = ''.join(['http://', get_current_site(None).domain, self.userbadge.badge.get_absolute_url()])
assertion_url = ''.join(['http://', get_current_site(None).domain, self.get_absolute_url()])
data = {
'uid': self.pk,
'recipient': {
'identity': identity_hash,
'type': 'email',
'hashed': True
},
'badge': badge_url,
'verify': {
'type': 'hosted',
'url': assertion_url
},
'issuedOn': self.userbadge.created_at
}
return json.dumps(data)
def success(request):
cur_site_name = get_current_site(request).name
cur_site = get_current_site(request)
logger.info('robokassa success' + str(request.GET))
order = Order.objects.get(pk=request.GET['InvId'])
return render(request, 'ligati_payment/lugati_robokassa/success.html', {'cur_site_name': cur_site_name})
def portfolio(request):
try:
general_info = General_Info.objects.get(site__id__exact=get_current_site(request).id)
portfolio_pics = Portfolio_Pic.objects.filter(site__id__exact=get_current_site(request).id)
except:
raise Http404
check_user_status(general_info)
page_title = (general_info.business_name + ' | Portfolio') if (general_info.meta_title == '') else (general_info.meta_title + ' | Our Portfolio')
has_pic_dict = {}
for pic_choice in Portfolio_Pic.PIC_TYPE_CHOICES:
has_pic_dict[pic_choice[0]] = False
for pic in portfolio_pics:
has_pic_dict[pic.pic_type] = True
context = {
'page_title':page_title,
'page_description':general_info.portfolio_meta_description,
'active':'portfolio',
'general_info':general_info,
'has_pic_dict':has_pic_dict,
'portfolio_pics':portfolio_pics,
}
return render(request, 'portfolio.html', context)
def _build_params(self):
"""
Ipaymu parameters builder.
Build params based on ipaymu requirements:
https://ipaymu.com/cara-integrasi-webstore-tingkat-lanjut/
==Should be provided via form submit--------
'product' => 'Nama Produk'
'price' => '101000'
'quantity' => 1
'comments' => 'Keterangan Produk'
==Can be provided via Form submit or use default settings value
'key' => 'api_key_merchant'
'action' => 'payment',
'ureturn' => '/ipaymu/success/',
'ucancel' => '/ipaymu/canceled/',
'invoice_number' => uniqid('INV-')
'paypal_email' => 'email_paypal_merchant'
'paypal_price' => 1
'format' => 'json'
---------- Django Ipaymu notification point ------------
'unotify' => '/ipaymu/notify/',
"""
self.raw_params = {
# These parameters must provided via form
'product': self.data.get('product', 'n/a'),
'price': self.data.get('price', 0),
'quantity': self.data.get('quantity', 0),
'comments': self.data.get('comments', ''),
# These parameters can be overrided via form or settings
'key': self.data.get('key') or settings.IPAYMU_APIKEY,
'action': self.data.get('action') or settings.IPAYMU_ACTION,
'format': self.data.get('format') or settings.IPAYMU_RETURN_FORMAT,
'paypal_email': self.data.get('paypal_email') or settings.IPAYMU_PAYPAL_EMAIL,
'invoice_number': self.data.get('invoice_number', 'n/a'),
'paypal_price': self.data.get('paypal_price'),
'ureturn': self.data.get('ureturn') or settings.IPAYMU_RETURN_URL or ('%s%s%s' % (settings.SITE_PROTOCOL,
get_current_site(self.request).domain,
reverse('ipaymu_return_url'))),
'ucancel': self.data.get('ucancel') or settings.IPAYMU_CANCEL_URL or ('%s%s%s' % (settings.SITE_PROTOCOL,
get_current_site(self.request).domain,
reverse('ipaymu_cancel_url'))),
'unotify': '%s%s%s' % (settings.SITE_PROTOCOL,
get_current_site(self.request).domain,
reverse('ipaymu_notify_url')),
}
return
def meta_data(request):
meta = dict()
meta['site_name'] = settings.SITE_NAME
meta['site_url'] = ''.join(['http://', get_current_site(None).domain])
meta['site_title'] = settings.SITE_TITLE
meta['site_domain'] = get_current_site(None).domain
meta['site_db_admins'] = settings.SITE_FB_ADMINS
meta['site_bitly_verification'] = settings.SITE_BITLY_VERIFICATION
meta['DEBUG'] = settings.DEBUG
meta['accept_gzip'] = 'gzip' in request.META.get('HTTP_ACCEPT_ENCODING', '')
return {'meta': meta}
def create_blogpost(request):
if request.method == 'POST':
form = CreateBlogPostForm(request.POST, user=request.user, site=get_current_site(request))
if form.is_valid():
instance = form.save()
request.user.message_set.create(message=_("The blog post %s has been saved") % instance.title)
return HttpResponseRedirect('/page/my-blogs/')
else:
form = CreateBlogPostForm(user=request.user, site=get_current_site(request))
extra = dict(form=form)
return render_to_response('foundry/create_blogpost.html', extra, context_instance=RequestContext(request))
def get(self, request, *args, **kwargs):
form = BrandUsersForm(initial={
"user": request.user,
"users": None,
})
try:
page = request.GET.get('page', 1)
except PageNotAnInteger:
page = 1
if "participant_go" in request.GET:
if len(request.GET["searchbox"].split()) < 2:
kwargs["first_name"] = request.GET["searchbox"]
kwargs["last_name"] = request.GET["searchbox"]
else:
names = request.GET["searchbox"].split()
kwargs["first_name"] = names[0]
kwargs["last_name"] = names[1]
current_users = []
for user in OrganizationUser.objects.filter(organization=self.organization):
current_users += [user.user.pk]
if request.user.is_superuser:
if "first_name" in kwargs and "last_name" in kwargs:
q = User.objects.filter(~Q(pk__in=current_users), Q(first_name__icontains=kwargs["first_name"]) | Q(
last_name__icontains=kwargs["last_name"]),
is_active=True, profile__site_registered=get_current_site(request))
else:
q = User.objects.filter(~Q(pk__in=current_users), is_active=True,
profile__site_registered=get_current_site(request))
else:
if "first_name" in kwargs and "last_name" in kwargs:
q = User.objects.filter(~Q(pk__in=current_users), Q(first_name__icontains=kwargs["first_name"]) | Q(
last_name__icontains=kwargs["last_name"]),
is_active=True, profile__site_registered=request.user.profile.site_registered)
else:
q = User.objects.filter(~Q(pk__in=current_users), is_active=True,
profile__site_registered=request.user.profile.site_registered)
q = q.order_by("first_name")
p = Paginator(q, 40, request=request).page(page)
form.fields["users"] = AdvancedModelMultipleChoiceField(
queryset=p.object_list)
# for uop in form.fields["users"]:
# if self.organization.is_member(uop.user):
# pass
context = self.get_context_data()
context["pager"] = p
context["show_users"] = True
context = RequestContext(request, context)
context["manageform"] = form
context["search_textbox"] = forms.UsersSearchForm()
return self.render_to_response(context)
def signupstep3(request):
id = request.session.get('id')
try:
obj=Student.objects.get(id=id)
except:
return HttpResponse('404 ERROR')
if request.method == "GET":
departmentobj = Department.objects.all()
currentsite = str(get_current_site(request).domain)
currentsite = str(get_current_site(request).domain)
current_url = resolve(request.path_info).url_name
request.session['current_url'] = str(current_url)
return render_to_response('frontend/signup-step3.html',locals(),context_instance=RequestContext(request))
def get_queryset(self):
# TODO: refatoring, used super()
self.site = get_current_site(self.request)
self.long_slug = self.get_long_slug()
if not self.long_slug:
return None
self.set_channel_rules()
self.articleboxes = ContainerBox.objects.filter(
channel__long_slug=self.long_slug)
is_paginated = self.page_kwarg in self.request.GET
if not is_paginated:
for box in self.articleboxes:
self.excluded_ids.update(
[a.pk for a in box.ordered_containers()])
filters = {}
filters['site_domain'] = self.site.domain
filters['date_available__lte'] = timezone.now()
filters['published'] = True
filters['child_class'] = 'Album'
if self.channel and self.channel.is_root_node() and not is_paginated:
filters['show_on_root_channel'] = True
queryset = Container.objects.filter(
**filters).exclude(pk__in=self.excluded_ids)
return queryset._clone()
def get(self, request, *args, **kwargs):
try:
user = BaseUser.objects.get(id=self.request.session["_auth_user_id"])
except (BaseUser.DoesNotExist, TypeError, ValueError, OverflowError, KeyError):
return HttpResponse('{"status":"error"}', mimetype='application/json')
if user.is_active:
return HttpResponse('{"status": "is_already_active"}', mimetype='application/json')
send_mail_time = self.request.session.get('_send_signup_mail_time', None)
if send_mail_time:
send_mail_time = datetime.datetime.fromtimestamp(send_mail_time)
if send_mail_time + datetime.timedelta(minutes=10) > datetime.datetime.now():
return HttpResponse('{"status":"please wait 10 minutes."}', mimetype='application/json')
self.request.session["_send_signup_mail_time"] = datetime.datetime.now().timestamp()
token = signup_token_generator.make_token(user)
current_site = get_current_site(self.request)
site_name = current_site.name
domain = current_site.domain
use_https = self.request.is_secure()
c = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'user': user,
'token': token,
'protocol': 'https' if use_https else 'http',
}
subject = loader.render_to_string('steam/email_confirm.html', c)
user.email_user(_('Welcome SQA Game Center Project'), subject)
return HttpResponse('{"status":"ok"}', mimetype='application/json')
def logout(request, next_page=None,
template_name='registration/logged_out.html',
redirect_field_name=REDIRECT_FIELD_NAME,
current_app=None, extra_context=None):
"""
Logs out the user and displays 'You are logged out' message.
"""
auth_logout(request)
if redirect_field_name in request.REQUEST:
next_page = request.REQUEST[redirect_field_name]
# Security check -- don't allow redirection to a different host.
if not is_safe_url(url=next_page, host=request.get_host()):
next_page = request.path
if next_page:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page)
current_site = get_current_site(request)
context = {
'site': current_site,
'site_name': current_site.name,
'title': _('Logged out')
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context,
current_app=current_app)
def logout(request, next_page=None,
template_name='registration/logged_out.html',
redirect_field_name=REDIRECT_FIELD_NAME,
current_app=None, extra_context=None):
"""
Logs out the user and displays 'You are logged out' message.
"""
the_user = request.user
auth_logout(request)
user_actions.action_logout(the_user)
redirect_to = request.REQUEST.get(redirect_field_name, '')
if redirect_to:
netloc = urlparse.urlparse(redirect_to)[1]
# Security check -- don't allow redirection to a different host.
if not (netloc and netloc != request.get_host()):
return HttpResponseRedirect(redirect_to)
if next_page is None:
current_site = get_current_site(request)
context = {
'site': current_site,
'site_name': current_site.name,
'title': 'Logged out'
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context,
current_app=current_app)
else:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page or request.path)
def edit_eptitude_for_book_card(
request, card_id, eptitude_id, book_id, eptitude_form=EptitudeForm, template_name="card/edit_eptitude.html"
):
card = get_object_or_404(Card, pk=card_id)
get_object_or_404(Book, pk=book_id)
redirect_to = "/cards/edit_card_for_book/%s/%s" % (card_id, book_id)
eptitude = get_object_or_404(CardEptitude, pk=eptitude_id)
if request.method == "POST":
form = eptitude_form(card, request.POST)
if form.is_valid():
editEptitudeByRequest(request, eptitude)
return HttpResponseRedirect(redirect_to)
else:
data = getEptitudeData(eptitude, card)
form = eptitude_form(card, data)
current_site = get_current_site(request)
context = {"form": form, "card": card, "site": current_site, "site_name": current_site.name}
return TemplateResponse(request, template_name, context)
def get(self, request, *args, **kwargs):
# Get the data from the session
try:
key = self.request.session[self.session_key_name]
del self.request.session[self.session_key_name]
except KeyError:
raise Http404()
# Get data for qrcode
image_factory_string = getattr(settings, 'TWO_FACTOR_QR_FACTORY', self.default_qr_factory)
image_factory = import_by_path(image_factory_string)
content_type = self.image_content_types[image_factory.kind]
try:
username = self.request.user.get_username()
except AttributeError:
username = self.request.user.username
site_name = get_current_site(self.request).name
alias = '{site_name}:{username}'.format(
username=username, site_name=site_name)
# Make and return QR code
img = qrcode.make(get_otpauth_url(alias, key, site_name), image_factory=image_factory)
resp = HttpResponse(content_type=content_type)
img.save(resp)
return resp
def sitemap(request, sitemaps, section=None,
template_name='sitemap.xml', content_type='application/xml'):
req_protocol = request.scheme
req_site = get_current_site(request)
if section is not None:
if section not in sitemaps:
raise Http404("No sitemap available for section: %r" % section)
maps = [sitemaps[section]]
else:
maps = list(six.itervalues(sitemaps))
page = request.GET.get("p", 1)
urls = []
for site in maps:
try:
if callable(site):
site = site()
urls.extend(site.get_urls(page=page, site=req_site,
protocol=req_protocol))
except EmptyPage:
raise Http404("Page %s empty" % page)
except PageNotAnInteger:
raise Http404("No page '%s'" % page)
response = TemplateResponse(request, template_name, {'urlset': urls},
content_type=content_type)
if hasattr(site, 'latest_lastmod'):
# if latest_lastmod is defined for site, set header so as
# ConditionalGetMiddleware is able to send 304 NOT MODIFIED
response['Last-Modified'] = http_date(
timegm(site.latest_lastmod.utctimetuple()))
return response
def create_subrace(request, card_id, subrace_form=SubRaceForm, template_name="card/create_subrace.html"):
card = get_object_or_404(Card, pk=card_id)
redirect_to = "/cards/edit/%s" % card_id
if request.method == "POST":
form = subrace_form(request.POST)
if form.is_valid():
title = request.POST["title"]
description = request.POST["description"]
race_id = request.POST["race"]
race = Race.objects.get(pk=race_id)
SubRace.objects.create(title=title, description=description, race=race)
return HttpResponseRedirect(redirect_to)
else:
form = subrace_form()
current_site = get_current_site(request)
context = {"form": form, "site": current_site, "site_name": current_site.name}
return TemplateResponse(request, template_name, context)
def save(self, domain_override=None,
subject_template_name='registration/password_reset_subject.txt',
email_template_name='registration/password_reset_email.html',
use_https=False, token_generator=default_token_generator,
from_email=None, request=None):
"""
Generates a one-use only link for resetting password and sends to the
user.
"""
for user in self.users_cache:
if not domain_override:
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
else:
site_name = domain = domain_override
c = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': int_to_base36(user.id),
'user': user,
'token': token_generator.make_token(user),
'protocol': use_https and 'https' or 'http',
}
subject = loader.render_to_string(subject_template_name, c)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = loader.render_to_string(email_template_name, c)
send_mail(subject=subject,
message=email,
from_email=None,
recipient_list=(user.email,))
def menu_edit(request):
current_site = get_current_site(request)
try:
menu = Menu.objects.get(site=current_site).json_tree
except Menu.DoesNotExist:
menu = '[{"title": "", "description": "", "url": ""}]'
if request.method =='POST':
try:
Menu.objects.get(site=current_site).delete()
except Menu.DoesNotExist:
pass
menu = striptags(request.POST.get('menudata'))
menu_obj = Menu(json_tree=menu, site_id=current_site.id)
menu_obj.save()
request.session['success'] = True
cache.set('sitemenus_' + current_site.domain, render_menu(current_site), sys.maxint)
return redirect('sitemenus_menu_edit')
success = request.session.get('success')
if success:
del request.session['success']
return render(request, 'sitemenus/sitemenus_edit.html', { 'menu': menu, 'success': success })
def index(request, sitemaps,
template_name='sitemap_index.xml', content_type='application/xml',
sitemap_url_name='obtainfo.sitemap.sitemap',
mimetype=None):
if mimetype:
warnings.warn("The mimetype keyword argument is deprecated, use "
"content_type instead", DeprecationWarning, stacklevel=2)
content_type = mimetype
req_protocol = 'https' if request.is_secure() else 'http'
req_site = get_current_site(request)
req_site = Site(name='movie', domain='movie.' + req_site.domain)
sites = []
for section, site in sitemaps.items():
if callable(site):
site = site()
protocol = req_protocol if site.protocol is None else site.protocol
sitemap_url = urlresolvers.reverse(
sitemap_url_name, kwargs={'section': section})
absolute_url = '%s://%s%s' % (protocol, req_site.domain, sitemap_url)
sites.append(absolute_url)
for page in range(2, site.paginator.num_pages + 1):
sites.append('%s?p=%s' % (absolute_url, page))
return TemplateResponse(request, template_name, {'sitemaps': sites},
content_type=content_type)
def save(self, commit=True):
user = super(BookmarkRegistrationForm, self).save(commit=False)
user.email = self.cleaned_data['username']
user.set_password(self.cleaned_data["password1"])
user.activation_key = default_token_generator.\
make_token(user)
user.key_expires = timezone.now() + datetime.timedelta(days=2,)
user.is_active = False
current_site = get_current_site(None)
site_name = current_site.name
domain = current_site.domain
use_https = False
c = {
'email': user.email,
'site_name': site_name,
'domain': domain,
'user': user,
'activation_key': user.activation_key,
'expires': user.key_expires,
'protocol': use_https and 'https' or 'http'
}
email_subject = _('Confirm your Bookmark.It account')
email_body = loader.render_to_string(
'registration/registration_confirm_email.html',
c
)
if commit:
user.save()
send_mail(subject=email_subject,
message=email_body,
from_email=None,
recipient_list=(user.email,))
return user
def on_comment_posted(sender, comment, request, **kwargs):
"""
Send email notification of a new comment to site staff when email notifications have been requested.
"""
# This code is copied from django_comments.moderation.
# That code doesn't offer a RequestContext, which makes it really
# hard to generate proper URL's with FQDN in the email
#
# Instead of implementing this feature in the moderator class, the signal is used instead
# so the notification feature works regardless of a manual moderator.register() call in the project.
if not appsettings.FLUENT_COMMENTS_USE_EMAIL_NOTIFICATION:
return
recipient_list = [manager_tuple[1] for manager_tuple in settings.MANAGERS]
site = get_current_site(request)
content_object = comment.content_object
subject = u'[{0}] New comment posted on "{1}"'.format(site.name, content_object)
context = {
'site': site,
'comment': comment,
'content_object': content_object
}
message = render_to_string("comments/comment_notification_email.txt", context, RequestContext(request))
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, recipient_list, fail_silently=True)
def get_redirect_url(self, *args, **kwargs):
"""
Refund the prepayment here.
"""
alipay = Alipay(pid=settings.ALIPAY_PID, key=settings.ALIPAY_KEY,
seller_email=settings.ALIPAY_EMAIL)
site = get_current_site(self.request)
detail_data = []
batch_no = datetime.now().strftime('%Y%m%d') + str(Refund.objects.count()+100).rjust(3, '0')
for order in Order.objects.filter(status=REFUNDING):
payment = order.payment_set.filter(trade_status='TRADE_SUCCESS').first()
refund = Refund(order=order, trade_no=payment.trade_no)
refund.save()
refund.batch_no = batch_no
refund.save()
if settings.DEBUG:
refund_amount = 0.01
else:
refund_amount = order.final_price
detail_data.append(u'{}^{}^{}'.format(payment.trade_no, refund_amount, u'用户申请退款'))
params = {
'notify_url': u'http://{}{}'.format(site.domain, reverse('payments:refund_notify')),
'refund_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'batch_no': batch_no,
'batch_num': len(detail_data),
'detail_data': '#'.join(detail_data)
}
url = alipay._build_url('refund_fastpay_by_platform_pwd', **params)
return url
def lugati_feedback(request):
cur_site = get_current_site(request)
form = LugatiFeedbackForm(request.POST)
if form.is_valid():
message = form.cleaned_data['message']
name = form.cleaned_data['name']
subject = form.cleaned_data['subject']
mail = form.cleaned_data['mail']
phone = form.cleaned_data['phone']
message_text = ""
message_text += u"от: " + unicode(name) + " (" + unicode(mail) + ")\n"
message_text += u"тема: " + unicode(subject) + "\n"
message_text += u"телефон для связи: " + unicode(phone) + "\n"
message_text += u"текст: " + unicode(message)
#to us
emails = [settings.DEFAULT_FROM_EMAIL]
try:
msg = EmailMultiAlternatives(u"вопрос с сайта primorsk.su", message_text, settings.DEFAULT_FROM_EMAIL, emails)
msg.send()
except Exception, e:
logger.error(str(e))
return HttpResponse(json.dumps({'response': "Email with a confirmation link has been sent", 'result': 'success'}))
def sitemap(request, sitemaps, section=None,
template_name='sitemap.xml', content_type='application/xml',
mimetype=None):
if mimetype:
warnings.warn("The mimetype keyword argument is deprecated, use "
"content_type instead", DeprecationWarning, stacklevel=2)
content_type = mimetype
req_protocol = 'https' if request.is_secure() else 'http'
req_site = get_current_site(request)
req_site = Site(name='movie', domain='movie.' + req_site.domain)
if section is not None:
if section not in sitemaps:
raise Http404("No sitemap available for section: %r" % section)
maps = [sitemaps[section]]
else:
maps = list(six.itervalues(sitemaps))
page = request.GET.get("p", 1)
urls = []
for site in maps:
try:
if callable(site):
site = site()
urls.extend(site.get_urls(page=page, site=req_site,
protocol=req_protocol))
except EmptyPage:
raise Http404("Page %s empty" % page)
except PageNotAnInteger:
raise Http404("No page '%s'" % page)
return TemplateResponse(request, template_name, {'urlset': urls},
content_type=content_type)
def view_that_asks_for_money(self, request):
'''
We need this to be a method and not a function, since we need to have
a reference to the shop interface
'''
order = self.shop.get_order(request)
url_scheme = 'https' if request.is_secure() else 'http'
# get_current_site requires Django 1.3 - backward compatibility?
url_domain = get_current_site(request).domain
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"currency_code": settings.PAYPAL_CURRENCY_CODE,
"amount": self.shop.get_order_total(order),
"item_name": self.shop.get_order_short_name(order),
"invoice": self.shop.get_order_unique_id(order),
"notify_url": '%s://%s%s' % (url_scheme,
url_domain, reverse('paypal-ipn')), # defined by django-paypal
"return_url": '%s://%s%s' % (url_scheme,
url_domain, reverse('paypal_success')), # That's this classe's view
"cancel_return": '%s://%s%s' % (url_scheme,
url_domain, self.shop.get_cancel_url()), # A generic one
}
if hasattr(settings, 'PAYPAL_LC'):
paypal_dict['lc'] = settings.PAYPAL_LC
# Create the instance.
form = PayPalPaymentsForm(initial=paypal_dict)
context = {"form": form}
return render_to_response("shop_paypal/payment.html", context)
def lugati_product_details(context):
request = context['request']
lugati_base_url = request.path
cur_site = get_current_site(request)
object = Product.objects.get(pk=request.GET['id'])
return {'object': object, 'request': request}
def lugati_catalog_menu(context):
request = context['request']
lugati_base_url = request.path
cur_site = get_current_site(request)
lugati_base_url = settings.LUGATI_CATALOG_URL
parent_object = None
if 'parent_product' in request.GET:
parent_object = Product.objects.get(pk=request.GET['parent_product'],
site=cur_site)
path_list = []
if parent_object:
top_level_cat = parent_object
path_list.append(top_level_cat)
while True:
if top_level_cat.parent_object:
top_level_cat = top_level_cat.parent_object
path_list.append(top_level_cat)
else:
break
#recursive_menu
def get_subtree(lst_str, p_list, p_cat, site, level):
categories = Product.objects.filter(is_category=True).filter(
parent_object=p_cat).filter(site=site)
if categories.count() > 0:
lst_str += '<ul>'
for category in categories:
lst_str += '<li class="level_' + str(
level) + ' category_item">'
if category in p_list:
lst_str += '<a href="' + lugati_base_url + str(
category.id) + '" class="active">'
lst_str += category.name
lst_str += '</a>'
lst_str += get_subtree('', p_list, category, site,
level + 1)
else:
lst_str += '<a href="' + lugati_base_url + str(
category.id) + '">'
lst_str += category.name
lst_str += '</a>'
lst_str += '</li>'
lst_str += '</ul>'
return lst_str
#~recursive_menu
list_str = get_subtree('', path_list, None, cur_site, 1)
categories = Product.objects.filter(is_category=True).filter(
parent_object=parent_object).filter(site=cur_site)
return {
'categories': categories,
'lugati_base_url': lugati_base_url,
'list_str': list_str
}
def login_view(
request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
# authentication_form=AuthenticationForm,
authentication_form=AuShadhaUserForm,
current_app=None,
extra_context=None):
"""Displays the login form and handles the login action."""
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = authentication_form(data=request.POST)
if form.is_valid():
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
# Heavier security check -- don't allow redirection to a different
# host.
elif netloc and netloc != request.get_host():
redirect_to = settings.LOGIN_REDIRECT_URL
# Okay, security checks complete. Log the user in.
login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
data = {
'success': True,
'error_message': "Successfully Loggged In !",
'redirect_to': redirect_to
}
else:
data = {
'success':
False,
'error_message':
'''<em class='error_text'>ERROR! Could not login</em>
<p class='suggestion_text'>Please Check your Username & Password.</p>
<i class='help_text'>If you are sure they are correct,
Please contact Administrator to find
out whether you need to activate your account.
</i>
''',
}
jsondata = json.dumps(data)
return HttpResponse(jsondata, content_type='application/json')
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def get_feed(self, obj, request):
"""
Returns a feedgenerator.DefaultFeed object, fully populated, for
this feed. Raises FeedDoesNotExist for invalid parameters.
"""
current_site = get_current_site(request)
link = self.__get_dynamic_attr('link', obj)
link = add_domain(current_site.domain, link, request.is_secure())
feed = self.feed_type(
title=self.__get_dynamic_attr('title', obj),
subtitle=self.__get_dynamic_attr('subtitle', obj),
link=link,
description=self.__get_dynamic_attr('description', obj),
language=settings.LANGUAGE_CODE.decode(),
feed_url=add_domain(
current_site.domain,
self.__get_dynamic_attr('feed_url', obj) or request.path,
request.is_secure(),
),
author_name=self.__get_dynamic_attr('author_name', obj),
author_link=self.__get_dynamic_attr('author_link', obj),
author_email=self.__get_dynamic_attr('author_email', obj),
categories=self.__get_dynamic_attr('categories', obj),
feed_copyright=self.__get_dynamic_attr('feed_copyright', obj),
feed_guid=self.__get_dynamic_attr('feed_guid', obj),
ttl=self.__get_dynamic_attr('ttl', obj),
**self.feed_extra_kwargs(obj))
title_tmp = None
if self.title_template is not None:
try:
title_tmp = loader.get_template(self.title_template)
except TemplateDoesNotExist:
pass
description_tmp = None
if self.description_template is not None:
try:
description_tmp = loader.get_template(
self.description_template)
except TemplateDoesNotExist:
pass
for item in self.__get_dynamic_attr('items', obj):
if title_tmp is not None:
title = title_tmp.render(
RequestContext(request, {
'obj': item,
'site': current_site
}))
else:
title = self.__get_dynamic_attr('item_title', item)
if description_tmp is not None:
description = description_tmp.render(
RequestContext(request, {
'obj': item,
'site': current_site
}))
else:
description = self.__get_dynamic_attr('item_description', item)
link = add_domain(
current_site.domain,
self.__get_dynamic_attr('item_link', item),
request.is_secure(),
)
enc = None
enc_url = self.__get_dynamic_attr('item_enclosure_url', item)
if enc_url:
enc = feedgenerator.Enclosure(
url=smart_unicode(enc_url),
length=smart_unicode(
self.__get_dynamic_attr('item_enclosure_length',
item)),
mime_type=smart_unicode(
self.__get_dynamic_attr('item_enclosure_mime_type',
item)))
author_name = self.__get_dynamic_attr('item_author_name', item)
if author_name is not None:
author_email = self.__get_dynamic_attr('item_author_email',
item)
author_link = self.__get_dynamic_attr('item_author_link', item)
else:
author_email = author_link = None
pubdate = self.__get_dynamic_attr('item_pubdate', item)
if pubdate and not pubdate.tzinfo:
ltz = tzinfo.LocalTimezone(pubdate)
pubdate = pubdate.replace(tzinfo=ltz)
feed.add_item(
title=title,
link=link,
description=description,
unique_id=self.__get_dynamic_attr('item_guid', item, link),
enclosure=enc,
pubdate=pubdate,
author_name=author_name,
author_email=author_email,
author_link=author_link,
categories=self.__get_dynamic_attr('item_categories', item),
item_copyright=self.__get_dynamic_attr('item_copyright', item),
**self.item_extra_kwargs(item))
return feed
def send_registration_email(self, user):
code = self.communication_type_code
ctx = {'user': user, 'site': get_current_site(self.request)}
messages = CommunicationEventType.objects.get_and_render(code, ctx)
if messages and messages['body']:
Dispatcher().dispatch_user_messages(user, messages)
def course_add(request):
"""
Create new courses. By default courses are created by platform admins unless
ALLOW_PUBLIC_COURSE_CREATION is set to True.
The view validates the email of the course_owner field and the course_name
unless a regular user is creating the course, in which case the course_owner
is directly taken from the current user.
After that the course name is slugified and the CourseTeacher and Course are
saved, and the user is returned to the TeacherAdmin module.
.. versionadded:: 0.1
"""
allow_public = False
try:
allow_public = settings.ALLOW_PUBLIC_COURSE_CREATION
except AttributeError:
pass
if not allow_public and not request.user.is_staff:
return HttpResponseForbidden(
_("Only administrators can create courses"))
if request.method == 'POST':
if 'course_owner' in request.POST:
email_or_id = request.POST['course_owner']
try:
validate_email(email_or_id)
# is an email
try:
owner = User.objects.get(email=email_or_id)
except (User.DoesNotExist):
messages.error(
request,
_('That user doesn\'t exists, the owner must be an user of the platform'
))
return HttpResponseRedirect(reverse('course_add'))
except ValidationError:
# is name plus id
owner_id = name_and_id_regex.search(email_or_id)
if owner_id is None:
messages.error(
request,
_('The owner must be a name plus ID or an email'))
return HttpResponseRedirect(reverse('course_add'))
try:
owner_id = owner_id.groups()[0]
owner = User.objects.get(id=owner_id)
except (User.DoesNotExist):
messages.error(
request,
_('That user doesn\'t exists, the owner must be an user of the platform'
))
return HttpResponseRedirect(reverse('course_add'))
else:
owner = request.user
name = request.POST['course_name']
if (name == u''):
messages.error(request, _('The name can\'t be an empty string'))
return HttpResponseRedirect(reverse('course_add'))
course = Course(name=name, owner=owner, description=_('To fill'))
course.slug = slugify(course)
course.save()
CourseTeacher.objects.create(course=course, teacher=owner)
if not allow_public:
subject = _('Your course "%s" has been created') % name
template = 'courses/email_new_course.txt'
context = {
'user': owner.get_full_name(),
'course': name,
'site': get_current_site(request).name
}
to = [owner.email]
send_mail_wrapper(subject, template, context, to)
messages.success(request, _('The course was successfully created'))
return HttpResponseRedirect(
reverse('teacheradmin_info', args=[course.slug]))
return render_to_response('courses/add.html', {},
context_instance=RequestContext(request))
def comingSoon(request):
Site = get_current_site(request)
return render(request, 'comingsoon.html', {})
def login(
request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None,
):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = authentication_form(request, data=request.POST)
if form.is_valid():
# Ensure the user-originating redirection url is safe.
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
# Okay, security check complete. Log the user in.
try:
if form.get_user().status == 2:
invalid_user = True
context = {
'invalid_user': invalid_user,
}
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
except:
pass
auth_login(request, form.get_user())
if extra_context:
next_redirect_to = extra_context.get("next_redirect_to", {})
if next_redirect_to:
return HttpResponseRedirect(next_redirect_to)
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def api_cart_items(request, cart_item_id=''):
cur_site = get_current_site(request)
resp_dt = {}
if cart_item_id == '':
if request.method == 'POST':
body_dt = json.loads(request.body)
prod_id = body_dt['prod_id']
quantity = body_dt['quantity']
try:
pos_id = resolve(body_dt['cur_url']).kwargs['pos_id']
except:
pos_id = None
if not 'options' in body_dt:
body_dt['options'] = None
if 'cart_item_assigned' in body_dt:
cart_item = cart.add_product_to_cart(request,
prod_id=prod_id,
quantity=quantity,
pos_id=pos_id,
options=body_dt['options'],
cart_item_assigned=body_dt['cart_item_assigned'])
else:
cart_item = cart.add_product_to_cart(request, prod_id=prod_id, quantity=quantity, pos_id=pos_id, options=body_dt['options'])
# cart_item.cart_item_assigned = CartItem.objects.get(pk=body_dt['cart_item_assigned'])
# cart_item.save()
resp_dt = cart_item.get_list_item_info(request)
elif request.method == 'GET':
resp_dt = []
cart_items = cart.get_cart_items_with_toppings(request)
cart_products = []
total_cart_items = 0
for cart_item in cart_items:
node = cart_item.get_list_item_info(request)
cart_products.append(cart_item.product)
node['images'] = []
if 'thumbnail_size_str' in request.GET:
thumbnail_size_str = request.GET['thumbnail_size_str']
for img in cart_item.product.get_images():
img_node={}
img_node['image_url'], img_node['image_margin'] = img.get_thumbnail_attributes(img.get_thumbnail(thumbnail_size_str, get_native_image=True),thumbnail_size_str)
node['images'].append(img_node)
resp_dt.append(node)
total_cart_items += cart_item.quantity
node = {}
#todo delivery
node['online_payment'] = True
total_delivery_price = cart.get_total_delivery_price(request)
delivery_cart_options = cart.get_all_cart_delivery(request)
if delivery_cart_options.exists():
# total_delivery_cost += delivery_cart_option.delivery_option.price
# total_delivery_additional_cost += delivery_cart_option.delivery_option.additional_price
#todo online payment
node['online_payment'] = delivery_cart_options[0].delivery_option.online_payment
# try:
# total_delivery_price = total_delivery_cost + ((total_cart_items-1) * total_delivery_additional_cost)
# except Exception, e:
# logger.info(str(e))
else:
delivery_options = DeliveryOption.objects.filter(site=cur_site)
if delivery_options.exists():
total_delivery_price = delivery_options[0].price
if settings.DEFAULT_CURRENCY == 'BTC':
node['total_delivery_price'] = "%.8f" % total_delivery_price
else:
node['total_delivery_price'] = "%.2f" % total_delivery_price
resp_dt.append(node)
#~todo delivery
else:
if request.method == 'PUT':
# only implemented for quantity change
instance = CartItem.objects.get(pk=cart_item_id)
body_dt = json.loads(request.body)
instance.augment_quantity(body_dt['quantity'] - instance.quantity)
resp_dt['message'] = 'done'
else:
resp_dt['message'] = 'not implemented yet'
return HttpResponse(json.dumps(resp_dt))
def render(req, context, templates):
context['user'] = req.user if isinstance(req.user, User) else None
context['site_name'] = get_current_site(req).name
return render_to_response(templates, context)
def send_email_confirmation(self, email_address):
email_address.send_confirmation(site=get_current_site(self.request))
def login_remember_me_apikey_response(request, template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=None, current_app=None,
extra_context=None):
""" Extending login to return the user id and the API key.
This allows the FE to pick these up for all future requests (needed for API calls)."""
redirect_to = request.REQUEST.get(redirect_field_name, settings.LOGIN_REDIRECT_URL)
if request.method == "POST":
# Incorporated remember me element of the login
if not request.POST.get('remember_me', None):
request.session.set_expiry(0)
form = authentication_form(data=request.POST)
if form.is_valid():
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
# Okay, security check complete. Log the user in.
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
response = HttpResponseRedirect(redirect_to)
# Access the user information to respond with
current_user = form.get_user()
if current_user and current_user.api_key:
api_key = current_user.api_key.key
else:
api_key = 'no api key set for current user.'
response.set_cookie('user_id', current_user)
response.set_cookie('api_key', api_key)
response.set_cookie('user_name', '%s %s'%(current_user.first_name.title(), current_user.last_name.title()))
response.set_cookie('user_email', current_user.email)
response.set_cookie('user_roles', get_auth_roles(current_user))
response.set_cookie('user_active', str(current_user.is_active).lower())
return response
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
# Get the response object (although it is a template response - not rendered until after middleware
return TemplateResponse(request, template_name, context, current_app=current_app)
def login(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = authentication_form(data=request.POST)
if form.is_valid():
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
# Heavier security check -- don't allow redirection to a different
# host.
elif netloc and netloc != request.get_host():
redirect_to = settings.LOGIN_REDIRECT_URL
# Okay, security checks complete. Log the user in.
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
elif request.method == "GET" and request.GET.get('user', ''):
from django.contrib.auth import authenticate
user = request.GET.get('user')
token = request.GET.get('token')
user = authenticate(pk=user, token=token)
if user is not None:
auth_login(request, user)
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def __call__(self, request, *args, **kwargs):
self.site = get_current_site(request)
return super(LatestCommentFeed, self).__call__(request, *args,
**kwargs)
def get_object(self, request, long_slug):
self.site = get_current_site(request)
return get_object_or_404(Channel,
site=self.site,
long_slug=long_slug)
def _ups_config(self):
site = get_current_site(self.request)
return UPSConfiguration.objects.get(site=site)
def current_site(request):
return get_current_site(request).name
def __call__(self, request, *args, **kwargs):
self.site = get_current_site(request)
return super(ContainerFeed, self).__call__(request, *args, **kwargs)
def tlogin(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = authentication_form(data=request.POST)
if form.is_valid():
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = '/home'
# Security check -- don't allow redirection to a different
# host.
elif netloc and netloc != request.get_host():
redirect_to = '/home'
# redirect to payment form if user is not paid user
this_user = form.get_user()
if this_user is not None:
profile = this_user.profile
if not profile.paid_user:
redirect_to = 'https://trackpattern.chargify.com/h/46549/subscriptions/new/?reference=%s&first_name=%s&last_name=%s&email=%s' % (
this_user.id, this_user.first_name,
this_user.last_name, this_user.email)
else:
auth_login(request, this_user)
# If the user is 'None' log in anyway to get error
else:
auth_login(request, this_user)
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
context.update(extra_context or {})
return render_to_response(template_name,
context,
context_instance=RequestContext(
request, current_app=current_app))
def register(
request,
template_name='users/registration_form.html',
activation_email_template_name='users/activation_email.html',
activation_email_subject_template_name='users/activation_email_subject.html',
activation_email_html_template_name=None,
registration_form=RegistrationForm,
registered_user_redirect_to=None,
post_registration_redirect=None,
activation_from_email=None,
current_app=None,
extra_context=None):
if registered_user_redirect_to is None:
registered_user_redirect_to = getattr(settings, 'LOGIN_REDIRECT_URL')
if request.user.is_authenticated():
return redirect(registered_user_redirect_to)
if not settings.USERS_REGISTRATION_OPEN:
return redirect(reverse('users_registration_closed'))
if post_registration_redirect is None:
post_registration_redirect = reverse('users_registration_complete')
if request.method == 'POST':
form = registration_form(request.POST)
if form.is_valid():
user = form.save()
if not user.is_active and settings.USERS_VERIFY_EMAIL:
opts = {
'user': user,
'request': request,
'from_email': activation_from_email,
'email_template': activation_email_template_name,
'subject_template': activation_email_subject_template_name,
'html_email_template': activation_email_html_template_name,
}
send_activation_email(**opts)
user_registered.send(sender=user.__class__,
request=request,
user=user)
return redirect(post_registration_redirect)
else:
form = registration_form()
current_site = get_current_site(request)
context = {
'form': form,
'site': current_site,
'site_name': current_site.name,
'title': _('Register'),
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def save(self,
domain_override=None,
subject_template_name='registration/password_reset_subject.txt',
email_template_name='registration/password_reset_email.html',
use_https=False,
token_generator=default_token_generator,
from_email=None,
request=None,
html_email_template_name=None):
"""
Generates a one-use only link for resetting password and sends to the
user.
"""
from django.core.mail import send_mail
UserModel = get_user_model()
email = self.cleaned_data["email"]
active_users = UserModel._default_manager.filter(email__iexact=email,
is_active=True)
for user in active_users:
# Make sure that no email is sent to a user that actually has
# a password marked as unusable
# if not user.has_usable_password():
# continue
if not domain_override:
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
else:
site_name = domain = domain_override
c = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'user': user,
'token': token_generator.make_token(user),
'protocol': 'https' if use_https else 'http',
}
subject = loader.render_to_string(subject_template_name, c)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = loader.render_to_string(email_template_name, c)
send_mail(subject, email, from_email, [user.email])
old_users = OldlscdsUser.objects.filter(email=email)
if old_users:
for user in old_users:
if not user.last_login:
user.last_login = timezone.now()
if not user.password:
user.set_password('user.email')
user.save()
if not domain_override:
current_site = get_current_site(request)
site_name = current_site.name
domain = current_site.domain
else:
site_name = domain = domain_override
c = {
'email': user.email,
'domain': domain,
'site_name': site_name,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'user': user,
'token': token_generator.make_token(user),
'protocol': 'https' if use_https else 'http',
}
subject = loader.render_to_string(subject_template_name, c)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = loader.render_to_string(email_template_name, c)
send_mail(subject, email, from_email, [user.email])
def course_review_review(request, course_slug, assignment_id):
course = get_course_if_user_can_view_or_404(course_slug, request)
assignment = get_object_or_404(PeerReviewAssignment, id=assignment_id)
user_id = request.user.id
is_enrolled = course.students.filter(id=user_id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(
reverse('course_overview', args=[course_slug]))
if assignment.kq.unit.course != course:
messages.error(
request,
_('The selected peer review assignment is not part of this course.'
))
return HttpResponseRedirect(
reverse('course_reviews', args=[course_slug]))
collection = get_db().get_collection('peer_review_submissions')
submission = collection.find({
'kq': assignment.kq.id,
'assigned_to': user_id
})
if submission.count() == 0:
messages.error(request, _('You don\'t have this submission assigned.'))
return HttpResponseRedirect(
reverse('course_reviews', args=[course_slug]))
submission_obj = submission[0]
submitter = User.objects.get(id=int(submission_obj['author']))
criteria_initial = [{
'evaluation_criterion_id': criterion.id
} for criterion in assignment.criteria.all()]
EvalutionCriteriaResponseFormSet = formset_factory(
EvalutionCriteriaResponseForm, extra=0, max_num=len(criteria_initial))
if request.method == "POST":
submission_form = ReviewSubmissionForm(request.POST)
criteria_formset = EvalutionCriteriaResponseFormSet(
request.POST, initial=criteria_initial)
if criteria_formset.is_valid() and submission_form.is_valid():
criteria_values = [
(int(form.cleaned_data['evaluation_criterion_id']),
int(form.cleaned_data['value'])) for form in criteria_formset
]
try:
review = save_review(assignment.kq, request.user, submitter,
criteria_values,
submission_form.cleaned_data['comments'])
reviews = get_db().get_collection('peer_review_reviews')
reviewed_count = reviews.find({
'reviewer': user_id,
'kq': assignment.kq.id
}).count()
on_peerreviewreview_created_task.apply_async(
args=[review, reviewed_count],
queue='stats',
)
current_site_name = get_current_site(request).name
send_mail_to_submission_owner(current_site_name, assignment,
review, submitter)
except IntegrityError:
messages.error(
request,
_('Your can\'t submit two times the same review.'))
return HttpResponseRedirect(
reverse('course_reviews', args=[course_slug]))
pending = assignment.minimum_reviewers - reviewed_count
if pending > 0:
messages.success(
request,
_('Your review has been submitted. You have to review at least %d exercises more.'
) % pending)
else:
messages.success(request, _('Your review has been submitted.'))
return HttpResponseRedirect(
reverse('course_reviews', args=[course_slug]))
else:
submission_form = ReviewSubmissionForm()
criteria_formset = EvalutionCriteriaResponseFormSet(
initial=criteria_initial)
max_hours_assigned = timedelta(
hours=getattr(settings, "PEER_REVIEW_ASSIGNATION_EXPIRE", 24))
assigned_when = submission[0]["assigned_when"]
assignation_expire = assigned_when + max_hours_assigned
now = datetime.now(assigned_when.tzinfo)
is_assignation_expired = now > assignation_expire
return render_to_response('peerreview/review_review.html', {
'submission': submission[0],
'is_assignation_expired': is_assignation_expired,
'assignation_expire': assignation_expire,
'submission_form': submission_form,
'criteria_formset': criteria_formset,
'course': course,
'assignment': assignment,
'is_enrolled': is_enrolled,
},
context_instance=RequestContext(request))
def lugati_catalog_menu_new(context):
request = context['request']
lugati_base_url = request.path
cur_site = get_current_site(request)
lugati_base_url = settings.LUGATI_CATALOG_URL
parent_object = None
if 'parent_product' in request.GET:
parent_object = Product.objects.get(pk=request.GET['parent_product'],
site=cur_site)
path_list = []
if parent_object:
top_level_cat = parent_object
path_list.append(top_level_cat)
while True:
if top_level_cat.parent_object:
top_level_cat = top_level_cat.parent_object
path_list.append(top_level_cat)
else:
break
#recursive_menu
def get_subtree(lst_str, p_list, p_cat, site, level):
categories = Product.objects.filter(is_category=True).filter(
parent_object=p_cat).filter(site=site)
if categories.count() > 0:
if (level > 1):
lst_str += '<ul class="dropdown-menu navmenu-nav">'
else:
lst_str += '<ul class="nav navmenu-nav" role="menu">'
# lst_str += '<ul class="nav nav-pills nav-stacked">'
for category in categories:
lst_str += '<li class="level_' + str(
level) + ' category_item">'
# if category in p_list:
# lst_str += '<a href="' + lugati_base_url + str(category.id) + '" class="active">'
# lst_str += category.name
# lst_str += '</a>'
# lst_str += get_subtree('', p_list, category, site, level+1)
# else:
if (Product.objects.filter(is_category=True).filter(
parent_object=category).filter(site=site).count() > 0):
lst_str += '<a href="#" class="dropdown-toggle" data-toggle="dropdown">'
lst_str += category.name
lst_str += '<b class="caret"></b></a>'
lst_str += get_subtree('', p_list, category, site,
level + 1)
else:
lst_str += '<a href="/products?category=' + str(
category.id) + '">'
lst_str += category.name
lst_str += '</a>'
lst_str += '</li>'
lst_str += '</ul>'
return lst_str
#~recursive_menu
list_str = get_subtree('', path_list, None, cur_site, 1)
return {'lugati_base_url': lugati_base_url, 'list_str': list_str}
def current_site(request):
"""
Context processor add get_current_site() as {{{ current_site }}} to
template context.
"""
return {'current_site': get_current_site(request)}
def login(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
if request.GET.get('newsn') == '1':
csn = CaptchaStore.generate_key()
cimageurl = captcha_image_url(csn)
return HttpResponse(cimageurl)
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name, '')
human = False
if request.method == "POST":
form = CaptchaForm(request.POST)
if form.is_valid():
human = True
if human:
form = authentication_form(data=request.POST)
if form.is_valid():
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
# Heavier security check -- don't allow redirection to a different
# host.
elif netloc and netloc != request.get_host():
redirect_to = settings.LOGIN_REDIRECT_URL
# Okay, security checks complete. Log the user in.
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
captcha_form = CaptchaForm()
context = {
'form': form,
'captcha_form': captcha_form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def test_create_single_web_user(self):
org = Mock(spec=Organization)
org.org_id = "org_id"
org.account_type = "Basic"
site = get_current_site(None)
mock_entity = Mock(spec=Entity)
mock_entity.value.return_value = 'test'
users = User.objects.filter(email=WEB_USER_TEST_EMAIL)
NGOUserProfile.objects.filter(org_id=org.org_id).delete()
users.delete()
with patch(
"django.contrib.auth.tokens.default_token_generator.make_token"
) as make_token:
make_token.return_value = "token"
with patch("datawinners.entity.views.get_database_manager_for_org"
) as get_dbm:
get_dbm.return_value = Mock(spec=DatabaseManager)
with patch(
"datawinners.accountmanagement.models.Organization.objects.get"
) as get_organization_mock:
get_organization_mock.return_value = org
with patch("datawinners.entity.views.get_by_short_code"
) as reporter_entity:
with patch(
"datawinners.entity.views.put_email_information_to_entity"
) as put_email_information_to_entity:
put_email_information_to_entity.return_value = None
reporter_entity.return_value = mock_entity
create_single_web_user(org.org_id,
WEB_USER_TEST_EMAIL, "test",
"en")
user = User.objects.filter(
email=WEB_USER_TEST_EMAIL)[0]
emails = [
mail.outbox.pop()
for i in range(len(mail.outbox))
]
self.assertEqual(1, len(emails))
sent_email = emails[0]
self.assertEqual(settings.EMAIL_HOST_USER,
sent_email.from_email)
self.assertEqual([WEB_USER_TEST_EMAIL],
sent_email.to)
ctx_dict = {
'domain': "localhost:8000",
'uid': int_to_base36(user.id),
'user': user,
'token': "token",
'protocol': 'http',
'account_type': org.account_type,
'site': site,
}
self.assertEqual(
render_to_string(
'activatedatasenderemail/activation_email_subject_for_data_sender_account_en.txt'
), sent_email.subject)
self.assertEqual(
render_to_string(
'activatedatasenderemail/activation_email_for_data_sender_account_en.html',
ctx_dict), sent_email.body)
def queryset(self):
self.site = get_current_site(self.request)
return Poll.objects.all_published()
def access_annotation_target(request,
course_id,
assignment_id,
object_id,
user_id=None,
user_name=None,
roles=None):
"""
Renders an assignment page
"""
if user_id is None:
user_name = request.LTI['hx_user_name']
user_id = request.LTI['hx_user_id']
roles = request.LTI['hx_roles']
try:
assignment = Assignment.objects.get(assignment_id=assignment_id)
targ_obj = TargetObject.objects.get(pk=object_id)
assignment_target = AssignmentTargets.objects.get(
assignment=assignment, target_object=targ_obj)
object_uri = targ_obj.get_target_content_uri()
course_obj = LTICourse.objects.get(course_id=course_id)
except Assignment.DoesNotExist or TargetObject.DoesNotExist:
logger.error(
"User attempted to access an Assignment or Target Object that does not exist: assignment_id={assignment_id} object_id={object_id}"
.format(assignment_id=assignment_id, object_id=object_id))
raise AnnotationTargetDoesNotExist(
'Assignment or target object does not exist')
try:
is_instructor = request.LTI['is_staff']
except:
is_instructor = False
if not is_instructor and not assignment.is_published:
raise PermissionDenied(
'Permission to access unpublished assignment by a non-instructor is denied'
)
save_session(request,
collection_id=assignment_id,
object_id=object_id,
object_uri=object_uri,
context_id=course_id)
# Dynamically pass in the address that the detail view will use to fetch annotations.
# there's definitely a more elegant way (or a library function) to do this.
# also, we may want to consider denying if theres no ssl
protocol = 'https://' if request.is_secure() else 'http://'
abstract_db_url = protocol + get_current_site(request).domain + reverse(
'annotation_store:api_root')
logger.debug("DEBUG - Abstract Database URL: " + abstract_db_url)
original = {
'user_id':
user_id,
'username':
user_name,
'is_instructor':
request.LTI['is_staff'],
'collection':
assignment_id,
'course':
course_id,
'object':
object_id,
'target_object':
targ_obj,
'token':
retrieve_token(user_id, assignment.annotation_database_apikey,
assignment.annotation_database_secret_token),
'assignment':
assignment,
'roles': [str(role) for role in roles],
'instructions':
assignment_target.target_instructions,
'abstract_db_url':
abstract_db_url,
'session':
request.session.session_key,
'org':
settings.ORGANIZATION,
'logger_url':
settings.ANNOTATION_LOGGER_URL,
}
if not assignment.object_before(object_id) is None:
original['prev_object'] = assignment.object_before(object_id)
original['assignment_target'] = assignment_target
if not assignment.object_after(object_id) is None:
original['next_object'] = assignment.object_after(object_id)
original['assignment_target'] = assignment_target
if targ_obj.target_type == 'vd':
srcurl = targ_obj.target_content
if 'youtu' in srcurl:
typeSource = 'video/youtube'
else:
disassembled = urlparse(srcurl)
file_ext = os.path.splitext(os.path.basename(disassembled.path))[1]
typeSource = 'video/' + file_ext.replace('.', '')
original.update({'typeSource': typeSource})
elif targ_obj.target_type == 'ig':
original.update({'osd_json': targ_obj.target_content})
viewtype = assignment_target.get_view_type_for_mirador()
canvas_id = assignment_target.get_canvas_id_for_mirador()
if viewtype is not None:
original.update({'viewType': viewtype})
if canvas_id is not None:
original.update({'canvas_id': canvas_id})
if assignment_target.target_external_css:
original.update({'custom_css': assignment_target.target_external_css})
elif course_obj.course_external_css_default:
original.update({'custom_css': course_obj.course_external_css_default})
original.update(
{'dashboard_hidden': assignment_target.get_dashboard_hidden()})
original.update(
{'transcript_hidden': assignment_target.get_transcript_hidden()})
original.update(
{'transcript_download': assignment_target.get_transcript_download()})
original.update({'video_download': assignment_target.get_video_download()})
get_paras = {}
for k in request.GET.keys():
get_paras[k] = request.GET[k]
original.update(get_paras)
return render(request, '%s/detail.html' % targ_obj.target_type, original)
def restore_object(self, attrs, instance=None):
user = self.context['request'].user
name = attrs.get('name')
class_settings_values = attrs.get('class_settings')
attributes = ["description"]
settings_attributes = ['moderate_posts', 'is_public', 'allow_signups']
if instance is None:
try:
instance = Classgroup(owner=user,
name=alphanumeric_name(name),
display_name=name)
instance.save()
user.classgroups.add(instance)
user.save()
cg_perm = ClassGroupPermissions(instance)
cg_perm.setup()
cg_perm.assign_access_level(user, cg_perm.administrator)
try:
class_settings = ClassSettings(
classgroup=instance, access_key=make_random_key())
class_settings.save()
except IntegrityError:
class_settings = ClassSettings.objects.get(
classgroup=instance)
try:
message = Message(
user=user,
classgroup=instance,
source="welcome",
text=WELCOME_MESSAGE2_TEMPLATE,
message_type="A",
)
message.save()
message = Message(
user=user,
classgroup=instance,
source="welcome",
text=WELCOME_MESSAGE_TEMPLATE.format(
class_name=instance.display_name,
class_link=get_current_site(
self.context['request']).domain +
instance.link(),
access_key=class_settings.access_key),
message_type="A",
)
message.save()
except IntegrityError:
pass
except IntegrityError:
error_msg = "Class name is already taken."
log.exception(error_msg)
raise serializers.ValidationError(error_msg)
else:
if not ClassGroupPermissions.is_teacher(instance, user):
raise serializers.ValidationError(
"Class name is already taken.")
class_settings = instance.class_settings
instance = set_attributes(attributes, attrs, instance)
if class_settings_values is not None:
class_settings = set_attributes(settings_attributes,
class_settings_values,
class_settings)
class_settings.save()
return instance
def shortcut(request, content_type_id, object_id):
"""
Redirect to an object's page based on a content-type ID and an object ID.
"""
# Look up the object, making sure it's got a get_absolute_url() function.
try:
content_type = ContentType.objects.get(pk=content_type_id)
if not content_type.model_class():
raise http.Http404(
_("Content type %(ct_id)s object has no associated model") %
{'ct_id': content_type_id})
obj = content_type.get_object_for_this_type(pk=object_id)
except (ObjectDoesNotExist, ValueError):
raise http.Http404(
_("Content type %(ct_id)s object %(obj_id)s doesn't exist") % {
'ct_id': content_type_id,
'obj_id': object_id
})
try:
get_absolute_url = obj.get_absolute_url
except AttributeError:
raise http.Http404(
_("%(ct_name)s objects don't have a get_absolute_url() method") %
{'ct_name': content_type.name})
absurl = get_absolute_url()
# Try to figure out the object's domain, so we can do a cross-site redirect
# if necessary.
# If the object actually defines a domain, we're done.
if absurl.startswith('http://') or absurl.startswith('https://'):
return http.HttpResponseRedirect(absurl)
# Otherwise, we need to introspect the object's relationships for a
# relation to the Site object
object_domain = None
if Site._meta.installed:
opts = obj._meta
# First, look for an many-to-many relationship to Site.
for field in opts.many_to_many:
if field.rel.to is Site:
try:
# Caveat: In the case of multiple related Sites, this just
# selects the *first* one, which is arbitrary.
object_domain = getattr(obj, field.name).all()[0].domain
except IndexError:
pass
if object_domain is not None:
break
# Next, look for a many-to-one relationship to Site.
if object_domain is None:
for field in obj._meta.fields:
if field.rel and field.rel.to is Site:
try:
object_domain = getattr(obj, field.name).domain
except Site.DoesNotExist:
pass
if object_domain is not None:
break
# Fall back to the current site (if possible).
if object_domain is None:
try:
object_domain = get_current_site(request).domain
except Site.DoesNotExist:
pass
# If all that malarkey found an object domain, use it. Otherwise, fall back
# to whatever get_absolute_url() returned.
if object_domain is not None:
protocol = request.is_secure() and 'https' or 'http'
return http.HttpResponseRedirect('%s://%s%s' %
(protocol, object_domain, absurl))
else:
return http.HttpResponseRedirect(absurl)
