def product_download(request, course_slug, resource_url): try: product = Product.get_from_slug(course_slug) me = get_me(request) if ProductPurchase.objects.filter( product=product, purchase__person=me, purchase__refunded=False, ).all().count() > 0: view_dir = os.path.abspath( os.path.dirname(os.path.dirname(__file__))) with open( os.path.join(view_dir, "products", "downloads", course_slug, resource_url), "rb") as f: content = f.read() mime_type = magic.from_buffer(content, mime=True) response = HttpResponse(content, content_type=mime_type) response['Content-Type'] = mime_type response['Content-Length'] = len(content) return response return redirect(reverse('login')) except: import traceback traceback.print_exc() return redirect(reverse('login'))
def endpoint(request): openid_request = get_server().decodeRequest(dict(request.REQUEST.items())) if openid_request is None: return HttpResponse("This was not valid OpenID request") if openid_request.mode not in ("checkid_immediate", "checkid_setup"): return convertToHttpResponse(get_server().handleRequest(openid_request)) djangoid = get_djangoid_user_from_identity() if not request.user.is_authenticated(): return redirect_to_login( urllib.quote(openid_request.encodeToURL(request.build_absolute_uri())), login_url=reverse('login')) if request.user != djangoid.user: raise Exception("Logged in as %s while expecting %s" % (request.user, djangoid.user)) # Is the user authenticated, and does he trust this trust_root? # user logged in (using openid_request.identity and openid_request.trust_root) if djangoid.authenticate(openid_request.trust_root): response = openid_request.answer(True) elif openid_request.immediate: response = openid_request.answer(False, request.META["HTTP_HOST"]) else: if openid_request.claimed_id is None: openid_request.claimed_id = openid_request.identity redirect = openid_request.encodeToURL(reverse('openid_accept')) return HttpResponseRedirect(redirect) return convertToHttpResponse(response)
def endpoint(request): openid_request = get_server().decodeRequest(dict(request.REQUEST.items())) if openid_request is None: return HttpResponse("This was not valid OpenID request") if openid_request.mode not in ("checkid_immediate", "checkid_setup"): return convertToHttpResponse( get_server().handleRequest(openid_request)) djangoid = get_djangoid_user_from_identity() if not request.user.is_authenticated(): return redirect_to_login(urllib.quote( openid_request.encodeToURL(request.build_absolute_uri())), login_url=reverse('login')) if request.user != djangoid.user: raise Exception("Logged in as %s while expecting %s" % (request.user, djangoid.user)) # Is the user authenticated, and does he trust this trust_root? # user logged in (using openid_request.identity and openid_request.trust_root) if djangoid.authenticate(openid_request.trust_root): response = openid_request.answer(True) elif openid_request.immediate: response = openid_request.answer(False, request.META["HTTP_HOST"]) else: if openid_request.claimed_id is None: openid_request.claimed_id = openid_request.identity redirect = openid_request.encodeToURL(reverse('openid_accept')) return HttpResponseRedirect(redirect) return convertToHttpResponse(response)
def start_journey(request, hashid): Organization.get() me = get_me(request) pp = ProductPurchase.objects.get(hashid=hashid) Journey.objects.create(productpurchase=pp, start_date=timezone.now()) if pp.purchase.person != me: return redirect(reverse('logout')) me = get_me(request) return redirect(reverse("products:productpurchase", args=(pp.hashid, )))
def delete_account_link(self): return "%s%s" % ( settings.MAIL_BASE_URL, reverse("inkmail:delete_account", args=(self.delete_hash, ), host='mail'), )
def test_invalid_opt_in_click(self): self.assertEquals(Subscription.objects.count(), 0) email = Factory.rand_email() name = Factory.rand_name() subscription_url = Factory.rand_url() response = self.post( reverse( 'inkmail:subscribe', ), { 'first_name': name, 'email': email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }, ) self.assertEquals(response.status_code, 200) process_outgoing_message_queue() self.assertEquals(len(mail.outbox), 1) self.assertEquals(Subscription.objects.count(), 1) s = Subscription.objects.all()[0] self.assertIn(s.opt_in_link, mail.outbox[0].body) self.get("%s%s" % (s.opt_in_link, Factory.rand_str(length=2))) s = Subscription.objects.get(pk=s.pk) self.assertEquals(s.double_opted_in, False) self.assertEquals(s.double_opted_in_at, None)
def checkout_help_edition(request, course_slug): o = Organization.get() product = Product.get_from_slug(course_slug) try: me = get_me(request) except: return redirect( "%s?help_edition=1" % reverse("products:course_purchase", args=(product.slug, ))) purchase, purchase_created = Purchase.objects.get_or_create( person=me, help_edition=True, ) purchase.total = Decimal(0.00) purchase.save() pp, pp_created = ProductPurchase.objects.get_or_create( product=product, purchase=purchase, ) pp.send_purchase_email() # pp = ProductPurchase.objects.get(hashid=hashid) # if pp.purchase.person != me: # return redirect(reverse('logout')) return TemplateResponse( request, 'products/%s/checkout_success.html' % (product.slug, ), locals())
def unsubscribe_link(self): return "%s%s" % ( settings.MAIL_BASE_URL, reverse("inkmail:unsubscribe", args=(self.unsubscribe_hash, ), host='mail'), )
def course_purchase(request, course_slug): o = Organization.get() product = Product.get_from_slug(course_slug) purchased = False try: me = get_me(request) if me.products.filter(product=product).count() > 0: purchased = True pp = me.products.filter(product=product)[0] return redirect( reverse('products:productpurchase', args=(pp.hashid, ))) except: pass # if not me and request.method == 'GET': # cached_resp = cache.get("%s_purchase_not_logged_in%s" % (course_slug, request.META["QUERY_STRING"])) # if cached_resp: # return cached_resp # else: # resp = TemplateResponse( # request, 'products/%s/purchase.html' % ( # product.slug, # ), # locals() # ) # resp.render() # cache.set("%s_purchase_not_logged_in%s" % (course_slug, request.META["QUERY_STRING"]), resp) # return resp resp = TemplateResponse(request, 'products/%s/purchase.html' % (product.slug, ), locals()) # resp.render() return resp
def test_get_transfer_subscribe_200(self): email = Factory.rand_email() name = Factory.rand_name() response = self.get( reverse( 'inkmail:transfer_subscription', kwargs={ "transfer_code": self.newsletter.hashid, }, ), { 'f': name, 'e': email, # 'newsletter': self.newsletter.internal_name, }, ) self.assertEquals(response.status_code, 200) process_outgoing_message_queue() self.assertEquals(len(mail.outbox), 1) self.assertEquals(mail.outbox[0].subject, self.newsletter.welcome_message.subject) om = OutgoingMessage.objects.all()[0] self.assertIn( om.render_email_string( self.newsletter.welcome_message.body_text_unrendered), mail.outbox[0].alternatives[0][0]) self.assertIn( om.render_email_string( self.newsletter.welcome_message.body_text_unrendered, plain_text=True), mail.outbox[0].body) self.assertEquals(len(mail.outbox[0].to), 1) self.assertEquals(mail.outbox[0].to[0], email) self.assertEquals(mail.outbox[0].from_email, self.newsletter.full_from_email)
def test_post_subscribe_200(self): email = Factory.rand_email() name = Factory.rand_name() subscription_url = Factory.rand_url() response = self.post( reverse('inkmail:subscribe', ), { 'first_name': name, 'email': email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }, ) self.assertEquals(response.status_code, 200) process_outgoing_message_queue() self.assertEquals(len(mail.outbox), 1) self.assertEquals(mail.outbox[0].subject, self.newsletter.confirm_message.subject) self.assertEquals(OutgoingMessage.objects.count(), 1) om = OutgoingMessage.objects.all()[0] self.assertIn( om.render_email_string( self.newsletter.confirm_message.body_text_unrendered), mail.outbox[0].alternatives[0][0]) self.assertIn( om.render_email_string( self.newsletter.confirm_message.body_text_unrendered, plain_text=True), mail.outbox[0].body) self.assertEquals(len(mail.outbox[0].to), 1) self.assertEquals(mail.outbox[0].to[0], email) self.assertEquals(mail.outbox[0].from_email, self.newsletter.full_from_email)
def test_get_transfer_subscribe_200(self): email = Factory.rand_email() name = Factory.rand_name() response = self.get( reverse( 'inkmail:transfer_subscription', kwargs={ "transfer_code": self.newsletter.hashid, }, ), { 'f': name, 'e': email, # 'newsletter': self.newsletter.internal_name, }, ) self.assertEquals(response.status_code, 200) self.assertEquals(HistoricalEvent.objects.count(), 1) self.assertEquals(Person.objects.count(), 1) self.assertEquals(Subscription.objects.count(), 1) he = HistoricalEvent.objects.all()[0] p = Person.objects.all()[0] s = Subscription.objects.all()[0] self.assertEquals(he.event_type, "transfer-subscription") self.assertEquals(he.event_creator_type, "person") self.assertEquals(he.event_creator_pk, p.pk) self.assertHistoricalEventDataEquality( he, person=p, event_type="transfer-subscription", newsletter=self.newsletter, subscription=s, )
def test_post_subscribe_adds_person_and_subscription(self): email = Factory.rand_email() name = Factory.rand_name() subscription_url = Factory.rand_url() response = self.post( reverse('inkmail:subscribe', ), { 'first_name': name, 'email': email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }, ) self.assertEquals(response.status_code, 200) self.assertEquals(Person.objects.count(), 1) p = Person.objects.all()[0] self.assertEquals(p.first_name, name) self.assertEquals(p.email, email) self.assertEquals(Subscription.objects.count(), 1) s = Subscription.objects.all()[0] self.assertEquals(s.person, p) self.assertEquals(s.newsletter.name, self.newsletter.name) self.assertEquals(s.subscription_url, subscription_url) self.assertEquals(s.subscribed_from_ip, self._source_ip)
def test_no_first_name_subscribe_adds_person_and_subscription(self): email = Factory.rand_email() subscription_url = Factory.rand_url() response = self.post( reverse('inkmail:subscribe', ), json.dumps({ 'email': email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }), 'json', HTTP_X_REQUESTED_WITH='XMLHttpRequest', ) json_string = response.content.decode('utf-8') response_data = json.loads(json_string) self.assertEquals(response_data["success"], True) self.assertEquals(response.status_code, 200) self.assertEquals(Person.objects.count(), 1) p = Person.objects.all()[0] self.assertEquals(p.email, email) self.assertEquals(Subscription.objects.count(), 1) s = Subscription.objects.all()[0] self.assertEquals(s.person, p) self.assertEquals(s.newsletter.name, self.newsletter.name) self.assertEquals(s.subscription_url, subscription_url) self.assertEquals(s.subscribed_from_ip, self._source_ip)
def test_no_first_name_subscribe_adds_person_and_subscription(self): email = Factory.rand_email() response = self.get( reverse( 'inkmail:transfer_subscription', kwargs={ "transfer_code": self.newsletter.hashid, }, ), { 'e': email, # 'newsletter': self.newsletter.internal_name, }, ) self.assertEquals(response.status_code, 200) self.assertEquals(Person.objects.count(), 1) p = Person.objects.all()[0] self.assertEquals(p.email, email) self.assertEquals(Subscription.objects.count(), 1) s = Subscription.objects.all()[0] self.assertEquals(s.person, p) self.assertEquals(s.subscription_url, "transfer-subscription") self.assertEquals(s.newsletter.name, self.newsletter.name) self.assertEquals(s.subscribed_from_ip, self._source_ip)
def bestimator_experiment(request, slug): if "bestid" not in request.GET: now = timezone.now() bestid = "%s%s" % (now.time(), Factory.rand_str(length=10, include_emoji=False)) bestid = bestid.encode('utf-8').hex() return redirect("%s?bestid=%s" % ( reverse("products:bestimator_experiment", args=(slug, )), bestid, )) else: bestid = request.GET["bestid"] date = datetime.datetime.today() experiment = BestimatorExperiment.objects.get(slug=slug) answer_objs = BestimatorAnswer.objects.filter( experiment_choice__experiment=experiment, session_hash=bestid, ) if answer_objs.count() > 0: answers = {} for a in answer_objs: answers[a.experiment_choice.slug] = a return locals()
def test_post_subscribe_200(self): email = Factory.rand_email() name = Factory.rand_name() subscription_url = Factory.rand_url() response = self.post( reverse('inkmail:subscribe', ), { 'first_name': name, 'email': email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }, ) self.assertEquals(response.status_code, 200) self.assertEquals(HistoricalEvent.objects.count(), 1) self.assertEquals(Person.objects.count(), 1) self.assertEquals(Subscription.objects.count(), 1) he = HistoricalEvent.objects.all()[0] p = Person.objects.all()[0] s = Subscription.objects.all()[0] self.assertEquals(he.event_type, "subscribed") self.assertEquals(he.event_creator_type, "person") self.assertEquals(he.event_creator_pk, p.pk) self.assertHistoricalEventDataEquality( he, person=p, event_type="subscribed", newsletter=self.newsletter, subscription=s, )
def test_clicked_confirm_a_second_time(self): self.assertEquals(Subscription.objects.count(), 0) email = Factory.rand_email() name = Factory.rand_name() subscription_url = Factory.rand_url() response = self.post( reverse( 'inkmail:subscribe', ), { 'first_name': name, 'email': email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }, ) self.assertEquals(response.status_code, 200) process_outgoing_message_queue() self.assertEquals(len(mail.outbox), 1) self.assertEquals(Subscription.objects.count(), 1) s = Subscription.objects.all()[0] self.assertIn(s.opt_in_link, mail.outbox[0].body) self.get(s.opt_in_link) s = Subscription.objects.get(pk=s.pk) self.assertEquals(s.double_opted_in, True) self.assertBasicallyEqualTimes(s.double_opted_in_at, self.now()) first_time = s.double_opted_in_at # Click it again self.get(s.opt_in_link) s = Subscription.objects.get(pk=s.pk) self.assertEquals(s.double_opted_in, True) self.assertBasicallyEqualTimes(s.double_opted_in_at, first_time)
def delete_link(request, hashid): o = Organization.get() link = Link.objects.get(hashid=hashid) if request.method == "POST" and "delete" in request.POST and request.POST["delete"] == "DO_DELETE": link.delete() return redirect(reverse('clubhouse:links', host='clubhouse')) return locals()
def confirm_delete_journey(request, hashid): o = Organization.get() me = get_me(request) journey = Journey.objects.get(hashid=hashid) if journey.productpurchase.purchase.person != me: return redirect(reverse('logout')) return locals()
def test_normal_page_renders(self): t = Factory.template(content='{{rendered_page_html|safe}}') self.page = Factory.page( template=t, ) url = reverse('website:page_or_post', kwargs={"page_slug": self.page.slug, },) response = self.get(url) self.assertEquals(response.status_code, 200)
def delete_purchase(request, hashid): o = Organization.get() purchase = Purchase.objects.get(hashid=hashid) if request.method == "POST" and "delete" in request.POST and request.POST["delete"] == "DO_DELETE": purchase.delete() return redirect(reverse('clubhouse:purchases', host='clubhouse')) return locals()
def delete_journey(request, hashid): o = Organization.get() journey = Journey.objects.get(hashid=hashid) if request.method == "POST" and "delete" in request.POST and request.POST["delete"] == "DO_DELETE": journey.delete() return redirect(reverse('clubhouse:journeys', host='clubhouse')) return locals()
def feed_links(self): return ({ 'rel': u'alternate', 'href': self.feed_id() }, { 'rel': u'self', 'href': link(reverse('%s_feed' % type, 'blog')) })
def delete_bestimator_choice(request, hashid): o = Organization.get() bestimator_choice = BestimatorExperimentChoice.objects.get(hashid=hashid) if request.method == "POST" and "delete" in request.POST and request.POST["delete"] == "DO_DELETE": bestimator_choice.delete() return redirect(reverse('clubhouse:bestimator_choices', host='clubhouse')) return locals()
def delete_productday(request, hashid): o = Organization.get() productday = ProductDay.objects.get(hashid=hashid) if request.method == "POST" and "delete" in request.POST and request.POST["delete"] == "DO_DELETE": productday.delete() return redirect(reverse('clubhouse:productdays', host='clubhouse')) return locals()
def test_unsubscribe_resubscribe_updates_all_fields(self): self.assertEquals(len(mail.outbox), 0) self.create_subscribed_person() self.assertEquals(self.subscription.unsubscribed, False) self.assertEquals(self.subscription.unsubscribed_at, None) self.send_newsletter_message() self.assertEquals(len(mail.outbox), 1) m = mail.outbox[0] self.assertEquals(OutgoingMessage.objects.count(), 1) om = OutgoingMessage.objects.all()[0] # Unsubscribe self.assertIn(om.unsubscribe_link, m.body) self.get(om.unsubscribe_link) # Fetch updated subscription self.subscription = Subscription.objects.get(pk=self.subscription.pk) self.assertEquals(self.subscription.unsubscribed, True) self.assertBasicallyEqualTimes(self.subscription.unsubscribed_at, self.now()) # Re-subscribe name = Factory.rand_name() subscription_url = Factory.rand_url() response = self.post( reverse( 'inkmail:subscribe', ), { 'first_name': name, 'email': self.person.email, 'newsletter': self.newsletter.internal_name, 'subscription_url': subscription_url, }, ) self.assertEquals(response.status_code, 200) self.assertEquals(Subscription.objects.count(), 1) self.subscription = Subscription.objects.get(pk=self.subscription.pk) self.assertEquals(self.subscription.unsubscribed, False) self.assertEquals(self.subscription.unsubscribed_at, None) process_outgoing_message_queue() self.assertEquals(len(mail.outbox), 2) self.assertEquals(Subscription.objects.count(), 1) s = Subscription.objects.all()[0] self.assertIn(s.opt_in_link, mail.outbox[1].body) # Re-double-opt-in self.get(s.opt_in_link) self.subscription = Subscription.objects.get(pk=self.subscription.pk) self.assertEquals(self.subscription.unsubscribed, False) self.assertEquals(self.subscription.unsubscribed_at, None) process_outgoing_message_queue() # Check fields self.person = Person.objects.get(pk=self.person.pk) self.assertEquals(self.person.first_name, name) self.assertEquals(self.subscription.subscription_url, subscription_url)
def home(request): o = Organization.get() me = get_me(request) products = Product.objects.filter() if me.products.count() == 1: return redirect( reverse("products:productpurchase", args=(me.products.first().hashid, ))) return locals()
def create_resource(request): # o = Organization.get() p = Resource.objects.create() return redirect( reverse('clubhouse:resource', kwargs={ "hashid": p.hashid, }, host='clubhouse'))
def create_message(request): # o = Organization.get() m = Message.objects.create() return redirect( reverse('clubhouse:message', kwargs={ "hashid": m.hashid, }, host='clubhouse'))
def opt_in_link(self): if not self.opt_in_key or self.opt_in_key_created_at < timezone.now( ) - OPT_IN_LINK_EXPIRE_TIME: self.generate_opt_in_link() return "%s%s" % (settings.MAIL_BASE_URL, reverse("inkmail:confirm_subscription", args=(self.opt_in_key, ), host='mail'))
def feed_links(self, obj): return ({'rel': u'alternate', 'href': self.feed_id(obj)}, {'rel': u'self', 'href': link(reverse( '%s_feed' % type, 'tag/%s' % get_tags_bit(obj)))})
def get_server(): url = 'http://%s%s' % (Site.objects.get_current().domain, reverse('openid_endpoint')) return server.Server(DjangoidStore(), url)
def feed_id(self, obj): if obj: return link(obj.get_absolute_url()) else: return link('%s#comments' % reverse('post_list'))
def feed_id(self): return link(reverse('post_list'))
def feed_links(self, obj): return ({'rel': u'alternate', 'href': self.feed_id(obj)}, {'rel': u'self', 'href': link(reverse( '%s_feed' % type, 'comments/%s' % str(getattr(obj, 'id', ''))))})
def feed_links(self): return ({'rel': u'alternate', 'href': self.feed_id()}, {'rel': u'self', 'href': link(reverse('%s_feed' % type, 'blog'))})
def feed_id(self, obj): if not obj: raise Http404 return link(reverse('post_by_tag', tag=get_tags_bit(obj)))
def get_absolute_url(self): return reverse('post_detail', year=self.date.year, month=self.date.strftime('%m'), day=self.date.strftime('%d'), slug=self.slug)
def testEmailChange(self): self.assertEquals(self.client.login(email=self.old_email, password=self.name), True) response = self.client.post(reverse('profile_edit'), {'email': self.new_email}) self.assertEqual(len(mail.outbox), 1)
def get_absolute_url(self): return reverse('wpimport.views.post_detail', self.id)