from django import template

from symposion.reviews.models import Review, ReviewAssignment

register = template.Library()

@register.assignment_tag(takes_context=True)

def review_assignments(context):

    request = context["request"]

    assignments = ReviewAssignment.objects.filter(user=request.user)

    return assignments

from django.conf.urls.defaults import patterns, url

urlpatterns = patterns("symposion.reviews.views",

    url(r"^section/(?P<section_slug>[\w\-]+)/assignments/$", "review_section", {"assigned": True}, name="review_section_assignments"),

    url(r"^section/(?P<section_slug>[\w\-]+)/status/$", "review_status", name="review_status"),

    url(r"^section/(?P<section_slug>[\w\-]+)/status/(?P<key>\w+)/$", "review_status", name="review_status"),

    url(r"^section/(?P<section_slug>[\w\-]+)/list/(?P<user_pk>\d+)/$", "review_list", name="review_list_user"),

    url(r"^section/(?P<section_slug>[\w\-]+)/admin/$", "review_admin", name="review_admin"),

    url(r"^section/(?P<section_slug>[\w\-]+)/admin/accept/$", "review_bulk_accept", name="review_bulk_accept"),

    url(r"^section/(?P<section_slug>[\w\-]+)/notification/(?P<status>\w+)/$", "result_notification", name="result_notification"),

    url(r"^section/(?P<section_slug>[\w\-]+)/notification/(?P<status>\w+)/prepare/$", "result_notification_prepare", name="result_notification_prepare"),

    url(r"^section/(?P<section_slug>[\w\-]+)/notification/(?P<status>\w+)/send/$", "result_notification_send", name="result_notification_send"),

    url(r"^review/(?P<pk>\d+)/$", "review_detail", name="review_detail"),

    url(r"^(?P<pk>\d+)/delete/$", "review_delete", name="review_delete"),

    url(r"^assignments/$", "review_assignments", name="review_assignments"),

    url(r"^assignment/(?P<pk>\d+)/opt-out/$", "review_assignment_opt_out", name="review_assignment_opt_out"),

)

import re

from django.core.mail import send_mass_mail

from django.db.models import Q

from django.http import HttpResponseBadRequest, HttpResponseNotAllowed

from django.shortcuts import render, redirect, get_object_or_404

from django.template import Context, Template

from django.views.decorators.http import require_POST

from django.contrib.auth.decorators import login_required

from symposion.conf import settings

from symposion.proposals.models import ProposalBase, ProposalSection

from symposion.teams.models import Team

from symposion.utils.mail import send_email

from symposion.reviews.forms import ReviewForm, SpeakerCommentForm

from symposion.reviews.forms import BulkPresentationForm

from symposion.reviews.models import (

    ReviewAssignment, Review, LatestVote, ProposalResult, NotificationTemplate,

    ResultNotification

)

def access_not_permitted(request):

    return render(request, "reviews/access_not_permitted.html")

def proposals_generator(request, queryset, user_pk=None, check_speaker=True):

    for obj in queryset:

        # @@@ this sucks; we can do better

        if check_speaker:

            if request.user in [s.user for s in obj.speakers()]:

                continue

        try:

            obj.result

        except ProposalResult.DoesNotExist:

            ProposalResult.objects.get_or_create(proposal=obj)

        obj.comment_count = obj.result.comment_count

        obj.total_votes = obj.result.vote_count

        obj.plus_one = obj.result.plus_one

        obj.plus_zero = obj.result.plus_zero

        obj.minus_zero = obj.result.minus_zero

        obj.minus_one = obj.result.minus_one

        lookup_params = dict(proposal=obj)

        if user_pk:

            lookup_params["user__pk"] = user_pk

        else:

            lookup_params["user"] = request.user

        try:

            obj.user_vote = LatestVote.objects.get(**lookup_params).vote

            obj.user_vote_css = LatestVote.objects.get(**lookup_params).css_class()

        except LatestVote.DoesNotExist:

            obj.user_vote = None

            obj.user_vote_css = "no-vote"

        yield obj

