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)