Esempio n. 1
0
def add(request, constituency_slug=None):
    """ Report the addition of a leaflet """  
    context = {}
    leaflet_urls = request.GET.getlist('v1') \
                   or request.POST.getlist('v1')

    c = None
    if constituency_slug:
        year = settings.CONSTITUENCY_YEAR
        c = Constituency.objects.get(slug=constituency_slug,
                                     year=year)
    else:
        c = request.user.home_constituency
    
    leaflet = None
    for url in leaflet_urls:
        leaflet = UploadedLeaflet.objects.create(url=url,
                                       user=request.user,
                                       constituency=c)

        signals.leaflet_added.send(None, user=request.user, constituency=c)
    if leaflet:
        # return HttpResponseRedirect(reverse('tasks'))
        context['constituency'] = c
        context['leaflet'] = leaflet
        return render_with_context(request, 'tsc/thanks.html', context)
    else:
        return render_with_context(request, 'tsc/add.html', context)
Esempio n. 2
0
def home(request):
    context = _get_statistics_context()    
    if request.user.hassling: # Send them off a-hasslin'
        request.user.hassling = False
        request.user.save()
        return HttpResponseRedirect(reverse('constituency', args=[request.user.home_constituency.slug]) + "#candidates")    

    tasks = TaskUser.objects.filter(
            user=request.user).order_by('state', 'date_assigned')
    open_tasks = tasks.filter(state__in=[TaskUser.States.started,
                                         TaskUser.States.assigned,
                                         TaskUser.States.ignored])
    completed_tasks = tasks.filter(state=TaskUser.States.completed)
    ignored_tasks = tasks.filter(state=TaskUser.States.ignored)
    context['all_tasks'] = tasks
    context['open_tasks'] = open_tasks
    context['completed_tasks'] = completed_tasks
    context['ignored_tasks'] = ignored_tasks
    context['badges'] = Badge.objects.filter(user=request.user)
    context['new_signups'] = CustomUser.objects\
                             .order_by('-date_joined')[:5]
    context['first_time'] = request.user.login_count < 3
    constituencies = request.user.constituencies.all()
    context['activity'] = generate_activity(constituencies)
    
    return render_with_context(request, 'tasks/tasks.html', context)
Esempio n. 3
0
def manage_tasks(request):
    tasks = Task.objects.filter(archived=False)
    context= {}
    context['tasks'] = tasks
    return render_with_context(request,
                               'tasks/manage_tasks.html',
                               context) 
Esempio n. 4
0
def admin_assign_constituency(request):
    from forms import AssignConstituency
    from signup.models import CustomUser
    
    context = {}

    if request.method == "POST":
        form = AssignConstituency(request.POST, request.FILES)
        if form.is_valid():
            constituencies = form.cleaned_data['constituencies']
            all_users = CustomUser.objects.filter(
                is_active=True,
                constituencies__in=constituencies)
            
            context['message'] = []
            for task in form.cleaned_data['tasks']:
                (assigned, already_assigned) = TaskUser.objects.trigger_assign(task, all_users, constituencies)
                task_string = "%s in %s" % (task, constituencies)
                context['message'].append((task_string, assigned, already_assigned))
            
            context['form'] = form
        else:
            context['form'] = form
    else:
        context['form'] = AssignConstituency()
    
    return render_with_context(request, 'tasks/task_admin.html', context)
def constituencies_with_more_than_rss(request,
                                       volunteers=1):
    current_site = Site.objects.get_current()
    constituencies = models.filter_where_customuser_more_than(volunteers)
    context = {'constituencies': constituencies}
    context['site'] = current_site
    return render_with_context(request,
                              'geo.rss',
                              context,
                              mimetype="application/atom+xml")