@login_required

    if not request.user.has_perm("reviews.can_review_%s" % section_slug):

        return access_not_permitted(request)

    section = get_object_or_404(ProposalSection, section__slug=section_slug)

    queryset = ProposalBase.objects.filter(kind__section=section)

    if assigned:

        assignments = ReviewAssignment.objects.filter(user=request.user).values_list("proposal__id")

        queryset = queryset.filter(id__in=assignments)

    proposals = proposals_generator(request, queryset)

    ctx = {

        "proposals": proposals,

        "section": section,

    }

    return render(request, "reviews/review_list.html", ctx)

@login_required

def review_list(request, section_slug, user_pk):

    # if they're not a reviewer admin and they aren't the person whose

    # review list is being asked for, don't let them in

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        if not request.user.pk == user_pk:

            return access_not_permitted(request)

    queryset = ProposalBase.objects.select_related("speaker__user", "result")

    reviewed = LatestVote.objects.filter(user__pk=user_pk).values_list("proposal", flat=True)

    queryset = queryset.filter(pk__in=reviewed)

    proposals = queryset.order_by("submitted")

    admin = request.user.has_perm("reviews.can_manage_%s" % section_slug)

    proposals = proposals_generator(request, proposals, user_pk=user_pk, check_speaker=not admin)

    ctx = {

        "proposals": proposals,

    }

    return render(request, "reviews/review_list.html", ctx)

@login_required

def review_admin(request, section_slug):

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    def reviewers():

        already_seen = set()

        for team in Team.objects.filter(permissions__codename="can_review_%s" % section_slug):

            for membership in team.memberships.filter(Q(state="member") | Q(state="manager")):

                user = membership.user

                if user.pk in already_seen:

                    continue

                already_seen.add(user.pk)

                user.comment_count = Review.objects.filter(user=user).count()

                user.total_votes = LatestVote.objects.filter(user=user).count()

                user.plus_one = LatestVote.objects.filter(

                    user = user,

                    vote = LatestVote.VOTES.PLUS_ONE

                ).count()

                user.plus_zero = LatestVote.objects.filter(

                    user = user,

                    vote = LatestVote.VOTES.PLUS_ZERO

                ).count()

                user.minus_zero = LatestVote.objects.filter(

                    user = user,

                    vote = LatestVote.VOTES.MINUS_ZERO

                ).count()

                user.minus_one = LatestVote.objects.filter(

                    user = user,

                    vote = LatestVote.VOTES.MINUS_ONE

                ).count()

                yield user

    ctx = {

        "section_slug": section_slug,

        "reviewers": reviewers(),

    }

    return render(request, "reviews/review_admin.html", ctx)

@login_required

def review_detail(request, pk):

    proposals = ProposalBase.objects.select_related("result").select_subclasses()

    proposal = get_object_or_404(proposals, pk=pk)

    if not request.user.has_perm("reviews.can_review_%s" % proposal.kind.section.slug):

        return access_not_permitted(request)

    speakers = [s.user for s in proposal.speakers()]

    if not request.user.is_superuser and request.user in speakers:

        return access_not_permitted(request)

    admin = request.user.is_staff

    try:

        latest_vote = LatestVote.objects.get(proposal=proposal, user=request.user)

    except LatestVote.DoesNotExist:

        latest_vote = None

    if request.method == "POST":

        if request.user in speakers:

            return access_not_permitted(request)

        if "vote_submit" in request.POST:

            review_form = ReviewForm(request.POST)

            if review_form.is_valid():

                review = review_form.save(commit=False)

                review.user = request.user

                review.proposal = proposal

                review.save()

                return redirect(request.path)

            else:

                message_form = SpeakerCommentForm()

        elif "message_submit" in request.POST:

            message_form = SpeakerCommentForm(request.POST)

            if message_form.is_valid():

                message = message_form.save(commit=False)

                message.user = request.user

                message.proposal = proposal

                message.save()

                for speaker in speakers:

                    if speaker and speaker.email:

                        ctx = {

                            "proposal": proposal,

                            "message": message,

                            "reviewer": False,

                        }

                        send_email(

                            [speaker.email], "proposal_new_message",

                            context = ctx

                        )

                return redirect(request.path)

            else:

                initial = {}

                if latest_vote:

                    initial["vote"] = latest_vote.vote

                if request.user in speakers:

                    review_form = None

                else:

                    review_form = ReviewForm(initial=initial)

        elif "result_submit" in request.POST:

            if admin:

                result = request.POST["result_submit"]

                if result == "accept":

                    proposal.result.status = "accepted"

                    proposal.result.save()

                elif result == "reject":

                    proposal.result.status = "rejected"

                    proposal.result.save()

                elif result == "undecide":

                    proposal.result.status = "undecided"

                    proposal.result.save()

                elif result == "standby":

                    proposal.result.status = "standby"

                    proposal.result.save()

            return redirect(request.path)

    else:

        initial = {}

        if latest_vote:

            initial["vote"] = latest_vote.vote

        if request.user in speakers:

            review_form = None

        else:

            review_form = ReviewForm(initial=initial)

        message_form = SpeakerCommentForm()

    proposal.comment_count = proposal.result.comment_count

    proposal.total_votes = proposal.result.vote_count

    proposal.plus_one = proposal.result.plus_one

    proposal.plus_zero = proposal.result.plus_zero

    proposal.minus_zero = proposal.result.minus_zero

    proposal.minus_one = proposal.result.minus_one

    reviews = Review.objects.filter(proposal=proposal).order_by("-submitted_at")

    messages = proposal.messages.order_by("submitted_at")

    return render(request, "reviews/review_detail.html", {

        "proposal": proposal,

        "latest_vote": latest_vote,

        "reviews": reviews,

        "review_messages": messages,

        "review_form": review_form,

        "message_form": message_form

    })

