def post(self, request, *args, **kwargs): form_class = self.get_form_class() form = self.get_form(form_class) form.full_clean() if form.is_valid(): username = form.cleaned_data['username'].replace(' ', '').lower() password = form.cleaned_data['password'] user = User.objects.create(username=username) user.email = form.cleaned_data['email'] user.set_password(password) user.is_active = False user.save() user_settings = UserSettings(user=user,credit=100) user_settings.save() logger.info('New user signed up: %s (%s)', user, user.email) # Automatically authenticate the user after user creation. #user_auth = authenticate(username=username, password=password) #login(request, user_auth) return self.form_valid(form) else: return self.form_invalid(form)
def get(self, request): context = {} stripe.api_key = settings.STRIPE_TEST_API_SECRET currentlyloggedinuser = "" usersettings = UserSettings() if request.user.is_authenticated: currentlyloggedinuser = request.user usersettings = usersettings.get_settings_based_on_user(currentlyloggedinuser) # Call Stripe Settings For The Link Generation context["call_state"] = settings.STRIPE_CALL_STATE context["stripe_acct"] = settings.STRIPE_ACCOUNT_ID # If this is from a Stripe Auth Page comm = StripeCommunication() response_code = request.GET.get("code", "") json_response = {} if response_code != "": json_response = comm.create_new_stripe_custom_account(response_code) if "stripe_user_id" in json_response: print("Found Stripe User ID") print(json_response["stripe_user_id"]) if "error_description" in json_response: context["error_description"] = json_response["error_description"] return render(request, self.template_name, context)
def setUp(self): # Necessary Currency Objects usd = Currency.objects.create() USA = Country() USA.PrimaryCurrency = usd USA.Name = "United States" USA.Code = "US" USA.save() # Types u1 = UserType.objects.create(Name="Kenny Type 1") u2 = UserType.objects.create(Name="Kenny Type 2") u3 = UserType.objects.create(Name="Kenny Type 3") kenny = User.objects.create( username="******", email="*****@*****.**", first_name="Kenny", last_name="Kim" ) # Has User Settings, has associated types, neither of the two fields we check kenny.set_password("Thing5Ar3Gr34t") kenny.save() settings_kenny = UserSettings() settings_kenny = settings_kenny.get_settings_based_on_user(kenny) settings_kenny.save() UserAssociatedTypes.objects.create(UserAccount=kenny, UserFreelanceType=u2) UserAssociatedTypes.objects.create(UserAccount=kenny, UserFreelanceType=u3)
def add_blog_post(req, podcast_slug): site = get_site(req, podcast_slug) if not payment_plans.minimum( UserSettings.get_from_user(site.podcast.owner).plan, payment_plans.FEATURE_MIN_BLOG): raise Http404() data = {'site': site} if not req.POST: return _pmrender(req, 'dashboard/sites/blog/page_new.html', data) try: naive_publish = datetime.datetime.strptime(req.POST.get('publish'), '%Y-%m-%dT%H:%M') # 2015-07-09T12:00 adjusted_publish = naive_publish - UserSettings.get_from_user(req.user).get_tz_delta() post = SiteBlogPost( site=site, title=req.POST.get('title'), slug=req.POST.get('slug'), body=req.POST.get('body'), publish=adjusted_publish ) post.save() except Exception as e: print e data.update(error=True, default=req.POST) return _pmrender(req, 'dashboard/sites/blog/page_new.html', data) else: return redirect('site_manage_blog', podcast_slug=podcast_slug)
def podcast_dashboard(req, podcast_slug): pod = get_podcast(req, podcast_slug) tz = UserSettings.get_from_user(req.user).tz_offset total_listens = analytics_query.total_listens(pod) total_listens_this_week = analytics_query.total_listens_this_week(pod, tz) subscribers = analytics_query.total_subscribers(pod) data = { 'podcast': pod, 'episodes': pod.podcastepisode_set.order_by('-publish'), 'analytics': { 'total_listens': total_listens, 'total_listens_this_week': total_listens_this_week, 'subscribers': subscribers, }, 'next_milestone': next(x for x in constants.MILESTONES if x > total_listens), 'previous_milestone': [x for x in constants.MILESTONES if x <= total_listens][-1] if total_listens > 0 else 0, 'hit_first_milestone': total_listens > constants.MILESTONES[1], # The first "real" milestone 'is_still_importing': pod.is_still_importing(), 'site': None, 'LOCALES': constants.locales, 'SITE_PAGE_TYPES': SitePage.PAGE_TYPES, 'SITE_THEMES': Site.SITE_THEMES, 'N_DESTINATIONS': NotificationHook.DESTINATIONS, 'N_TRIGGERS': NotificationHook.TRIGGERS, } try: data['site'] = pod.site except Site.DoesNotExist: pass owner_uset = UserSettings.get_from_user(pod.owner) if payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_COMMENT_BOX): all_feedback = Feedback.objects.filter(podcast=pod) data['feedback_all'] = all_feedback data['feedback'] = all_feedback.filter(episode=None).order_by('-created') data['feedback_episodes'] = (all_feedback.exclude(episode=None) .annotate(Count('episode', distinct=True)) .select_related('episode')) if payment_plans.minimum(owner_uset.plan, payment_plans.PLAN_PRO): sparkline_data = analytics_query.get_episode_sparklines(pod, tz) data['sparklines'] = sparkline_data if payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_NOTIFICATIONS): data['notifications'] = NotificationHook.objects.filter(podcast=pod) if req.GET.get('notification_sent'): data['notification_sent'] = True if payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_COLLABORATORS): data['collab_error'] = req.GET.get('collaberr') return _pmrender(req, 'dashboard/podcast/page_podcast.html', data)
def getUserSettings(self, request): currentlyloggedinuser = "" usersettings = UserSettings() if request.user.is_authenticated: currentlyloggedinuser = request.user usersettings = usersettings.get_settings_based_on_user(currentlyloggedinuser) return usersettings
def register(request, trial): page_type = 'register' if trial == 'trial': trial_account = True else: trial_account = False if request.method == 'POST': user_form = UserRegisterForm(request.POST, label_suffix='') group_form = GroupRegisterForm(request.POST, label_suffix='') if user_form.is_valid() and group_form.is_valid(): # save each form password = user_form.cleaned_data['password1'] new_user = user_form.save() group = group_form.save() # associate the user with the group u = new_user group.users.add(u) # set the group as the user's current_group settings = UserSettings(user=u, current_group=group) settings.save() # generate a slug from the group name slug = slugify(group.name)[:20] group.slug = slug group.save() # set the account status to trial if required if trial_account == True: group.account_type = 'Trial' group.save() # save initial snapshots of new user and group details snapshot_user_details(u, password='******') snapshot_group_details(group) # log the new user in user = authenticate(username=new_user.username, password=password) login(request, user) # set the new user up as a participant participant = Participant(group=group, email=user.email, first_name=user.first_name, last_name=user.last_name) participant.save() # send the new user a welcome email send_welcome_email(group=group, user=user) return HttpResponseRedirect(reverse('welcome')) else: user_form = UserRegisterForm(label_suffix='') group_form = GroupRegisterForm(label_suffix='') return render( request, 'register.html', { 'group_form': group_form, 'page_type': page_type, 'trial_account': trial_account, 'user_form': user_form, })
def register(request, trial): page_type = 'register' if trial == 'trial': trial_account = True else: trial_account = False if request.method == 'POST': user_form = UserRegisterForm(request.POST, label_suffix='') group_form = GroupRegisterForm(request.POST, label_suffix='') if user_form.is_valid() and group_form.is_valid(): # save each form password = user_form.cleaned_data['password1'] new_user = user_form.save() group = group_form.save() # associate the user with the group u = new_user group.users.add(u) # set the group as the user's current_group settings = UserSettings(user=u, current_group=group) settings.save() # generate a slug from the group name slug = slugify(group.name)[:20] group.slug = slug group.save() # set the account status to trial if required if trial_account == True: group.account_type = 'Trial' group.save() # save initial snapshots of new user and group details snapshot_user_details(u, password='******') snapshot_group_details(group) # log the new user in user = authenticate(username=new_user.username, password=password) login(request, user) # set the new user up as a participant participant = Participant(group=group, email=user.email, first_name=user.first_name, last_name=user.last_name) participant.save() # send the new user a welcome email send_welcome_email(group=group, user=user) return HttpResponseRedirect(reverse('welcome')) else: user_form = UserRegisterForm(label_suffix='') group_form = GroupRegisterForm(label_suffix='') return render(request, 'register.html', { 'group_form': group_form, 'page_type': page_type, 'trial_account': trial_account, 'user_form': user_form, })
def get_context_data(self, request, **kwargs): context = super(UserDashboardLowFi, self).get_context_data(**kwargs) user_settings = UserSettings() user_settings = user_settings.get_settings_based_on_user(request.user) user_contracts_where_relationship_exists = Relationship.objects.filter( ContractUser=request.user) all_recipients = Recipient.objects.all() all_milestones = Milestone.objects.all().order_by("Deadline") context["needs_stripe"] = user_settings.does_this_user_need_stripe() context["call_state"] = settings.STRIPE_CALL_STATE context["stripe_acct"] = settings.STRIPE_ACCOUNT_ID context["first_name"] = request.user.first_name context["projects_in_progress"] = [] context["upcoming_milestones"] = [] for relationship in user_contracts_where_relationship_exists: if relationship.ContractForRelationship.StartDate <= timezone.now( ).date( ) and relationship.ContractForRelationship.EndDate >= timezone.now( ).date(): # Get recipient and fill in entry for the in progress projects recipient_for_contract = all_recipients.filter( ContractForRecipient=relationship.ContractForRelationship ).first() context["projects_in_progress"].append({ "name": relationship.ContractForRelationship.Name, "progress": relationship.ContractForRelationship. get_contract_state_view(), "client": recipient_for_contract.Name }) # Get milestones for this contract that are still due contract_milestones = all_milestones.filter( MilestoneContract=relationship.ContractForRelationship) for milestone in contract_milestones: if milestone.Deadline >= timezone.now().date(): context["upcoming_milestones"].append({ "date": milestone.Deadline.strftime("%b %d %Y"), "name": milestone.Name, "project": milestone.MilestoneContract.Name, "amount": "{0:.2f}".format(milestone.MilestonePaymentAmount) }) return context
def edit_site(req, podcast_slug): site = get_site(req, podcast_slug) try: site.theme = req.POST.get('theme') site.cover_image_url = signer.unsign( req.POST.get('cover-url')) if req.POST.get('cover-url') else None site.logo_url = signer.unsign( req.POST.get('logo-url')) if req.POST.get('logo-url') else None site.analytics_id = req.POST.get('analytics_id') site.itunes_url = req.POST.get('itunes_url') site.stitcher_url = req.POST.get('stitcher_url') site.show_itunes_banner = req.POST.get('show_itunes_banner') == 'true' site.custom_css = req.POST.get('custom_css') site.custom_cname = req.POST.get('custom_cname') us = UserSettings.get_from_user(site.podcast.owner) if payment_plans.minimum(us.plan, payment_plans.FEATURE_MIN_BLOG): site.disqus_url = req.POST.get('disqus_url') if payment_plans.minimum(us.plan, payment_plans.FEATURE_MIN_SITE_FAVICON): site.favicon_url = signer.unsign(req.POST.get( 'favicon-url')) if req.POST.get('favicon-url') else None site.save() except Exception as e: return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '?error=true#settings,site-options') else: return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '#settings,site-options')
def new_site(req, podcast_slug): pod = get_podcast(req, podcast_slug) if not payment_plans.minimum( UserSettings.get_from_user(pod.owner).plan, payment_plans.FEATURE_MIN_SITES): raise Http404() try: site = Site( podcast=pod, theme=req.POST.get('theme'), cover_image_url=signer.unsign(req.POST.get('cover-url')) if req.POST.get('cover-url') else None, logo_url=signer.unsign(req.POST.get('logo-url')) if req.POST.get('logo-url') else None, analytics_id=req.POST.get('analytics_id'), itunes_url=req.POST.get('itunes_url'), stitcher_url=req.POST.get('stitcher_url'), show_itunes_banner=req.POST.get('show_itunes_banner') == 'true') site.save() except Exception as e: return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '?error=true#site') else: return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '#site')
def edit_blog_post(req, podcast_slug, post_slug): site = get_site(req, podcast_slug) post = get_object_or_404(SiteBlogPost, site=site, slug=post_slug) if not req.POST: return _pmrender(req, 'dashboard/sites/blog/page_edit.html', { 'site': site, 'post': post }) try: naive_publish = datetime.datetime.strptime( req.POST.get('publish', '').split('.')[0], '%Y-%m-%dT%H:%M:%S') # 2015-07-09T12:00 adjusted_publish = naive_publish - UserSettings.get_from_user( req.user).get_tz_delta() post.title = req.POST.get('title') post.slug = req.POST.get('slug') post.body = req.POST.get('body') post.publish = adjusted_publish post.disable_comments = req.POST.get('disable_comments') == 'true' post.save() except Exception as e: data.update(error=True, default=req.POST) return _pmrender(req, 'dashboard/sites/blog/page_edit.html', data) else: return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '#site,blog')
def add_blog_post(req, podcast_slug): site = get_site(req, podcast_slug) if not payment_plans.minimum( UserSettings.get_from_user(site.podcast.owner).plan, payment_plans.FEATURE_MIN_BLOG): raise Http404() try: publis_parsed = datetime.datetime.strptime( req.POST.get('publish', '').split('.')[0], '%Y-%m-%dT%H:%M:%S') post = SiteBlogPost( site=site, title=req.POST.get('title'), slug=req.POST.get('slug'), body=req.POST.get('body'), publish=publis_parsed, disable_comments=req.POST.get('disable_comments') == 'true') post.save() except Exception as e: print(e) return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '?error=sblog#site,blog') else: return redirect( reverse('podcast_dashboard', podcast_slug=podcast_slug) + '#site,blog')
def send_tip(req, podcast_slug): pod = get_object_or_404(Podcast, slug=podcast_slug) try: amount = int(float(req.POST.get('amount')) / 100.0) * 100 if amount < 100: return {'error': ugettext('Tips less than $1 are not allowed.')} except Exception: return HttpResponse(status=400) tip_type = req.POST.get('type') owner_us = UserSettings.get_from_user(pod.owner) if owner_us.plan == PLAN_DEMO and tip_type == 'subscribe': return {'error': ugettext('You cannot have recurring tips for free podcasts.')} if amount > PLAN_TIP_LIMITS[owner_us.plan]: return {'error': ugettext('That tip is too large for %s') % pod.name} if tip_type == 'charge': return _send_one_time_tip(req, pod, owner_us, amount) elif tip_type == 'subscribe': return _auth_subscription(req, pod, amount) else: return HttpResponse(status=400)
def tip_flow(req, podcast_slug): pod = get_object_or_404(Podcast, slug=podcast_slug) us = UserSettings.get_from_user(pod.owner) if not us.stripe_payout_managed_account: if pod.homepage: return redirect(pod.homepage) else: raise Http404() recurring_tip = None pay_session = req.session.get('pay_session') tipper = None if pay_session: tipper = TipUser.objects.get(id=pay_session, verified=True) try: recurring_tip = RecurringTip.objects.get( podcast=pod, tipper=tipper, deactivated=False) except Exception as e: pass ctx = {'error': req.GET.get('error'), 'recurring_tip': recurring_tip, 'podcast': pod, 'tipper': tipper} return _pmrender(req, 'payments/tip_jar/main.html', ctx)
def _pmrender(req, template, data=None): data = data or {} class DefaultEmptyDict(collections.defaultdict): def __init__(self): super(DefaultEmptyDict, self).__init__(lambda: '') def get(self, _, d=''): return d data.setdefault('settings', settings) data.setdefault('default', DefaultEmptyDict()) data['sign'] = lambda x: signer.sign(x.encode('utf-8')).decode('utf-8') if x else x if not req.user.is_anonymous(): data.setdefault('user', req.user) networks = set(req.user.network_set.filter(deactivated=False)) data.setdefault('networks', networks) podcasts = set(req.user.podcast_set.all()) podcasts |= set(Podcast.objects.filter(networks__in=networks)) podcasts |= { x.podcast for x in Collaborator.objects.filter(collaborator=req.user).select_related('podcast')} data.setdefault('podcasts', list(podcasts)) uset = UserSettings.get_from_user(req.user) data.setdefault('user_settings', uset) data.setdefault('tz_delta', uset.get_tz_delta()) data.setdefault('max_upload_size', payment_plans.MAX_FILE_SIZE[uset.plan]) data['is_admin'] = req.user.is_staff and bool(req.GET.get('admin')) return render(req, template, data)
def get_context_data(self, request, **kwargs): context = {} # Get user content settings usersettings = UserSettings() usersettings = usersettings.get_settings_based_on_user(request.user) # Set context for view context["name"] = request.user.first_name context["country"] = Country.objects.all() context["currency"] = Currency.objects.all() context["selected_country"] = usersettings.BaseCountry.IdCountry context[ "selected_country_currency"] = usersettings.BaseCountry.PrimaryCurrency.IdCurrency return context
def tip_flow(req, podcast_slug): pod = get_object_or_404(Podcast, slug=podcast_slug) us = UserSettings.get_from_user(pod.owner) if not us.stripe_payout_managed_account: if pod.homepage: return redirect(pod.homepage) else: raise Http404() recurring_tip = None pay_session = req.session.get('pay_session') tipper = None if pay_session: tipper = TipUser.objects.get(id=pay_session, verified=True) try: recurring_tip = RecurringTip.objects.get( podcast=pod, tipper=tipper, deactivated=False) except Exception as e: pass ctx = {'error': req.GET.get('error'), 'recurring_tip': recurring_tip, 'podcast': pod, 'tipper': tipper} return _pmrender(req, 'payments/tip_jar/main.html', ctx)
def send_tip(req, podcast_slug): pod = get_object_or_404(Podcast, slug=podcast_slug) try: amount = int(float(req.POST.get('amount')) / 100.0) * 100 if amount < 100: return {'error': ugettext('Tips less than $1 are not allowed.')} except Exception: return HttpResponse(status=400) tip_type = req.POST.get('type') owner_us = UserSettings.get_from_user(pod.owner) if owner_us.plan == PLAN_DEMO and tip_type == 'subscribe': return {'error': ugettext('You cannot have recurring tips for free podcasts.')} if amount > PLAN_TIP_LIMITS[owner_us.plan]: return {'error': ugettext('That tip is too large for %s') % pod.name} if tip_type == 'charge': return _send_one_time_tip(req, pod, owner_us, amount) elif tip_type == 'subscribe': return _auth_subscription(req, pod, amount) else: return HttpResponse(status=400)
def set_coupon(req): code = req.POST.get('coupon') try: coupon = stripe.Coupon.retrieve(code) except stripe.error.InvalidRequestError: return redirect(reverse('upgrade') + '?coupon_invalid') if not coupon.valid: return redirect(reverse('upgrade') + '?coupon_invalid') if 'owner_id' in coupon.metadata: us = UserSettings.get_from_user(req.user) if us.plan != payment_plans.PLAN_DEMO: return redirect(reverse('upgrade') + '?coupon_unavailable') try: cust = us.get_stripe_customer() except Exception: pass else: if len(stripe.Invoice.list(customer=cust.id, limit=1).data): return redirect(reverse('upgrade') + '?coupon_unavailable') req.session['coupon'] = code return redirect(reverse('upgrade') + '?coupon_applied')
def get_episodes(self): episodes = self.podcastepisode_set.filter(publish__lt=datetime.datetime.now(), awaiting_import=False).order_by( "-publish" ) if UserSettings.get_from_user(self.owner).plan == payment_plans.PLAN_DEMO: episodes = episodes[:10] return episodes
def podcast_geochart(req, podcast_slug): pod = get_podcast(req, podcast_slug) owner_uset = UserSettings.get_from_user(pod.owner) if not payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_GEOANALYTICS): return _pmrender(req, 'dashboard/podcast/page_geochart_upgrade.html', {'podcast': pod}) return _pmrender(req, 'dashboard/podcast/page_geochart.html', {'podcast': pod})
def get_html_description(self, is_demo=None): raw = self.description if is_demo is None: us = UserSettings.get_from_user(self.podcast.owner) is_demo = us.plan == payment_plans.PLAN_DEMO available_flags = self.podcast.get_available_flair_flags(flatten=True) if (self.flair_tip_jar and FLAIR_TIP_JAR in available_flags): raw += '\n\nSupport %s by donating to the [tip jar](https://pinecast.com/payments/tips/%s).' % ( self.podcast.name, self.podcast.slug) if (self.flair_site_link and FLAIR_SITE_LINK in available_flags): raw += '\n\nFind out more at [%s](http://%s.pinecast.co).' % ( self.podcast.name, self.podcast.slug) if (self.flair_feedback and FLAIR_FEEDBACK in available_flags): prompt = self.get_feedback_prompt() fb_url = 'https://pinecast.com%s' % reverse( 'ep_comment_box', podcast_slug=self.podcast.slug, episode_id=str(self.id)) raw += '\n\n%s [%s](%s)' % (prompt, fb_url, fb_url) if (is_demo or self.flair_powered_by and FLAIR_SITE_LINK in available_flags): raw += ('\n\nThis podcast is powered by ' '[Pinecast](https://pinecast.com).') markdown = gfm.markdown(raw) return sanitize(markdown)
def podcast_top_episodes(req, podcast_slug): pod = get_podcast(req, podcast_slug) owner_uset = UserSettings.get_from_user(pod.owner) if not payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_COMMENT_BOX): return _pmrender(req, 'dashboard/podcast/page_top_episodes_upgrade.html', {'podcast': pod}) with analytics_query.AsyncContext() as async_ctx: top_ep_data_query = analytics_query.get_top_episodes(unicode(pod.id), async_ctx) top_ep_data = top_ep_data_query() ep_ids = [x['episode'] for x in top_ep_data] episodes = PodcastEpisode.objects.filter(id__in=ep_ids) mapped = {unicode(ep.id): ep for ep in episodes} # This step is necessary to filter out deleted episodes top_ep_data = [x for x in top_ep_data if x['episode'] in mapped] # Sort the top episode data descending top_ep_data = reversed(sorted(top_ep_data, key=lambda x: x['podcast'])) data = { 'podcast': pod, 'episodes': mapped, 'top_ep_data': top_ep_data, } return _pmrender(req, 'dashboard/podcast/page_top_episodes.html', data)
def podcast_dashboard(req, podcast_slug): pod = get_podcast(req, podcast_slug) with analytics_query.AsyncContext() as async_ctx: total_listens = analytics_query.total_listens(pod, async_ctx) total_listens_this_week = analytics_query.total_listens_this_week(pod, async_ctx) subscribers = analytics_query.total_subscribers(pod, async_ctx) listens = total_listens() data = { 'podcast': pod, 'episodes': pod.podcastepisode_set.order_by('-publish'), 'analytics': { 'total_listens': listens, 'total_listens_this_week': total_listens_this_week(), 'subscribers': subscribers(), }, 'next_milestone': next(x for x in MILESTONES if x > listens), 'previous_milestone': [x for x in MILESTONES if x <= listens][-1] if listens else 0, 'hit_first_milestone': listens > MILESTONES[1], # The first "real" milestone 'is_still_importing': pod.is_still_importing(), } owner_uset = UserSettings.get_from_user(pod.owner) if payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_COMMENT_BOX): data['feedback'] = Feedback.objects.filter(podcast=pod, episode=None).order_by('-created') return _pmrender(req, 'dashboard/podcast/page_podcast.html', data)
def new_network(req): uset = UserSettings.get_from_user(req.user) if not plans.minimum(uset.plan, plans.FEATURE_MIN_NETWORK): return _pmrender(req, 'dashboard/network/page_new_upgrade.html') if not req.POST: return _pmrender(req, 'dashboard/network/page_new.html') try: net = Network( name=req.POST.get('name'), owner=req.user, image_url=signer.unsign(req.POST.get('image-url')) if req.POST.get('image-url') else None ) net.save() net.members.add(req.user) net.save() except Exception as e: print e return _pmrender(req, 'dashboard/network/page_new.html', {'error': ugettext('Error while saving network details'), 'default': req.POST}) return redirect('network_dashboard', network_id=net.id)
def podcast_top_episodes(req, pod): timeframe = req.GET.get('timeframe') if not timeframe: return None tz = UserSettings.get_from_user(req.user).tz_offset top_ep_data = query.get_top_episodes(str(pod.id), timeframe, tz) episodes = PodcastEpisode.objects.filter(id__in=list(top_ep_data.keys())) mapped = {str(ep.id): ep for ep in episodes} # This step is necessary to filter out deleted episodes, since deleted episodes # are not removed from the analytics data. top_ep_data = {k: v for k, v in top_ep_data.items() if k in mapped} # Sort the top episode data descending return [[ugettext('Episode'), ugettext('Count')]] + [[ { 'href': reverse('podcast_episode', podcast_slug=pod.slug, episode_id=ep_id), 'title': mapped[ep_id].title, }, count, ] for ep_id, count in list( reversed(sorted(top_ep_data.items(), key=lambda x: x[1])))[:25]]
def new_podcast(req): uset = UserSettings.get_from_user(req.user) if payment_plans.has_reached_podcast_limit(uset): return _pmrender(req, 'dashboard/podcast/page_new_upgrade.html') ctx = {'PODCAST_CATEGORIES': json.dumps(list(CATEGORIES))} if not req.POST: return _pmrender(req, 'dashboard/podcast/page_new.html', ctx) try: pod = Podcast( slug=req.POST.get('slug'), name=req.POST.get('name'), subtitle=req.POST.get('subtitle'), cover_image=signer.unsign(req.POST.get('image-url')), description=req.POST.get('description'), is_explicit=req.POST.get('is_explicit', 'false') == 'true', homepage=req.POST.get('homepage'), language=req.POST.get('language'), copyright=req.POST.get('copyright'), author_name=req.POST.get('author_name'), owner=req.user) pod.save() # TODO: The following line can throw an exception and create a # duplicate podcast if something has gone really wrong pod.set_category_list(req.POST.get('categories')) except Exception as e: ctx.update(default=req.POST, error=True) return _pmrender(req, 'dashboard/podcast/page_new.html', ctx) return redirect('podcast_dashboard', podcast_slug=pod.slug)
def _pmrender(req, template, data=None): data = data or {} class DefaultEmptyDict(collections.defaultdict): def __init__(self): super(DefaultEmptyDict, self).__init__(lambda: '') def get(self, _, d=''): return d data.setdefault('settings', settings) data.setdefault('default', DefaultEmptyDict()) data['sign'] = lambda x: signer.sign(x) if x else x if not req.user.is_anonymous(): data.setdefault('user', req.user) networks = req.user.network_set.filter(deactivated=False) data.setdefault('networks', networks) podcasts = set(req.user.podcast_set.all()) for network in networks: for p in network.podcast_set.all(): podcasts.add(p) data.setdefault('podcasts', podcasts) uset = UserSettings.get_from_user(req.user) data.setdefault('user_settings', uset) data.setdefault('tz_delta', uset.get_tz_delta()) data.setdefault('max_upload_size', payment_plans.MAX_FILE_SIZE[uset.plan]) return render(req, template, data)
def get_html_description(self, is_demo=None): raw = self.description if is_demo is None: us = UserSettings.get_from_user(self.podcast.owner) is_demo = us.plan == payment_plans.PLAN_DEMO available_flags = self.podcast.get_available_flair_flags(flatten=True) if self.flair_tip_jar and FLAIR_TIP_JAR in available_flags: raw += "\n\nSupport %s by donating to the [tip jar](https://pinecast.com/payments/tips/%s)." % ( self.podcast.name, self.podcast.slug, ) if self.flair_site_link and FLAIR_SITE_LINK in available_flags: raw += "\n\nFind out more at [%s](http://%s.pinecast.co)." % (self.podcast.name, self.podcast.slug) if self.flair_feedback and FLAIR_FEEDBACK in available_flags: prompt = self.get_feedback_prompt() fb_url = "https://pinecast.com%s" % reverse( "ep_comment_box", podcast_slug=self.podcast.slug, episode_id=str(self.id) ) raw += "\n\n%s [%s](%s)" % (prompt, fb_url, fb_url) if is_demo or self.flair_powered_by and FLAIR_SITE_LINK in available_flags: raw += "\n\nThis podcast is powered by " "[Pinecast](https://pinecast.com)." markdown = gfm.markdown(raw) return sanitize(markdown)
def new_site(req, podcast_slug): pod = get_podcast(req, podcast_slug) if not payment_plans.minimum( UserSettings.get_from_user(pod.owner).plan, payment_plans.FEATURE_MIN_SITES): raise Http404() data = { 'podcast': pod, 'themes': Site.SITE_THEMES, } if not req.POST: return _pmrender(req, 'dashboard/sites/page_new.html', data) try: site = Site( podcast=pod, theme=req.POST.get('theme'), cover_image_url=signer.unsign(req.POST.get('cover-url')) if req.POST.get('cover-url') else None, logo_url=signer.unsign(req.POST.get('logo-url')) if req.POST.get('logo-url') else None, analytics_id=req.POST.get('analytics_id'), itunes_url=req.POST.get('itunes_url'), stitcher_url=req.POST.get('stitcher_url') ) site.save() except Exception as e: print e data.update(error=True, default=req.POST) return _pmrender(req, 'dashboard/sites/page_new.html', data) else: return redirect('site_options', podcast_slug=podcast_slug)
def _pmrender(req, template, data=None): data = data or {} class DefaultEmptyDict(collections.defaultdict): def __init__(self): super(DefaultEmptyDict, self).__init__(lambda: '') def get(self, _, d=''): return d data.setdefault('settings', settings) data.setdefault('default', DefaultEmptyDict()) data['sign'] = lambda x: signer.sign(x.encode('utf-8')).decode('utf-8') if x else x if not req.user.is_anonymous(): data.setdefault('user', req.user) networks = req.user.network_set.filter(deactivated=False) data.setdefault('networks', networks) podcasts = list(set( req.user.podcast_set.all() | Podcast.objects.filter(networks__in=networks))) data.setdefault('podcasts', podcasts) uset = UserSettings.get_from_user(req.user) data.setdefault('user_settings', uset) data.setdefault('tz_delta', uset.get_tz_delta()) data.setdefault('max_upload_size', payment_plans.MAX_FILE_SIZE[uset.plan]) data['is_admin'] = req.user.is_staff and bool(req.GET.get('admin')) return render(req, template, data)
def get_episodes(self): episodes = self.get_all_episodes_raw().filter( publish__lt=round_now(), awaiting_import=False).order_by('-publish') us = UserSettings.get_from_user(self.owner) if us.plan == payment_plans.PLAN_DEMO: episodes = episodes[:10] return episodes
def episode_geochart(req, podcast_slug, episode_id): pod = get_podcast(req, podcast_slug) owner_uset = UserSettings.get_from_user(pod.owner) ep = get_object_or_404(PodcastEpisode, podcast=pod, id=episode_id) if not payment_plans.minimum(owner_uset.plan, payment_plans.FEATURE_MIN_GEOANALYTICS_EP): return _pmrender(req, 'dashboard/episode/page_geochart_upgrade.html', {'podcast': pod, 'episode': ep}) return _pmrender(req, 'dashboard/episode/page_geochart.html', {'podcast': pod, 'episode': ep})
def get_subscription(self): us = UserSettings.get_from_user(self.podcast.owner) stripe_account = us.stripe_payout_managed_account try: return stripe.Subscription.retrieve(self.stripe_subscription_id, stripe_account=stripe_account) except stripe.error.InvalidRequestError: return None
def importer(req): uset = UserSettings.get_from_user(req.user) if uset.plan == plans.PLAN_DEMO: return _pmrender(req, 'dashboard/page_importer_upgrade.html', {'reached_limit': False}) elif plans.has_reached_podcast_limit(uset): return _pmrender(req, 'dashboard/page_importer_upgrade.html', {'reached_limit': True}) else: return _pmrender(req, 'dashboard/page_importer.html')
def player(req, episode_id): ep = get_object_or_404(PodcastEpisode, id=episode_id) resp = render(req, 'player.html', {'episode': ep}) # If the user is not a demo user, allow the player to be used outside the app. if UserSettings.user_meets_plan(ep.podcast.owner, plans.FEATURE_MIN_PLAYER): resp.xframe_options_exempt = True return resp
def get_subscription(self): us = UserSettings.get_from_user(self.podcast.owner) stripe_account = us.stripe_payout_managed_account try: return stripe.Subscription.retrieve( self.stripe_subscription_id, stripe_account=stripe_account) except stripe.error.InvalidRequestError: return None
def get_domain(self): if not self.custom_cname: return self.get_subdomain() us = UserSettings.get_from_user(self.podcast.owner) if not minimum(us.plan, FEATURE_MIN_SITES): return self.get_subdomain() return 'http://%s' % self.custom_cname
def get_domain(self): if not self.custom_cname: return self.get_subdomain() us = UserSettings.get_from_user(self.podcast.owner) if not minimum(us.plan, FEATURE_MIN_SITES): return self.get_subdomain() return "http://%s" % self.custom_cname
def setUp(self): # Necessary Currency Objects usd = Currency.objects.create() USA = Country() USA.PrimaryCurrency = usd USA.Name = "United States" USA.Code = "US" USA.save() # Types u1 = UserType.objects.create(Name="Clara Type 1") u2 = UserType.objects.create(Name="Clara Type 2") u3 = UserType.objects.create(Name="Clara Type 3") clara = User.objects.create( username="******", email="*****@*****.**", first_name="Clara", last_name="Chang") # Has User Settings, no associated types clara.set_password("Thing5Ar3Gr34t") clara.save() settings_clara = UserSettings() settings_clara = settings_clara.get_settings_based_on_user(clara) settings_clara.BusinessName = "InFlow" settings_clara.Region = "New York" settings_clara.save()
def post(self, request): context = self.get_context_data(request) selected_frequency = request.POST.get( "frequency", UserSettings._meta.get_field("FreelancerFrequency").get_default()) other_text = request.POST.get("other", "") # Go through each UserType and see what was selected, add that to the DB # Remove anything that was previously selected UserAssociatedTypes.objects.filter(UserAccount=request.user).delete() for type in self.all_user_types: current_type = request.POST.get(type.Name, "") if current_type == "on": UserAssociatedTypes.objects.create(UserAccount=request.user, UserFreelanceType=type) # Build up user settings or fetch previously saved ones, then save what was selected as the freelancer frequency type usersettings = UserSettings() usersettings = usersettings.get_settings_based_on_user(request.user) usersettings.FreelancerFrequency = selected_frequency usersettings.OtherType = other_text usersettings.save() return redirect(reverse("accounts:onboarding_2"))
def testKennyPostTryToChangeToClara(self): kenny = User.objects.get(username="******") settings_kenny = UserSettings() settings_kenny = settings_kenny.get_settings_based_on_user(kenny) c = Client() loginAttempt = c.login(username='******', password='******') response = c.post( '/account/settings', { 'first-name': 'Snickity', 'last-name': 'Snack', 'email-address': '*****@*****.**', 'phone-number': '2121234567' }) self.assertTrue("error_message" in response.context)
def upgrade(req): us = UserSettings.get_from_user(req.user) customer = us.get_stripe_customer() ctx = { 'stripe_customer': customer, } return _pmrender(req, 'payments/main.html', ctx)
def player(req, episode_id): ep = get_object_or_404(PodcastEpisode, id=episode_id) resp = render(req, 'player.html', {'episode': ep}) # If the user is not a demo user, allow the player to be used outside the app. if UserSettings.user_meets_plan(ep.podcast.owner, plans.FEATURE_MIN_PLAYER): resp.xframe_options_exempt = True return resp
def setUp(self): # Necessary Currency Objects usd = Currency.objects.create() USA = Country() USA.PrimaryCurrency = usd USA.Name = "United States" USA.Code = "US" USA.save() # Users brian_1 = User.objects.create(username="******", email="*****@*****.**", first_name="Brian", last_name="Katchmar") brian_1.set_password("Th3L10nK1ng15Fun") brian_1.save() settings_brian_1 = UserSettings() settings_brian_1 = settings_brian_1.get_settings_based_on_user(brian_1) settings_brian_1.save() brian_2 = User.objects.create(username="******", email="*****@*****.**", first_name="Brian", last_name="Katchmar") brian_2.set_password("Th3L10nK1ng15Fun") brian_2.save() settings_brian_2 = UserSettings() settings_brian_2 = settings_brian_2.get_settings_based_on_user(brian_2) settings_brian_2.save() if not Contract.objects.filter(Name=self.contract_name_1).exists(): contract_1 = Contract.objects.create(Creator=brian_1, Name=self.contract_name_1, StartDate=date.today(), EndDate=date.today()) Relationship.objects.create(ContractUser=brian_1, ContractForRelationship=contract_1, RelationshipType="f") Relationship.objects.create(ContractUser=brian_2, ContractForRelationship=contract_1, RelationshipType="c")
def set_payment_method(req): us = UserSettings.get_from_user(req.user) customer = us.get_stripe_customer() if customer: customer.source = req.POST.get('token') customer.save() else: us.create_stripe_customer(req.POST.get('token')) return {'success': True, 'id': us.stripe_customer_id}
def manage_blog(req, podcast_slug): site = get_site(req, podcast_slug) if not payment_plans.minimum( UserSettings.get_from_user(site.podcast.owner).plan, payment_plans.FEATURE_MIN_BLOG): raise Http404() return _pmrender(req, 'dashboard/sites/blog/page_manage.html', {'site': site, 'posts': site.siteblogpost_set.all().order_by('-publish')})
def get_context_data(self, request, **kwargs): # Get some necessary User Information user_settings = UserSettings() user_settings = user_settings.get_settings_based_on_user(request.user) # Set the context context = super(EditAccountView, self).get_context_data(**kwargs) # Call Stripe Settings For The Link Generation context["needs_stripe"] = user_settings.does_this_user_need_stripe() context["call_state"] = settings.STRIPE_CALL_STATE context["stripe_acct"] = settings.STRIPE_ACCOUNT_ID # If this is from a Stripe Auth Page comm = StripeCommunication() response_code = request.GET.get("code", "") stripe_state = request.GET.get("state", "") json_response = {} # We need to check if this request even came from Stripe if response_code != "": json_response = comm.create_new_stripe_custom_account( response_code) context["came_from_stripe"] = True if stripe_state != settings.STRIPE_CALL_STATE: context["error_message"] = "Bad Call State" context["needs_stripe"] = True else: context["came_from_stripe"] = False # Did we get the stripe User ID in the response? if "stripe_user_id" in json_response: context["user_stripe_acct"] = json_response["stripe_user_id"] else: context["user_stripe_acct"] = "" # Did the response come with an error description? if "error_description" in json_response: context["error_message"] = json_response["error_description"] context["needs_stripe"] = True return context
def favicon(req, podcast_slug): pod = get_object_or_404(Podcast, slug=podcast_slug) us = UserSettings.get_from_user(pod.owner) if not minimum(us.plan, FEATURE_MIN_SITE_FAVICON): return redirect('https://pinecast.com/static/img/favicon.png') site = get_object_or_404(models.Site, podcast=pod) if not site.favicon_url: return redirect('https://pinecast.com/static/img/favicon.png') return redirect(site.favicon_url)
def favicon(req, podcast_slug): pod = get_object_or_404(Podcast, slug=podcast_slug) us = UserSettings.get_from_user(pod.owner) if not minimum(us.plan, FEATURE_MIN_SITE_FAVICON): return redirect('https://pinecast.com/static/img/favicon.png') site = get_object_or_404(models.Site, podcast=pod) if not site.favicon_url: return redirect('https://pinecast.com/static/img/favicon.png') return redirect(site.favicon_url)
def get_remaining_surge(self, max_size): uset = UserSettings.get_from_user(self.owner) if not payment_plans.minimum(uset.plan, payment_plans.PLAN_STARTER): return 0 thirty_ago = datetime.datetime.now() - datetime.timedelta(days=30) last_thirty_eps = self.podcastepisode_set.filter(created__gt=thirty_ago, audio_size__gt=max_size) surge_count = last_thirty_eps.count() surge_amt = last_thirty_eps.aggregate(models.Sum("audio_size"))["audio_size__sum"] or 0 surge_amt -= surge_count * max_size remaining = max_size - surge_amt return 0 if remaining < 0 else remaining
def post(self, request): context = self.get_context_data(request) # Gather Data From Post selected_work_with = request.POST.get( "work-with", UserSettings._meta.get_field("FreelancerWorkWith").get_default()) # Remove anything that was previously selected UserInterest.objects.filter(UserAccount=request.user).delete() for interest in FREELANCER_INTERESTED_IN: interest_point = request.POST.get(interest[0], "") if interest_point == "on": UserInterest.objects.create(UserAccount=request.user, Interest=interest[0]) # Build up user settings or fetch previously saved ones, then save what was selected as the freelancer work with and interested in usersettings = UserSettings() usersettings = usersettings.get_settings_based_on_user(request.user) usersettings.FreelancerWorkWith = selected_work_with usersettings.save() return redirect(reverse("accounts:onboarding_3"))
def testClaraGet(self): kenny = User.objects.get(username="******") clara = User.objects.get(username="******") settings_kenny = UserSettings() settings_kenny = settings_kenny.get_settings_based_on_user(kenny) settings_clara = UserSettings() settings_clara = settings_clara.get_settings_based_on_user(clara) c = Client() loginAttempt = c.login(username='******', password='******') response = c.get("/account/settings") self.assertNotEqual(response.context["first_name"], kenny.first_name) self.assertNotEqual(response.context["last_name"], kenny.last_name) self.assertNotEqual(response.context["email"], kenny.email) self.assertNotEqual(response.context["phone_number"], "") self.assertEqual(response.context["first_name"], clara.first_name) self.assertEqual(response.context["last_name"], clara.last_name) self.assertEqual(response.context["email"], clara.email) self.assertEqual(response.context["phone_number"], settings_clara.PhoneNumber)
def podcast_new_ep(req, podcast_slug): pod = get_podcast(req, podcast_slug) tz_delta = UserSettings.get_from_user(req.user).get_tz_delta() latest_episode = pod.get_most_recent_episode() ctx = { 'podcast': pod, 'latest_ep': latest_episode, } if not req.POST: base_default = EmptyStringDefaultDict() base_default['publish'] = datetime.datetime.strftime( datetime.datetime.now() + tz_delta, '%Y-%m-%dT%H:%M' # 2015-07-09T12:00 ) ctx['default'] = base_default return _pmrender(req, 'dashboard/episode/page_new.html', ctx) try: publish_parsed = datetime.datetime.strptime(req.POST.get('publish').split('.')[0], ISO_FORMAT) image_url = req.POST.get('image-url') ep = PodcastEpisode( podcast=pod, title=req.POST.get('title'), subtitle=req.POST.get('subtitle'), publish=publish_parsed, description=req.POST.get('description'), duration=int(req.POST.get('duration-hours')) * 3600 + int(req.POST.get('duration-minutes')) * 60 + int(req.POST.get('duration-seconds')), audio_url=signer.unsign(req.POST.get('audio-url')), audio_size=int(req.POST.get('audio-url-size')), audio_type=req.POST.get('audio-url-type'), image_url=signer.unsign(image_url) if image_url else pod.cover_image, copyright=req.POST.get('copyright'), license=req.POST.get('license'), explicit_override=req.POST.get('explicit_override')) ep.set_flair(req.POST, no_save=True) ep.save() if req.POST.get('feedback_prompt'): prompt = EpisodeFeedbackPrompt(episode=ep, prompt=req.POST.get('feedback_prompt')) prompt.save() except Exception as e: raise e ctx['error'] = True ctx['default'] = req.POST return _pmrender(req, 'dashboard/episode/page_new.html', ctx) return redirect('podcast_dashboard', podcast_slug=pod.slug)
def _process(self): assert self.selection select = ', '.join( select_format(k, v) for k, v in self.selection.items()) where = '' group_by = '' tz = UserSettings.get_from_user(self.req.user).tz_offset if self.criteria: where = ' AND '.join( where_format(k, v) for k, v in self.criteria.items() ) if self.group_by: if isinstance(self.group_by, (list, tuple)): group_by = ', '.join(ident(x) for x in self.group_by) else: group_by = ident(self.group_by) if self.timeframe: tf = USER_TIMEFRAMES.get( self.req.GET.get('timeframe', self.timeframe), lambda tz: None)(tz) if tf: if where: where += ' AND ' where += tf if self.interval_val: if group_by: group_by += ', ' group_by += INTERVALS[self.interval_val] query = 'SELECT %s FROM %s' % (select, ident(self.event_type)) if where: query += ' WHERE %s' % where if group_by: query += ' GROUP BY %s' % group_by query += ';' # if settings.DEBUG: # print(query) self.res = get_client().query(query, database=self.db) return self
def cancel(self): us = UserSettings.get_from_user(self.podcast.owner) try: subscription = stripe.Subscription.retrieve( self.stripe_subscription_id, stripe_account=us.stripe_payout_managed_account) except stripe.error.InvalidRequestError: pass else: subscription.delete() finally: self.deactivated = True self.save()
def signup(req): if not req.user.is_anonymous(): return redirect('dashboard') if not req.POST: return _pmrender( req, 'signup/main.html', {'email': req.GET.get('email', '')} ) error = None if not _validate_recaptcha(req): error = ugettext('Your humanity was not verified') elif not req.POST.get('email'): error = ugettext('Missing email address') elif not req.POST.get('password'): error = ugettext('Come on, you need a password') elif len(req.POST.get('password')) < 8: error = ugettext('Your password needs to be at least 8 characters long') elif User.objects.filter(email=req.POST.get('email')).count(): error = ugettext('That email address is already associated with an account') if error: return _pmrender(req, 'signup/main.html', { 'error': error, 'email': req.POST.get('email'), }) try: u = User.objects.create_user( str(uuid.uuid4())[:30], req.POST.get('email'), req.POST.get('password') ) u.save() except Exception as e: return _pmrender(req, 'signup/main.html', { 'error': str(e), 'email': req.POST.get('email'), }) try: us = UserSettings.get_from_user(u) us.tz_offset = req.POST.get('timezone') us.save() except Exception: pass # whatever. return redirect(reverse('login') + '?signup_success=true')
def process_request(self, req): scheme = 'http' if not req.is_secure() else 'https' domain = req.META.get('HTTP_HOST') or req.META.get('SERVER_NAME') if settings.DEBUG and ':' in domain: domain = domain[:domain.index(':')] pc_forward = req.META.get('HTTP_X_PINECAST_FORWARD') if pc_forward: try: site = Site.objects.get(custom_cname__iexact=pc_forward) us = UserSettings.get_from_user(site.podcast.owner) if not minimum(us.plan, FEATURE_MIN_CNAME): raise NotCNAMEReadyException() return self._resolve(req, site.podcast.slug) except (Site.DoesNotExist, NotCNAMEReadyException): pass pieces = domain.split('.') if len(pieces) != 3: return None if domain[len(pieces[0]):] not in SUBDOMAIN_HOSTS: return None try: pod = Podcast.objects.get(slug__iexact=pieces[0]) site = Site.objects.get(podcast=pod) except (Site.DoesNotExist, Podcast.DoesNotExist): return None us = UserSettings.get_from_user(pod.owner) if minimum(us.plan, FEATURE_MIN_CNAME) and site.custom_cname: return redirect( '%s://%s%s' % (scheme, site.custom_cname, req.get_full_path()), permanent=True) return self._resolve(req, pod.slug)
def upgrade(req): us = UserSettings.get_from_user(req.user) customer = us.get_stripe_customer() ctx = { 'active_coupon': req.session.get('coupon'), 'coupon_applied': 'coupon_applied' in req.GET, 'coupon_invalid': 'coupon_invalid' in req.GET, 'coupon_unavailable': 'coupon_unavailable' in req.GET, 'error': req.GET.get('error'), 'stripe_customer': customer, 'success': 'success' in req.GET, } return _pmrender(req, 'payments/main.html', ctx)