Esempio n. 6
0
def manage_assign_email(request, task_pk):
    """
        Assign an email to be sent for particular users.
        Creates TaskEmailUser objects to represent assignment
    """
    context = {}
    matched_users = []
    count = 0
    skip = 0
    task = get_object_or_404(Task, pk=task_pk)
    dry_run = request.POST.get('dry_run', False)
    selected_email = request.POST.get('email', None)

    email = None
    if selected_email:
        email = TaskEmail.objects.get(pk=selected_email)
    
    if request.method == "POST":
        queryfilter = request.POST['queryfilter'].strip()      
        users = CustomUser.objects.all()
        
        if queryfilter:
            users = eval(queryfilter.strip())
        users = users.exclude(taskuser__task__pk=task_pk,
                              taskuser__state=TaskUser.States.ignored)
        users = users.filter(is_active=True, unsubscribed=False) # enforce
        for user in users:
            matched_users.append(user.email)
            taskusers = TaskUser.objects.filter(user=user,
                                                task=task)
            for task_user in taskusers:
                try:
                    task_email_user = TaskEmailUser.objects.get(task_email=email,
                                                                task_user=task_user)
                except TaskEmailUser.DoesNotExist:
                    if not dry_run:
                        task_email_user = TaskEmailUser.objects.create(task_email=email,
                                                                       task_user=task_user)        
                    count += 1
        
        context['posted'] = True
        context['matched_users'] = matched_users        
        context['queryfilter'] = queryfilter

    context['task'] = task
    context['emails'] = TaskEmail.objects.filter(task=task) \
                                         .order_by("-date_created")
    context['dry_run'] = dry_run
    context['count'] = count
    context['skip'] = skip
    context['selected_email'] = email
    return render_with_context(request,
                               'tasks/manage_assign_email.html',
                               context)
Esempio n. 7
0
def express_interest(request, constituency_slug=None):
    """ Report the addition of a leaflet """  
    context = {}
    interest = None
    if request.method == "POST":
        if request.POST.get('interest', False):
            interest = MeetingInterest.objects\
                       .create(user=request.user,
                               postcode=request.POST['postcode'])
            signals.interest_expressed.send(None, user=request.user)
        elif request.POST.get('organise', False):
            interest = MeetingInterest.objects\
                       .create(user=request.user,
                               organiser=True,
                               postcode=request.POST['postcode'])
            signals.interest_expressed.send(None, user=request.user)

        context['interest'] = interest
        return render_with_context(request, 'thanks.html', context)
    return render_with_context(request, 'express_interest.html', context)
def statistics(request):
    context = {}
    year = settings.CONSTITUENCY_YEAR
    context['histogram'] = models.date_joined_histogram()
    num_rows = context['histogram'].rowcount
    context['categorystep'] = int(num_rows / 40.0 * 4) + 1
    context['const_volunteers'] = \
      models.constituency_volunteers_histogram(Constituency.objects.filter(year=year))
    
    return render_with_context(request,
                               'statistics.html',
                               context)
Esempio n. 9
0
def index(request):
    vars = {}
    if request.method == "POST":
        invite_form = InviteForm(request.POST, request.FILES)
        if invite_form.is_valid():
            invite_form.save(request.user)
            context = {"notice": "Thanks for inviting more people to join!"}
            return HttpResponseRedirect(addToQueryString(reverse("tasks"), context))
        else:
            vars["invite_form"] = invite_form
    else:
        vars["invite_form"] = InviteForm()

    vars["siteurl"] = quote("http://%s" % Site.objects.get_current().domain)
    request.user.seen_invite = True
    request.user.save()
    return render_with_context(request, "invite/invite_page.html", vars)
Esempio n. 10
0
def manage_assign_tasks(request, task_pk):
    context = {}
    task = get_object_or_404(Task, pk=task_pk)
    context['task'] = task
    dry_run = False
    count = 0
    skip = 0
    matched_users = []
    email = None
    if request.method == "POST":
        dry_run = request.POST.get('dry_run', False)
        queryfilter = request.POST['queryfilter'].strip()
        users = CustomUser.objects.all()
        if queryfilter:
            users = eval(queryfilter.strip())
        users = users.filter(is_active=True, unsubscribed=False) # enforce
        for user in users:
            matched_users.append(user.email)

            if TaskUser.objects.filter(user=user,
                                       task__pk=task_pk): # Already assigned
                skip += 1
                continue
            else:
                if not dry_run:
                    # Trigger assignment
                    responses = user_touch.send(None,
                                                user=user,
                                                task_slug=task.slug)
                count += 1
        
        context['posted'] = True
        context['queryfilter'] = queryfilter
        context['matched_users'] = matched_users
    
    context['emails'] = TaskEmail.objects\
                        .distinct()\
                        .order_by("-date_created")
    context['dry_run'] = dry_run
    context['count'] = count
    context['skip'] = skip
    context['selected_email'] = email
    return render_with_context(request,
                               'tasks/manage_assign_tasks.html',
                               context)
Esempio n. 11
0
def index(request):
    vars = {}

    if request.method == "POST":
        invite_form = InviteForm(request.POST, request.FILES)
        if invite_form.is_valid():
            invite_form.save(request.user)

            return HttpResponseRedirect(addToQueryString(reverse("inviteindex"),
                {'notice': strings.INVITE_NOTICE_SUCCESS}))
        else:
            vars['invite_form'] = invite_form
    else:
        vars['invite_form'] = InviteForm()
        
    vars['siteurl'] = quote("http://%s" % Site.objects.get_current().domain)
    
    return render_with_context(request, "invite/invite_page.html", vars)