@login_required

@require_POST

def review_delete(request, pk):

    review = get_object_or_404(Review, pk=pk)

    section_slug = review.section.slug

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    review = get_object_or_404(Review, pk=pk)

    review.delete()

    return redirect("review_detail", pk=review.proposal.pk)

@login_required

def review_status(request, section_slug=None, key=None):

    if not request.user.has_perm("reviews.can_review_%s" % section_slug):

        return access_not_permitted(request)

    VOTE_THRESHOLD = settings.SYMPOSION_VOTE_THRESHOLD

    ctx = {

        "section_slug": section_slug,

        "vote_threshold": VOTE_THRESHOLD,

    }

    queryset = ProposalBase.objects.select_related("speaker__user", "result").select_subclasses()

    if section_slug:

        queryset = queryset.filter(kind__section__slug=section_slug)

    proposals = {

        # proposals with at least VOTE_THRESHOLD reviews and at least one +1 and no -1s, sorted by the 'score'

        "positive": queryset.filter(result__vote_count__gte=VOTE_THRESHOLD, result__plus_one__gt=0, result__minus_one=0).order_by("-result__score"),

        # proposals with at least VOTE_THRESHOLD reviews and at least one -1 and no +1s, reverse sorted by the 'score'

        "negative": queryset.filter(result__vote_count__gte=VOTE_THRESHOLD, result__minus_one__gt=0, result__plus_one=0).order_by("result__score"),

        # proposals with at least VOTE_THRESHOLD reviews and neither a +1 or a -1, sorted by total votes (lowest first)

        "indifferent": queryset.filter(result__vote_count__gte=VOTE_THRESHOLD, result__minus_one=0, result__plus_one=0).order_by("result__vote_count"),

        # proposals with at least VOTE_THRESHOLD reviews and both a +1 and -1, sorted by total votes (highest first)

        "controversial": queryset.filter(result__vote_count__gte=VOTE_THRESHOLD, result__plus_one__gt=0, result__minus_one__gt=0).order_by("-result__vote_count"),

        # proposals with fewer than VOTE_THRESHOLD reviews

        "too_few": queryset.filter(result__vote_count__lt=VOTE_THRESHOLD).order_by("result__vote_count"),

    }

    admin = request.user.has_perm("reviews.can_manage_%s" % section_slug)

    for status in proposals:

        if key and key != status:

            continue

        proposals[status] = list(proposals_generator(request, proposals[status], check_speaker=not admin))

    if key:

        ctx.update({

            "key": key,

            "proposals": proposals[key],

        })

    else:

        ctx["proposals"] = proposals

    return render(request, "reviews/review_stats.html", ctx)

@login_required

