def reset_password(request, pResetKey):
"""
Perform the password reset
"""
try:
lPasswordReset = PasswordReset.objects.filter(key=pResetKey)[0]
except:
raise Http404()
try:
lUserToReset = User.objects.filter(
username__iexact=lPasswordReset.username)[0]
except:
# try looking by email address
try:
lUserToReset = User.objects.filter(
email__iexact=lPasswordReset.username).order_by(
'-last_login')[0]
except:
# don't send email if account not found
raise Http404()
if request.method == "POST":
lForm = ResetPasswordForm(request.POST)
if lForm.is_valid():
lUserToReset.set_password(lForm.cleaned_data['password'])
lUserToReset.save()
lPasswordReset.used = datetime.now()
lPasswordReset.save()
notification(lPasswordReset,
lUserToReset,
'users',
'password',
'changed',
request.user,
browser_details(request),
pDestination=lUserToReset.email)
return render_auth(
request, "users/resetpassword/password_reset_done.html", {
'User': lUserToReset,
'PasswordReset': lPasswordReset,
'form': lForm
})
else:
lForm = ResetPasswordForm()
return render_auth(request, "users/resetpassword/password_reset_form.html",
{
'User': lUserToReset,
'PasswordReset': lPasswordReset,
'form': lForm
})
def bands_compare_contest(request, pBandOneSlug, pBandTwoSlug, pContestSlug):
"""
Compare two bands, optionally limited to specific contest
"""
if pBandOneSlug == pBandTwoSlug:
return render_auth(request,
"compare/bands/cant_compare_with_self.html")
try:
lBandOne = Band.objects.filter(slug=pBandOneSlug)[0]
lBandTwo = Band.objects.filter(slug=pBandTwoSlug)[0]
except IndexError:
raise Http404()
lCompareResults, lBandOneWins, lBandTwoWins = _compare_band_results(
lBandOne, lBandTwo, pContestSlug)
try:
lBandOnePercent = (lBandOneWins * 100) / (lBandOneWins + lBandTwoWins)
lBandTwoPercent = (lBandTwoWins * 100) / (lBandOneWins + lBandTwoWins)
except:
lBandOnePercent = 0
lBandTwoPercent = 0
lDidYouMean = None
if len(lCompareResults) == 0:
lDidYouMean = _did_you_mean_bands(lBandOne, lBandTwo)
lContestName = None
if pContestSlug:
try:
lContest = Contest.objects.filter(slug=pContestSlug)[0]
lContestName = lContest.name
except:
raise Http404
return render_auth(
request, "compare/bands/compare_result.html", {
"BandOne": lBandOne,
"BandTwo": lBandTwo,
"CompareResults": lCompareResults,
"BandOneWins": lBandOneWins,
"BandTwoWins": lBandTwoWins,
"BandOnePercent": lBandOnePercent,
"BandTwoPercent": lBandTwoPercent,
"DidYouMean": lDidYouMean,
"ContestSlug": pContestSlug,
"ContestName": lContestName,
"Filter": pContestSlug != None
})
def single_band_aliases(request, pBandSlug):
"""
Show and edit aliases for a given band
"""
try:
lBand = Band.objects.filter(slug=pBandSlug)[0]
except IndexError:
raise Http404()
lSuperuser = request.user.profile.superuser
lEnhancedUserAndOwner = request.user.profile.enhanced_functionality and lBand.owner == request.user
if not (lSuperuser or lProfileOwner or lEnhancedUserAndOwner):
raise Http404()
if request.POST:
lNewAlias = request.POST['new_alias_name']
lBandAlias = PreviousBandName()
lBandAlias.band = lBand
lBandAlias.old_name = lNewAlias
lBandAlias.owner = request.user
lBandAlias.lastChangedBy = request.user
lBandAlias.save()
notification(None, lBandAlias, 'bands', 'band_alias', 'new',
request.user, browser_details(request))
return HttpResponseRedirect('/bands/%s/aliases/' % lBand.slug)
lBandAliases = PreviousBandName.objects.filter(band=lBand)
return render_auth(request, "bands/band_aliases.html", {
'Band': lBand,
'Aliases': lBandAliases,
})
def year_list(request):
"""
Show a list of years that have contests
"""
cursor = connection.cursor()
lYearObjects = []
lThisYear = datetime.today().year
cursor.execute(
"SELECT extract(year from e.date_of_event), count(distinct(r.band_id)), count(distinct(e.id)) FROM contests_contestevent e, contests_contestresult r WHERE r.contest_event_id = e.id GROUP BY extract(year from e.date_of_event) ORDER BY extract(year from e.date_of_event) desc "
)
rows = cursor.fetchall()
for row in rows:
lYearObject = YearObject()
lYearObject.year = int(row[0])
if lYearObject.year > lThisYear:
continue
lYearObject.competing_bands_count = row[1]
lYearObject.contest_count = row[2]
lYearObjects.append(lYearObject)
cursor.close()
lAllRegions = Region.objects.filter(container__isnull=True)
lAllUkRegions = Region.objects.filter(container__isnull=False)
return render_auth(
request, 'years/years.html', {
"Years": lYearObjects,
"AllCountryRegions": lAllRegions,
"AllUkRegions": lAllUkRegions,
})
def people_hash_by_letter(request):
"""
Return the people list hashes, one for the first letter by surname
"""
lPeople = Person.objects.all().order_by('surname');
lPeopleStructure = {}
for person in lPeople:
if person.surname:
lFirstLetter = person.surname[0].upper()
if lFirstLetter:
try:
lList = lPeopleStructure[lFirstLetter]
except KeyError:
lList = u""
lList += u"!" + smart_text(person.first_names) + u"," + smart_text(person.surname);
lPeopleStructure[lFirstLetter] = lList
lHashes = {}
for letter in lPeopleStructure.keys():
lPeople = lPeopleStructure[letter]
lHash = hashlib.sha256(lPeople.encode('utf-8')).hexdigest()
lHashes[letter] = lHash
return render_auth(request, 'people/hashes.json', {
'Hashes' : lHashes,
})
def edit_person(request, pPersonSlug):
"""
Edit a person
"""
try:
lPerson = Person.objects.filter(slug=pPersonSlug)[0]
except IndexError:
raise Http404()
lFormType = EditPersonForm
if request.user.profile.superuser:
lFormType = EditPersonAsSuperuserForm
if request.user.profile.superuser == False:
if request.user.id != lPerson.owner.id:
raise Http404()
if request.user.profile.enhanced_functionality == False:
raise Http404()
if request.method == 'POST':
form = lFormType(request.POST, instance=lPerson)
if form.is_valid():
lOriginalPerson = Person.objects.filter(id=lPerson.id)[0]
lNewPerson = form.save(commit=False)
lNewPerson.lastChangedBy = request.user
lNewPerson.save()
notification(lOriginalPerson, lNewPerson, 'people', 'person', 'edit', request.user, browser_details(request))
return HttpResponseRedirect('/people/%s/' % lPerson.slug)
else:
form = lFormType(instance=lPerson)
return render_auth(request, 'people/edit_person.html', {'form': form, "Person" : lPerson})
def messages(request, pUsername):
"""
Show messages
"""
try:
lUser = User.objects.filter(username=pUsername)[0]
except IndexError:
raise Http404
lProfile = lUser.profile
if pUsername != lUser.username:
raise Http404
lOutstandingFeedbackCount, lSentFeedbackCount, lContestsCount, lContestHistoryCount, lMessageCount, lUserBadges = _get_tab_counts(
request, lUser)
lMessages = Message.objects.filter(to_user=request.user).filter(
deleted=False)
return render_auth(
request, 'users/profile/messages.html', {
'User': lUser,
'Profile': lProfile,
"ContestCount": lContestsCount,
'FeedbackCount': lOutstandingFeedbackCount,
'SentFeedbackCount': lSentFeedbackCount,
'PerformanceCount': lContestHistoryCount,
"MessageCount": lMessageCount,
"Messages": lMessages,
"UserBadges": lUserBadges,
})
def _show_owner_profile(request, pUser):
"""
Show user's private profile
"""
lProfile = pUser.profile
# default contest history visibility to private
if lProfile.contest_history_visibility == None:
lProfile.contest_history_visibility = 'private'
lProfile.save()
# Get feedback list to show
lOutstandingFeedback = SiteFeedback.objects.filter(
owner__id=request.user.id,
status="Outstanding").select_related().order_by('-created')
lOutstandingFeedbackCount, lSentFeedbackCount, lContestsCount, lContestHistoryCount, lMessageCount, lUserBadges = _get_tab_counts(
request, pUser)
return render_auth(
request, 'users/profile/user.html', {
'User': pUser,
'Profile': lProfile,
'Feedback': lOutstandingFeedback,
'FeedbackCount': lOutstandingFeedbackCount,
'SentFeedbackCount': lSentFeedbackCount,
'ContestCount': lContestsCount,
'PerformanceCount': lContestHistoryCount,
"MessageCount": lMessageCount,
"UserBadges": lUserBadges,
})
def move_specific_band(request, pBandSlug):
"""
Move a band already on the map
"""
try:
lBand = Band.objects.filter(slug=pBandSlug)[0]
except IndexError:
raise Http404()
lForm = EditLocationForm(instance=lBand)
if request.POST:
lForm = EditLocationForm(request.POST, instance=lBand)
if lForm.is_valid():
lOldBand = Band.objects.filter(id=lBand.id)[0]
lNewBand = lForm.save(commit=False)
lNewBand.lastChangedBy = request.user
lNewBand.mapper = request.user
lNewBand.save()
notification(lOldBand, lNewBand, 'bands', 'band_map', 'move',
request.user, browser_details(request))
return HttpResponseRedirect('/map/coordwrong/%s/saved/' %
lBand.slug)
return render_auth(request, 'map/movespecificband.html', {
"Band": lBand,
"form": lForm
})
def single_venue_aliases(request, pVenueSlug):
"""
Show and edit aliases for a given venue
"""
try:
lVenue = Venue.objects.filter(slug=pVenueSlug)[0]
except IndexError:
raise Http404()
lSuperuser = request.user.profile.superuser
if not (lSuperuser):
raise Http404()
if request.POST:
lNewAlias = request.POST['new_alias_name']
lVenueAlias = VenueAlias()
lVenueAlias.venue = lVenue
lVenueAlias.name = lNewAlias
lVenueAlias.owner = request.user
lVenueAlias.lastChangedBy = request.user
lVenueAlias.save()
notification(None, lVenueAlias, 'venues', 'venue_alias', 'new',
request.user, browser_details(request))
return HttpResponseRedirect('/venues/%s/aliases/' % lVenue.slug)
lVenueAliases = VenueAlias.objects.filter(venue=lVenue)
return render_auth(request, "venues/venue_aliases.html", {
'Venue': lVenue,
'Aliases': lVenueAliases,
})
def edit_venue(request, pVenueSlug):
"""
Edit a venue
"""
try:
lVenue = Venue.objects.filter(slug=pVenueSlug)[0]
except IndexError:
raise Http404()
lSuperuser = request.user.profile.superuser or request.user.profile.regional_superuser
lOwner = request.user.profile.enhanced_functionality and request.user == lVenue.owner
lEditAllowed = lSuperuser or lOwner
if not lEditAllowed:
raise Http404
lFormClass = EditVenueForm
if request.method == 'POST':
form = lFormClass(request.POST, instance=lVenue)
if form.is_valid():
lOldVenue = Venue.objects.filter(id=lVenue.id)[0]
lNewVenue = form.save(commit=False)
lNewVenue.lastChangedBy = request.user
lNewVenue.save()
notification(lOldVenue, lNewVenue, 'venues', 'venue', 'edit',
request.user, browser_details(request))
return HttpResponseRedirect('/venues/%s/' % lVenue.slug)
else:
form = lFormClass(instance=lVenue)
return render_auth(request, 'venues/edit_venue.html', {
'form': form,
"Venue": lVenue
})
def venue_list(request):
"""
Show a list of a venues
"""
lVenues = Venue.objects.all()
lRegions = Region.objects.all()
lRegionList = {}
for region in lRegions:
lRegionList[region.id] = region
# work out events on site for each venue
cursor = connection.cursor()
lResults = {}
cursor.execute(
"select venue_link_id, count(*) from contests_contestevent group by venue_link_id"
)
rows = cursor.fetchall()
for row in rows:
lResults[row[0]] = row[1]
cursor.close()
for venue in lVenues:
try:
venue.eventcount = lResults[venue.id]
except KeyError:
venue.eventcount = 0
try:
venue.country = lRegionList[venue.country_id]
except KeyError:
venue.country = None
return render_auth(request, 'venues/venue_list.html', {"Venues": lVenues})
def single_venue_event(request, pVenueSlug, pContestSlug):
"""
Show details of which of a particular event have been run at a particular venue
"""
try:
lVenue = Venue.objects.filter(slug=pVenueSlug).select_related()[0]
lContest = Contest.objects.filter(slug=pContestSlug)[0]
except IndexError:
raise Http404()
# get events
cursor = connection.cursor()
lEvents = []
lEventIds = ""
cursor.execute(
"select event.date_of_event, event.name, contest.slug, contest.name, event.id, contest.id, event.date_resolution from contests_contest contest, contests_contestevent event where contest.slug = '%s' and event.contest_id = contest.id and event.venue_link_id = %d order by event.date_of_event desc"
% (pContestSlug, lVenue.id))
rows = cursor.fetchall()
if len(rows) == 0:
raise Http404()
for row in rows:
lEvent = ContestEvent()
lEvent.date_of_event = row[0]
lEvent.name = row[1]
lContestSlug = row[2]
lContestName = row[3]
lEvent.id = row[4]
lContestId = row[5]
lEvent.date_resolution = row[6]
if len(lEventIds) > 0:
lEventIds += ','
lEventIds += str(lEvent.id)
lEvents.append(lEvent)
cursor.close()
# get winners
cursor = connection.cursor()
lWinners = {}
cursor.execute(
"select result.contest_event_id, result.band_name, result.band_id, band.slug, band.name from contests_contestresult result, bands_band band where result.band_id = band.id and result.results_position = 1 and result.contest_event_id in (%s)"
% lEventIds)
rows = cursor.fetchall()
for row in rows:
lWinners[row[0]] = (row[1], row[2], row[3], row[4])
cursor.close()
for lEvent in lEvents:
if lEvent.id in lWinners.keys():
lEvent.band_name = lWinners[lEvent.id][0]
lBand = Band()
lBand.id = lWinners[lEvent.id][1]
lBand.slug = lWinners[lEvent.id][2]
lBand.name = lWinners[lEvent.id][3]
lEvent.winners = lBand
return render_auth(request, 'venues/event.html', {
"Venue": lVenue,
"Contest": lContest,
"Events": lEvents,
})
def create_with_subject(request, pUserCode, pSubject):
"""
Create a new message with a subject
"""
lToUser = User.objects.filter(username=pUserCode)[0]
if request.method == 'POST':
lForm = UserMessageForm(request.POST)
if lForm.is_valid():
lMessage = Message()
lMessage.from_user = User.objects.filter(
username=request.user.username)[0]
lMessage.to_user = lToUser
lMessage.title = lForm.cleaned_data['title']
lMessage.text = lForm.cleaned_data['text']
lMessage.save()
notification(None,
lMessage,
'messages',
'message',
'new',
request.user,
browser_details(request),
pDestination=lMessage.to_user.email)
return HttpResponseRedirect('/users/%s/' % lToUser.username)
else:
lForm = UserMessageForm(initial={
'title': pSubject,
})
return render_auth(request, 'messages/create.html', {
"MessageForm": lForm,
"To": pUserCode
})
def talk(request, pSlug):
"""
Show the talk page for a particular band
"""
if request.user.profile.superuser == False:
raise Http404
try:
lObjectLink = Band.objects.filter(slug=pSlug)[0]
except IndexError:
raise Http404
try:
lTalk = BandTalkPage.objects.filter(object_link=lObjectLink)[0]
except IndexError:
lTalk = None
lRecentTalkChanges = fetch_recent_talk_changes(request)
return render_auth(
request, 'talk/talk.html', {
'Talk': lTalk,
'ObjectLink': lObjectLink,
'Offset': 'bands',
'RecentTalkChanges': lRecentTalkChanges,
})
def map_script_search(request):
"""
Return the javascript to add markers for bands within given distance miles of a point. Return a map_script.js centered on that point, showing bands within 10 miles
"""
lLatitude, lLongitude, lDistance, lType = _get_map_search_parameters(
request)
lVenues = None
if lLatitude and lLongitude and lDistance:
# showing map searched from a given lat/lng
lSearchPoint = Point(lLongitude, lLatitude)
lBands = Band.objects.distance(lSearchPoint).select_related(
'region').order_by('distance')
if lType == 'km':
lBands = lBands.filter(
point__distance_lte=(lSearchPoint,
D(km=lDistance))).exclude(status=0)
else:
lBands = lBands.filter(
point__distance_lte=(lSearchPoint,
D(mi=lDistance))).exclude(status=0)
lType = 'mi'
else:
# showing full map
lBands = []
lVenues = []
return render_auth(
request, 'map/map_script.js', {
"Bands": lBands,
"Venues": lVenues,
"Latitude": lLatitude,
"Longitude": lLongitude,
"Distance": lDistance,
"ShowExtinct": False,
})
def edit_band_profile(request, pUsercode, pClassifiedProfileId):
"""
Edit a classified band profile
"""
try:
lProfile = ClassifiedBand.objects.filter(owner=request.user,
id=pClassifiedProfileId)[0]
except IndexError:
raise Http404
if request.method == 'POST':
lForm = EditClassifiedBandForm(request.POST,
request.FILES,
instance=lProfile)
if lForm.is_valid():
lOldProfile = ClassifiedBand.objects.filter(id=lProfile.id)[0]
lNewProfile = lForm.save(commit=False)
lNewProfile.lastChangedBy = request.user
lNewProfile.owner = request.user
lNewProfile.save()
lNewProfile.check_expiry()
notification(lOldProfile, lNewProfile, 'classifieds',
'band_profile', 'edit', request.user,
browser_details(request))
return HttpResponseRedirect('/users/%s/classifieds/' %
(lProfile.owner.username))
else:
lForm = EditClassifiedBandForm(instance=lProfile)
return render_auth(request, 'classifieds/edit_band_profile.html', {
'Profile': lProfile,
'form': lForm,
})
def classifieds(request, pUsername):
"""
Show classified profiles
"""
try:
lUser = User.objects.filter(username=pUsername)[0]
except IndexError:
raise Http404
lProfile = lUser.profile
if pUsername != lUser.username:
raise Http404
lOutstandingFeedbackCount, lSentFeedbackCount, lContestsCount, lContestHistoryCount, lMessageCount, lUserBadges = _get_tab_counts(
request, lUser)
lClassifiedProfiles = ClassifiedPerson.objects.filter(owner=request.user)
return render_auth(
request, 'users/profile/classifieds.html', {
'User': lUser,
'Profile': lProfile,
"ContestCount": lContestsCount,
'FeedbackCount': lOutstandingFeedbackCount,
'SentFeedbackCount': lSentFeedbackCount,
'PerformanceCount': lContestHistoryCount,
"MessageCount": lMessageCount,
"ClassifiedProfiles": lClassifiedProfiles,
"UserBadges": lUserBadges,
})
def feedback_sent(request, pUsername):
"""
Show feedback sent
"""
try:
lUser = User.objects.filter(username=pUsername)[0]
except IndexError:
raise Http404
lProfile = lUser.profile
if pUsername != lUser.username:
raise Http404
lSentFeedback = SiteFeedback.objects.filter(
reporter=request.user).select_related().order_by('created')
lOutstandingFeedbackCount, lSentFeedbackCount, lContestsCount, lContestHistoryCount, lMessageCount, lUserBadges = _get_tab_counts(
request, lUser)
return render_auth(
request, 'users/profile/feedback_sent.html', {
'User': lUser,
'Profile': lProfile,
'SentFeedback': lSentFeedback,
'FeedbackCount': lOutstandingFeedbackCount,
'SentFeedbackCount': lSentFeedbackCount,
'ContestCount': lContestsCount,
'PerformanceCount': lContestHistoryCount,
"MessageCount": lMessageCount,
"UserBadges": lUserBadges,
})
def notifications(request, pUsername):
"""
Show notifications page in user profile
"""
if request.user.is_superuser == False:
raise Http404
try:
lUser = User.objects.filter(username=pUsername)[0]
except IndexError:
raise Http404
lProfile = lUser.profile
if pUsername != lUser.username:
raise Http404
lOutstandingFeedbackCount, lSentFeedbackCount, lContestsCount, lContestHistoryCount, lMessageCount, lUserBadges = _get_tab_counts(
request, lUser)
return render_auth(
request, 'users/profile/notifications.html', {
'User': lUser,
'Profile': lProfile,
"ContestCount": lContestsCount,
'FeedbackCount': lOutstandingFeedbackCount,
'SentFeedbackCount': lSentFeedbackCount,
'PerformanceCount': lContestHistoryCount,
"MessageCount": lMessageCount,
"UserBadges": lUserBadges,
})
def add_person(request):
"""
Add a new person
"""
lFormType = EditPersonForm
if request.user.profile.superuser:
lFormType = EditPersonAsSuperuserForm
if request.user.profile.superuser == False:
if request.user.profile.enhanced_functionality == False:
raise Http404()
if request.method == 'POST':
form = lFormType(request.POST)
if form.is_valid():
lNewPerson = form.save(commit=False)
lNewPerson.slug = slugify(lNewPerson.name, instance=lNewPerson)
lNewPerson.lastChangedBy = request.user
lNewPerson.owner = request.user
lNewPerson.save()
notification(None, lNewPerson, 'people', 'person', 'new', request.user, browser_details(request))
return HttpResponseRedirect('/people/')
else:
form = lFormType()
return render_auth(request, 'people/new_person.html', {'form': form})
def talk(request, pUsername):
"""
Show the talk page for a particular user
"""
if request.user.profile.superuser == False:
raise Http404
try:
lTalkUser = User.objects.filter(username=pUsername)[0]
except IndexError:
raise Http404
try:
lTalk = UserTalk.objects.filter(owner=lTalkUser)[0]
except IndexError:
lTalk = None
lEditEnabled = False
if lTalkUser.username == request.user.username:
lEditEnabled = True
lSuperusers = UserProfile.objects.filter(superuser=True)
lRecentTalkChanges = fetch_recent_talk_changes(request)
return render_auth(
request, 'users/talk.html', {
'TalkUser': lTalkUser,
'Talk': lTalk,
'EditEnabled': lEditEnabled,
'OwnerId': lTalkUser.id,
'Superusers': lSuperusers,
'RecentTalkChanges': lRecentTalkChanges,
})
def single_person_aliases(request, pPersonSlug):
"""
Show and edit aliases for a given person
"""
if pPersonSlug == 'unknown':
raise Http404()
if request.user.profile.superuser == False:
raise Http404()
try:
lPerson = Person.objects.filter(slug=pPersonSlug)[0]
except IndexError:
raise Http404()
if request.POST:
lNewAlias = request.POST['new_alias_name']
lPersonAlias = PersonAlias()
lPersonAlias.person = lPerson
lPersonAlias.name = lNewAlias
lPersonAlias.owner = request.user
lPersonAlias.lastChangedBy = request.user
lPersonAlias.save()
notification(None, lPersonAlias, 'people', 'person_alias', 'new', request.user, browser_details(request))
return HttpResponseRedirect('/people/%s/aliases/' % lPerson.slug)
lPeopleAliases = PersonAlias.objects.filter(person=lPerson)
return render_auth(request, "people/person_aliases.html", {
'Person' : lPerson,
'Aliases' : lPeopleAliases,
})
def talk_edit(request, pUsername):
"""
Edit the talk page
"""
if request.user.profile.superuser == False:
raise Http404
if request.user.username != pUsername:
raise Http404
try:
lTalk = UserTalk.objects.filter(owner=request.user)[0]
except IndexError:
lTalk = UserTalk()
lTalk.owner = request.user
lTalk.save()
if request.method == "POST":
form = UserTalkEditForm(data=request.POST, instance=lTalk)
if form.is_valid():
form.save()
# notification(None, lTalk, 'talk', 'edit', request.user, browser_details(request))
return HttpResponseRedirect('/users/%s/talk/' %
request.user.username)
else:
form = UserTalkEditForm(instance=lTalk)
return render_auth(request, 'users/talk_edit.html', {
'Talk': lTalk,
'form': form,
})
def number_bands(request):
"""
Show list of which conductors have taken the most bands
"""
lPeople = []
cursor = connection.cursor()
cursor.execute("""
WITH bands AS (
SELECT r.person_conducting_id, count(distinct r.band_id) as bandcount
FROM contests_contestresult r
GROUP BY r.person_conducting_id
ORDER BY 2 desc
)
SELECT p.slug, p.surname, p.first_names, b.bandcount
FROM people_person p
INNER JOIN bands b ON b.person_conducting_id = p.id
WHERE b.bandcount > 4
AND b.person_conducting_id != 310730 -- unknown
ORDER BY 4 desc
""")
rows = cursor.fetchall()
for row in rows:
lPerson = ResultObject()
lPerson.slug = row[0]
lPerson.surname = row[1]
lPerson.first_names = row[2]
lPerson.bandcount = row[3]
lPeople.append(lPerson)
cursor.close()
return render_auth(request, 'people/bandcount.html', {
'People' : lPeople,
})
def pro_upgrade(request):
"""
Upgrade to a pro account
"""
lStripePublicCode = settings.STRIPE_PUBLIC_DATA_KEY
return render_auth(request, 'users/pro/upgrade.html',
{'StripePublicCode': lStripePublicCode})
def edit_piece(request, pPieceSlug):
"""
Edit a test piece
"""
try:
lPiece = TestPiece.objects.filter(slug=pPieceSlug)[0]
except IndexError:
raise Http404()
if request.user.profile.superuser == False:
if request.user.id != lPiece.owner.id:
raise Http404()
if request.user.profile.enhanced_functionality == False:
raise Http404()
if request.method == 'POST':
form = EditPieceForm(request.POST, instance=lPiece)
if form.is_valid():
lOldPiece = TestPiece.objects.filter(id=lPiece.id)[0]
lNewPiece = form.save(commit=False)
lNewPiece.lastChangedBy = request.user
lNewPiece.save()
notification(lOldPiece, lNewPiece, 'pieces', 'piece', 'edit',
request.user, browser_details(request))
return HttpResponseRedirect('/pieces/%s/' % lPiece.slug)
else:
form = EditPieceForm(instance=lPiece)
return render_auth(request, 'pieces/edit_piece.html', {
'form': form,
"Piece": lPiece
})
def feedback_push_to_admin(request, pUsercode, pFeedbackId):
"""
Release feedback to admin queue
"""
try:
lFeedback = SiteFeedback.objects.filter(id=pFeedbackId)[0]
except IndexError:
raise Http404()
lProfile = request.user.profile
if lProfile.superuser and lFeedback.claim_date != None:
lProfile.remove_points_and_save(lFeedback.id,
PointsAward.TYPE_FEEDBACK_CLAIM)
lFeedbackComment = ""
if request.POST:
if not lFeedback.additional_comments:
lFeedback.additional_comments = ""
lFeedback.additional_comments += "\n"
lFeedbackComment = request.POST['extra']
lFeedback.additional_comments += lFeedbackComment
lFeedback.status = 'Admin'
lFeedback.lastChangedBy = request.user
lFeedback.claim_date = None
if request.user.id == lFeedback.owner.id:
lFeedback.save("Feedback pushed to admin by %s with comment [%s]" %
(request.user, lFeedbackComment))
notification(None, lFeedback, 'feedback', 'feedback', 'to_admin',
request.user, browser_details(request))
return render_auth(request, 'users/blank.html')
def list_merge_requests(request):
"""
List all requests for Person merges
"""
if request.user.profile.superuser == False:
raise Http404
lMergeRequests = PersonMergeRequest.objects.filter()
for mergeRequest in lMergeRequests:
mergeRequest.from_adjuducations_count = ContestAdjudicator.objects.filter(
person=mergeRequest.source_person).count()
mergeRequest.to_adjuducations_count = ContestAdjudicator.objects.filter(
person=mergeRequest.destination_person).count()
mergeRequest.from_compositions_count = TestPiece.objects.filter(
composer=mergeRequest.source_person).count()
mergeRequest.to_compositions_count = TestPiece.objects.filter(
composer=mergeRequest.destination_person).count()
mergeRequest.from_arranger_count = TestPiece.objects.filter(
arranger=mergeRequest.source_person).count()
mergeRequest.to_arranger_count = TestPiece.objects.filter(
arranger=mergeRequest.destination_person).count()
return render_auth(request, 'move/list_person_merge_requests.html',
{'MergeRequests': lMergeRequests})
def enter_contest_date(request, pContestSlug):
"""
Enter date of contest
"""
lContestDate = ""
lForm = ContestDateForm()
try:
lContestGroup = ContestGroup.objects.filter(slug=pContestSlug)[0]
except IndexError:
raise Http404()
if request.POST:
lForm = ContestDateForm(request.POST)
lContestDate = request.POST['ContestDate']
if lForm.is_valid():
lContestDate = lForm.cleaned_data['ContestDate']
lSlashCount = lContestDate.count('/')
if lSlashCount == 0:
lDay, lMonth, lYear = (1, 1, lContestDate)
lDateResolution = 'Y'
elif lSlashCount == 1:
lDay = 1
lMonth, lYear = lContestDate.split('/')
lDateResolution = 'M'
elif lSlashCount == 2:
lDay, lMonth, lYear = lContestDate.split('/')
lDateResolution = 'D'
lDate = '%s-%s-%s' % (lYear, lMonth, lDay)
return HttpResponseRedirect('/addwhitfriday/%s/%s/' %
(pContestSlug, lDate))
return render_auth(request, 'addwhitfriday/contestdate.html', {
"ContestGroup": lContestGroup,
"form": lForm
})