Esempio n. 12
0
def task(request, slug, constituency=None):
    """
        Check out a task. Needs to also optionally take a login token to allow
        direct access to the task by email.
    """
    context = {}
    context['task'] = Task.objects.get(slug=slug)

    if constituency is not None:
        year = settings.CONSTITUENCY_YEAR
        c = Constituency.objects.get(slug=constituency,
                                     year=year)
        context['constituency'] = Constituency.objects\
                                  .get(slug=constituency,
                                       year=year)
    else:
        context['constituency'] = None;
    if request.user.is_authenticated():
        items = TaskUser.objects
        
        if constituency is not None:
            try:
                context['usertasks'] = [items.get(task=context['task'],
                                                user=request.user,
                                                constituency=context['constituency'])]
            except TaskUser.DoesNotExist:
                pass
        else: # For the root task page, list all constituencies
            context['usertasks'] = items.filter(task=context['task'],
                                                user=request.user)
    else:
        context['usertasks'] = None

    started_tu = TaskUser.objects.filter(task=context['task'],\
                                         state=TaskUser.States.started)
    if constituency is not None:
        started_tu = started_tu.filter(constituency=context['constituency'])
    
    context['started_users'] = \
        CustomUser.objects.filter(taskuser__in=started_tu).distinct()
    
    return render_with_context(request, 'tasks/task_page.html', context)
Esempio n. 13
0
def admin_assign_all(request):
    from forms import AssignForm
    from signup.models import CustomUser
    
    context = {}

    if request.method == "POST":
        form = AssignForm(request.POST, request.FILES)
        if form.is_valid():
            all_users = CustomUser.objects.filter(
                is_active=True)
            context['message'] = []
            for task in form.cleaned_data['tasks']:
                (assigned, already_assigned) = TaskUser.objects.trigger_assign(task, all_users)
                context['message'].append((task, assigned, already_assigned))
                
            context['form'] = form
        else:
            context['form'] = form
    else:
        context['form'] = AssignForm()
    
    return render_with_context(request, 'tasks/task_admin.html', context)
Esempio n. 14
0
def scan_queue(request, dry_run=False):
    # Look at the email queue, determine if there are any emails which can be sent
    users = CustomUser.objects.filter(is_active=True,
                                      unsubscribed=False,
                                      taskuser__taskemailuser__isnull=False)
    context = {}
    sent = []
    for user in users:
        emails = TaskEmailUser.objects.filter(task_user__user=user).distinct()

        # Find out what the date was for the last sending
        last_sent = emails.exclude(date_sent=None).order_by('-date_added')
        date_last_sent = None
        if last_sent:
            date_last_sent = last_sent[0].date_sent
        
        # Only email once every two days
        if date_last_sent and date_last_sent > datetime.datetime.now() - datetime.timedelta(2):
            continue
        
        # Send unsent once-off messages with priority, then look for reminders
        # that are more than a week since they were last sent
        oldest_unsent = emails.filter(date_sent=None,
                                      task_email__email_type__in=[TaskEmail.EmailTypes.welcome,
                                                                  TaskEmail.EmailTypes.oneoff,],
                                     ).order_by('date_added')
        
        send_task_email_user = None
        if oldest_unsent:
            send_task_email_user = oldest_unsent[0]
        else:
            week_ago = datetime.datetime.now() - datetime.timedelta(7)

            # Find unsent reminders first
            reminders = emails.filter(date_sent=None,
                                      task_email__email_type=TaskEmail.EmailTypes.reminder
                                     ).order_by('date_sent')

            # If we cant find unsent reminders, find the oldest reminder sent more than a week ago
            if not reminders:
                reminders = emails.filter(date_sent__lte=week_ago,
                                          task_email__email_type=TaskEmail.EmailTypes.reminder
                                         ).order_by('date_sent')

            if reminders:
                send_task_email_user = reminders[0]

        if send_task_email_user:
            if not dry_run:
                try:
                    success = send_task_email_user.send()
                    if success:
                        sent.append(send_task_email_user)
                except RegistrationProfile.DoesNotExist:
                    pass
            else:
                sent.append(send_task_email_user)
    
    context['sent'] = sent
    context['dry_run'] = dry_run

    return render_with_context(request,
                               'tasks/emails_sent.html',
                               context)