def review_assignments(request):

    if not request.user.groups.filter(name="reviewers").exists():

        return access_not_permitted(request)

    assignments = ReviewAssignment.objects.filter(

        user=request.user,

        opted_out=False

    )

    return render(request, "reviews/review_assignment.html", {

        "assignments": assignments,

    })

@login_required

@require_POST

def review_assignment_opt_out(request, pk):

    review_assignment = get_object_or_404(ReviewAssignment,

        pk=pk,

        user=request.user

    )

    if not review_assignment.opted_out:

        review_assignment.opted_out = True

        review_assignment.save()

        ReviewAssignment.create_assignments(review_assignment.proposal, origin=ReviewAssignment.AUTO_ASSIGNED_LATER)

    return redirect("review_assignments")

@login_required

def review_bulk_accept(request, section_slug):

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    if request.method == "POST":

        form = BulkPresentationForm(request.POST)

        if form.is_valid():

            talk_ids = form.cleaned_data["talk_ids"].split(",")

            talks = ProposalBase.objects.filter(id__in=talk_ids).select_related("result")

            for talk in talks:

                talk.result.status = "accepted"

                talk.result.save()

            return redirect("review_section", section_slug=section_slug)

    else:

        form = BulkPresentationForm()

    return render(request, "reviews/review_bulk_accept.html", {

        "form": form,

    })

@login_required

def result_notification(request, section_slug, status):

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    proposals = ProposalBase.objects.filter(kind__section__slug=section_slug, result__status=status).select_related("speaker__user", "result").select_subclasses()

    notification_templates = NotificationTemplate.objects.all()

    ctx = {

        "section_slug": section_slug,

        "status": status,

        "proposals": proposals,

        "notification_templates": notification_templates,

    }

    return render(request, "reviews/result_notification.html", ctx)

@login_required

def result_notification_prepare(request, section_slug, status):

    if request.method != "POST":

        return HttpResponseNotAllowed(["POST"])

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    proposal_pks = []

    try:

        for pk in request.POST.getlist("_selected_action"):

            proposal_pks.append(int(pk))

    except ValueError:

        return HttpResponseBadRequest()

    proposals = ProposalBase.objects.filter(

        kind__section__slug=section_slug,

        result__status=status,

    )

    proposals = proposals.filter(pk__in=proposal_pks)

    proposals = proposals.select_related("speaker__user", "result")

    proposals = proposals.select_subclasses()

    notification_template_pk = request.POST.get("notification_template", "")

    if notification_template_pk:

        notification_template = NotificationTemplate.objects.get(pk=notification_template_pk)

    else:

        notification_template = None

    ctx = {

        "section_slug": section_slug,

        "status": status,

        "notification_template": notification_template,

        "proposals": proposals,

        "proposal_pks": ",".join([str(pk) for pk in proposal_pks]),

    }

    return render(request, "reviews/result_notification_prepare.html", ctx)

@login_required

def result_notification_send(request, section_slug, status):

    if request.method != "POST":

        return HttpResponseNotAllowed(["POST"])

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    if not all([k in request.POST for k in ["proposal_pks", "from_address", "subject", "body"]]):

        return HttpResponseBadRequest()

    try:

        proposal_pks = [int(pk) for pk in request.POST["proposal_pks"].split(",")]

    except ValueError:

        return HttpResponseBadRequest()

    proposals = ProposalBase.objects.filter(

        kind__section__slug=section_slug,

        result__status=status,

    )

    proposals = proposals.filter(pk__in=proposal_pks)

    proposals = proposals.select_related("speaker__user", "result")

    proposals = proposals.select_subclasses()

    notification_template_pk = request.POST.get("notification_template", "")

    if notification_template_pk:

        notification_template = NotificationTemplate.objects.get(pk=notification_template_pk)

    else:

        notification_template = None

    emails = []

    for proposal in proposals:

        rn = ResultNotification()

        rn.proposal = proposal

        rn.template = notification_template

        rn.to_address = proposal.speaker_email

        rn.from_address = request.POST["from_address"]

        rn.subject = request.POST["subject"]

        rn.body = Template(request.POST["body"]).render(

            Context({

                "proposal": proposal.notification_email_context()

            })

        )

        rn.save()

        emails.append(rn.email_args)

    send_mass_mail(emails)

    return redirect("result_notification", section_slug=section_slug, status=status)

import datetime

from django.db import models

from django.core.urlresolvers import reverse

from django.contrib.auth.models import User

from markitup.fields import MarkupField

class Speaker(models.Model):

    SESSION_COUNT_CHOICES = [

        (1, "One"),

        (2, "Two")

    ]

    user = models.OneToOneField(User, null=True, related_name="speaker_profile")

    name = models.CharField(max_length=100, help_text="As you would like it to appear in the conference program.")

    biography = MarkupField(blank=True, help_text="A little bit about you. Edit using <a href='http://warpedvisions.org/projects/markdown-cheat-sheet/' target='_blank'>Markdown</a>.")

    photo = models.ImageField(upload_to="speaker_photos", blank=True)

    annotation = models.TextField()  # staff only

    invite_email = models.CharField(max_length=200, unique=True, null=True, db_index=True)

    invite_token = models.CharField(max_length=40, db_index=True)

    created = models.DateTimeField(

        default = datetime.datetime.now,

        editable = False

    )

    def __unicode__(self):

        if self.user:

            return self.name

        else:

            return "?"

    def get_absolute_url(self):

        return reverse("speaker_edit")

    @property

    def email(self):

        if self.user is not None:

            return self.user.email

        else:

            return self.invite_email

    @property

    def all_presentations(self):

        presentations = []

        if self.presentations:

            for p in self.presentations.all():

                presentations.append(p)

            for p in self.copresentations.all():

                presentations.append(p)

        return presentations

from django.http import Http404

from django.shortcuts import render_to_response, redirect, get_object_or_404

from django.template import RequestContext

from django.contrib import messages

from django.contrib.auth.decorators import login_required

from symposion.sponsorship.forms import SponsorApplicationForm, SponsorDetailsForm, SponsorBenefitsFormSet

from symposion.sponsorship.models import Sponsor, SponsorBenefit

@login_required

def sponsor_apply(request):

    if request.method == "POST":

        form = SponsorApplicationForm(request.POST, user=request.user)

        if form.is_valid():

            sponsor = form.save()

            return redirect("sponsor_detail", pk=sponsor.pk)

    else:

        form = SponsorApplicationForm(user=request.user)

    return render_to_response("sponsorship/apply.html", {

        "form": form,

    }, context_instance=RequestContext(request))

@login_required

def sponsor_add(request):

    if not request.user.is_staff:

        raise Http404()

    if request.method == "POST":

        form = SponsorApplicationForm(request.POST, user=request.user)

        if form.is_valid():

            sponsor = form.save(commit=False)

            sponsor.active = True

            sponsor.save()

    else:

        form = SponsorApplicationForm(user=request.user)

    return render_to_response("sponsorship/add.html", {

        "form": form,

    }, context_instance=RequestContext(request))

@login_required

def sponsor_detail(request, pk):

    sponsor = get_object_or_404(Sponsor, pk=pk)

    if sponsor.applicant != request.user:

        return redirect("sponsor_list")

    formset_kwargs = {

        "instance": sponsor,

        "queryset": SponsorBenefit.objects.filter(active=True)

    }

    if request.method == "POST":

        form = SponsorDetailsForm(request.POST, instance=sponsor)

        formset = SponsorBenefitsFormSet(request.POST, request.FILES, **formset_kwargs)

        if form.is_valid() and formset.is_valid():

            form.save()

            formset.save()

            messages.success(request, "Sponsorship details have been updated")

            return redirect("dashboard")

    else:

        form = SponsorDetailsForm(instance=sponsor)

        formset = SponsorBenefitsFormSet(**formset_kwargs)

    return render_to_response("sponsorship/detail.html", {

        "sponsor": sponsor,

        "form": form,

        "formset": formset,

    }, context_instance=RequestContext(request))

{% extends "site_base.html" %}

{% load i18n %}

{% load proposal_tags %}

{% load review_tags %}

{% load teams_tags %}

{% block head_title %}Dashboard{% endblock %}

{% block body_class %}auth{% endblock %}

{% block body %}

    <div class="dashboard-panel">

        <div class="dashboard-panel-header">

            <i class="icon-bullhorn"></i>

            <h3>{% trans "Speaking" %}</h3>

            <div class="pull-right header-actions">

                {% if not user.speaker_profile %}

                    <a href="{% url speaker_create %}" class="btn">

                        <i class="icon-plus-sign"></i> Create a speaker profile

                    </a>

                {% else %}

                    <a href="{% url speaker_edit %}" class="btn">

                        <i class="icon-pencil"></i> Edit your speaker profile

                    </a>

                    <a href="{% url proposal_submit %}" class="btn">

                        <i class="icon-plus-sign"></i> Submit a new proposal

                    </a>

                {% endif %}

            </div>

        </div>

        <div class="dashboard-panel-content">

            {% if not user.speaker_profile %}

                <p>To submit a proposal, you must first <a href="{% url speaker_create %}">create a speaker profile</a>.</p>

            {% else %}

                <h4>Your Proposals</h4>

                {% if user.speaker_profile.proposals.exists %}

                    <table class="table">

                        <tr>

                            <th>Title</th>

                            <th>Session type</th>

                            <th>Status</th>

                            <th>Actions</th>

                        </tr>

                        {% for proposal in user.speaker_profile.proposals.all %}

                            {% include "proposals/_proposal_row.html" %}

                        {% endfor %}

                    </table>

                {% else %}

                    <p>No proposals submitted yet.</p>

                {% endif %}

                {% associated_proposals as associated_proposals %}

                {% if associated_proposals %}

                    <h4>Proposals you have joined as an additional speaker</h4>

                    <table class="table">

                        <tr>

                            <th>Title</th>

                            <th>Session type</th>

                            <th>Status</th>

                            <th>Actions</th>

                        </tr>

                        {% for proposal in associated_proposals %}

                            {% include "proposals/_proposal_row.html" %}

                        {% endfor %}

                    </table>

                {% endif %}

                {% pending_proposals as pending_proposals %}

                {% if pending_proposals %}

                    <h4>Proposals you have been invited to join</h4>

                    <table class="table">

                        <tr>

                            <th>Title</th>

                            <th>Session type</th>

                            <th>Status</th>

                            <th>Actions</th>

                        </tr>

                        {% for proposal in pending_proposals %}

                            {% include "proposals/_pending_proposal_row.html" %}

                        {% endfor %}

                    </table>

                {% endif %}

            {% endif %}

        </div>

    </div>

    <div class="dashboard-panel">

        <div class="dashboard-panel-header">

            <i class="icon-briefcase"></i>

            <h3>{% trans "Sponsorship" %}</h3>

            <div class="pull-right header-actions">

                {% if not user.sponsorships.exists %}

                    <a href="{% url sponsor_apply %}" class="btn">

                        <i class="icon-plus-sign"></i> Apply to be a sponsor

                    </a>

                {% endif %}

            </div>

        </div>

        <div class="dashboard-panel-content">

            {% if not user.sponsorships.exists %}

                <p>If you or your organization would be interested in sponsorship opportunities, <a href="{% url sponsor_apply %}">use our online form to apply to be a sponsor</a>.

            {% else %}

                <h4>Your Sponsorship</h4>

                <ul>

                    {% for sponsorship in user.sponsorships.all %}

                        <li>

                            <a href="{% url sponsor_detail sponsorship.pk %}"><b>{{ sponsorship.name }}</b></a>

                            ({{ sponsorship.level }})

                            {% if not sponsorship.active %}

                                <span class="label label-warning">awaiting approval</span>

                            {% endif %}

                        </li>

                    {% endfor %}

                </ul>

            {% endif %}

            {% if user.is_staff %}

                <p>

                    As staff, you can directly <a href="{% url sponsor_add %}">add a sponsor</a> if the organization isn't

                    applying themselves.

                </p>

            {% endif %}

        </div>

    </div>

    {% if review_sections %}

        <div class="dashboard-panel">

            <div class="dashboard-panel-header">

                <i class="icon-briefcase"></i>

                <h3>{% trans "Reviews" %}</h3>

            </div>

            <div class="dashboard-panel-content">

                <ul>

                    {% for section in review_sections %}

                    {% endfor %}

                </ul>