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 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 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 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 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 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_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 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 single_band_alias_hide(request, pBandSlug, pAliasSerial):
"""
Hide an alias on the band page
"""
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 lEnhancedUserAndOwner):
raise Http404()
try:
lBandAlias = PreviousBandName.objects.filter(band__slug=pBandSlug,
id=pAliasSerial)[0]
except IndexError:
raise Http404
lBandAlias.hidden = True
lBandAlias.lastChangedBy = request.user
lBandAlias.save()
notification(None, lBandAlias, 'bands', 'band_alias', 'hide', request.user,
browser_details(request))
return HttpResponseRedirect('/bands/%s/aliases/' % pBandSlug)
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 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 edit_band(request, pBandSlug):
"""
Edit a 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
lRegionalSuperuserAndBandInRightRegion = request.user.profile.is_regional_superuser_region(
lBand.region)
lRegionalSuperuser = request.user.profile.regional_superuser
if not (lSuperuser or lEnhancedUserAndOwner
or lRegionalSuperuserAndBandInRightRegion or lRegionalSuperuser):
raise Http404
if lSuperuser or lRegionalSuperuserAndBandInRightRegion:
lFormClass = EditBandSuperuserForm
else:
lFormClass = EditBandForm
if request.method == 'POST':
form = lFormClass(request.POST, instance=lBand)
if form.is_valid():
lOldBand = Band.objects.filter(id=lBand.id)[0]
lNewBand = form.save(commit=False)
if lNewBand.name.lower() != lOldBand.name.lower():
try:
lOldBandMatchingAlias = PreviousBandName.objects.filter(
band=lNewBand, old_name__iexact=lOldBand.name)[0]
except IndexError:
# old name doesn't exist as alias
lPreviousBandName = PreviousBandName()
lPreviousBandName.owner = request.user
lPreviousBandName.lastChangedBy = request.user
lPreviousBandName.original_owner = request.user
lPreviousBandName.old_name = lOldBand.name
lPreviousBandName.visible = True
lPreviousBandName.band = lNewBand
lPreviousBandName.save()
lNewBand.lastChangedBy = request.user
lNewBand.save()
notification(lOldBand, lNewBand, 'bands', 'band', 'edit',
request.user, browser_details(request))
return HttpResponseRedirect('/bands/%s/' % lBand.slug)
else:
form = lFormClass(instance=lBand)
return render_auth(request, 'bands/edit_band.html', {
'form': form,
"Band": lBand
})
def merge_action(request, pMergeVenueRequestSerial):
"""
Perform a merge of venues
"""
if request.user.profile.superuser == False:
raise Http404
try:
lMergeRequest = VenueMergeRequest.objects.filter(
id=pMergeVenueRequestSerial)[0]
except IndexError:
raise Http404
lFromVenue = lMergeRequest.source_venue
lToVenue = lMergeRequest.destination_venue
if not lToVenue.country_id and lFromVenue.country_id:
lToVenue.country = lFromVenue.country
if not lToVenue.latitude and lFromVenue.latitude:
lToVenue.latitude = lFromVenue.latitude
if not lToVenue.longitude and lFromVenue.longitude:
lToVenue.longitude = lFromVenue.longitude
if not lToVenue.postcode and lFromVenue.postcode:
lToVenue.postcode = lFromVenue.postcode
lToVenue.save()
lEventsToMove = ContestEvent.objects.filter(venue_link=lFromVenue)
for event in lEventsToMove:
event.venue_link = lToVenue
event.lastChangedBy = request.user
event.save()
lNewVenueAlias = VenueAlias()
lNewVenueAlias.venue = lToVenue
lNewVenueAlias.name = lFromVenue.name
lNewVenueAlias.owner = request.user
lNewVenueAlias.lastChangedBy = request.user
lNewVenueAlias.save()
notification(None, lMergeRequest, 'move', 'venue_merge', 'done',
request.user, browser_details(request))
lSubmitterUser = lMergeRequest.owner
notification(None,
lMergeRequest,
'move',
'venue',
'merge',
request.user,
browser_details(request),
pDestination=lSubmitterUser.email)
lFromVenue.delete()
lMergeRequest.delete()
return HttpResponseRedirect('/move/venues/')
def new_classified(request, pPersonSlug):
"""
Create a new classified entry for this person
"""
try:
lPerson = Person.objects.filter(slug=pPersonSlug)[0]
except IndexError:
raise Http404
if request.user.is_anonymous == True or request.user.profile.pro_member == False:
raise Http404
lMaxProfiles = request.user.profile.max_profile_count
lActualPeopleProfilesCount = ClassifiedPerson.objects.filter(owner=request.user).count()
if (lActualPeopleProfilesCount >= lMaxProfiles):
return HttpResponseRedirect("/people/%s/newclassified/too_many/?username=%s" % (lPerson.slug,request.user.username))
lProfile = None
try:
lProfile = ClassifiedPerson.objects.filter(person=lPerson)[0]
except IndexError:
lProfile = None
if request.method == 'POST':
if lProfile:
if lProfile.owner != request.user:
raise Http404
lForm = EditClassifiedProfileForm(request.POST, instance=lProfile)
else:
lForm = EditClassifiedProfileForm(request.POST)
if lForm.is_valid():
# save new profile
lNewProfile = lForm.save(commit=False)
lNewProfile.person = lPerson
lNewProfile.lastChangedBy = request.user
lNewProfile.owner = request.user
lNewProfile.visible = True
lNewProfile.show_on_homepage = False
lNewProfile.save()
# email notification
notification(None, lNewProfile, 'people', 'profile', 'new', request.user, browser_details(request))
# redirect to person page
return HttpResponseRedirect('/people/%s/' % pPersonSlug)
else:
if lProfile:
lForm = EditClassifiedProfileForm(instance=lProfile)
else:
lForm = EditClassifiedProfileForm()
return render_auth(request, 'people/edit_classified.html', {"Person" : lPerson,
"form" : lForm,
})
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 _link_adjudicator(request, pOriginalAdjudicatorName, pContestEvent):
"""
Link the passed adjudicator to the contest
"""
lAdjudicatorName = pOriginalAdjudicatorName
if lAdjudicatorName.lower() == 'unknown':
return
# if it ends with a dot, remove it
if lAdjudicatorName.endswith('.'):
lAdjudicatorName = lAdjudicatorName[:-1]
# if there is no space after a full stop then add one
lAdjudicatorName = add_space_after_dot(lAdjudicatorName)
# if there is no dot after an initial then add one
lAdjudicatorName = add_dot_after_initial(lAdjudicatorName)
# get rid of double spaces
lAdjudicatorName = lAdjudicatorName.replace(" ", " ")
lLastSpace = lAdjudicatorName.rfind(' ')
if lLastSpace > 0:
lAdjudicatorFirstNames = lAdjudicatorName[:lLastSpace].strip()
lAdjudicatorSurname = lAdjudicatorName[lLastSpace:].strip()
else:
lAdjudicatorFirstNames = lAdjudicatorName
lAdjudicatorSurname = lAdjudicatorName
try:
lPerson = Person.objects.filter(
first_names__iexact=lAdjudicatorFirstNames,
surname__iexact=lAdjudicatorSurname)[0]
except IndexError:
try:
lPersonAlias = PersonAlias.objects.filter(
name__iexact=lAdjudicatorName)[0]
lPerson = lPersonAlias.person
except IndexError:
lPerson = Person()
lPerson.surname = lAdjudicatorSurname
lPerson.first_names = lAdjudicatorFirstNames
lPerson.slug = slugify(lAdjudicatorName, instance=lPerson)
lPerson.owner = request.user
lPerson.lastChangedBy = request.user
lPerson.save()
notification(None, lPerson, 'people', 'person', 'new',
request.user, browser_details(request))
lContestAdjudicator = ContestAdjudicator()
lContestAdjudicator.contest_event = pContestEvent
lContestAdjudicator.adjudicator_name = lPerson.name
lContestAdjudicator.person = lPerson
lContestAdjudicator.owner = request.user
lContestAdjudicator.lastChangedBy = request.user
lContestAdjudicator.save()
def enter_notes(request, pContestSlug, pDate):
"""
Enter any notes about the contest result
"""
lForm = NotesForm()
try:
lContest = Contest.objects.filter(slug=pContestSlug)[0]
lContestEvent = ContestEvent.objects.filter(contest=lContest,
date_of_event=pDate)[0]
except IndexError:
raise Http404()
# Process Notes
if request.POST:
lForm = NotesForm(request.POST)
if lForm.is_valid():
if lContestEvent.notes:
lContestEvent.notes += "\n"
lContestEvent.notes += lForm.cleaned_data['notes']
lContestEvent.save()
return HttpResponseRedirect(
'/contests/%s/%s/' %
(lContest.slug, lContestEvent.date_of_event))
else:
return HttpResponseRedirect(
'/contests/%s/%s/' %
(lContest.slug, lContestEvent.date_of_event))
else:
lContestUrl = lContestEvent.get_absolute_url()
lWinners = lContestEvent.winners()
lWinnersTwitter = ""
lAdditionalContext = {}
for winner in lWinners:
if winner.band.twitter_name:
lWinnersTwitter += winner.band.twitter_name + " "
lAdditionalContext["WinnersTwitter"] = lWinnersTwitter
notification(None,
lContestEvent,
'contests',
'contestevent',
'results_added',
request.user,
browser_details(request),
pUrl=lContestUrl,
pAdditionalContext=lAdditionalContext)
return render_auth(request, 'addresults/notes.html', {
"Contest": lContest,
"ContestEvent": lContestEvent,
"form": lForm,
})
def pro_paid(request):
"""
Paid, activate pro account
"""
lCurrentUserProfile = request.user.profile
lCurrentUserProfile.pro_member = True
lCurrentUserProfile.stripe_token = request.POST.get('stripeToken')
lCurrentUserProfile.stripe_email = request.POST.get('stripeEmail')
lCurrentUserProfile.save()
import stripe
stripe.api_key = settings.STRIPE_SECRET_KEY
try:
# Use Stripe's bindings...
lCustomer = stripe.Customer.create(
description=request.user.username,
source=lCurrentUserProfile.stripe_token,
email=lCurrentUserProfile.stripe_email)
lCustomer.subscriptions.create(plan='BBRPRO')
lCurrentUserProfile.stripe_customer = lCustomer.id
lCurrentUserProfile.save()
except stripe.error.CardError as e:
# Since it's a decline, stripe.error.CardError will be caught
body = e.json_body
err = body['error']
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
pass
except stripe.error.AuthenticationError as e:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
pass
except stripe.error.APIConnectionError as e:
# Network communication with Stripe failed
pass
except stripe.error.StripeError as e:
# Display a very generic error to the user, and maybe send
# yourself an email
pass
except Exception as e:
# Something else happened, completely unrelated to Stripe
pass
notification(request.user, None, 'users', 'pro_upgrade', 'paid',
request.user, browser_details(request))
return HttpResponseRedirect('/accounts/pro/thanks/')
def enter_contest_name(request):
"""
Enter the name of the contest
"""
lForm = ContestNameForm()
lContestName = ''
if request.POST:
lForm = ContestNameForm(request.POST)
lContestName = request.POST['contest']
if lForm.is_valid():
lContestName = lForm.cleaned_data['contest']
if lContestName.strip().endswith('.'):
lContestName = lContestName.strip()[:-1]
lExistingContest = False
try:
lContest = Contest.objects.filter(name__iexact=lContestName)[0]
lContestGroup = lContest.group
if lContestGroup and lContestGroup.group_type == 'W':
return HttpResponseRedirect("/addresults/whitfriday")
lExistingContest = True
except IndexError:
lContest = Contest()
lContest.name = lContestName
lContest.slug = slugify(lContestName, instance=lContest)
lContest.description = ''
lContest.lastChangedBy = request.user
lContest.owner = request.user
lContest.save()
notification(None, lContest, 'contests', 'contest', 'new',
request.user, browser_details(request))
if lExistingContest:
return HttpResponseRedirect('/addresults/%s/' % lContest.slug)
else:
return HttpResponseRedirect('/addresults/%s/contest-type/' %
lContest.slug)
cursor = connection.cursor()
lContestNamesData = []
cursor.execute("select name from contests_contest order by name")
rows = cursor.fetchall()
for row in rows:
lContestNamesData.append(row[0])
return render_auth(request, 'addresults/contestname.html', {
'form': lForm,
'value': lContestName,
'Data': lContestNamesData
})
def single_person_alias_delete(request, pPersonSlug, pAliasSerial):
"""
Delete a conductor alias
"""
if request.user.profile.superuser == False:
raise Http404()
try:
lPersonAlias = PersonAlias.objects.filter(person__slug=pPersonSlug, id=pAliasSerial)[0]
except IndexError:
raise Http404
notification(None, lPersonAlias, 'people', 'person_alias', 'delete', request.user, browser_details(request))
lPersonAlias.delete()
return HttpResponseRedirect('/people/%s/aliases/' % pPersonSlug)
def edit_classified(request, pPersonSlug):
"""
Edit a classified entry for this person
"""
try:
lPerson = Person.objects.filter(slug=pPersonSlug)[0]
except IndexError:
raise Http404
if request.user.is_anonymous == True or request.user.profile.pro_member == False:
raise Http404
lProfile = None
try:
lProfile = ClassifiedPerson.objects.filter(person=lPerson)[0]
except IndexError:
lProfile = None
if request.method == 'POST':
if lProfile:
if lProfile.owner != request.user:
raise Http404
lForm = EditClassifiedProfileForm(request.POST, instance=lProfile)
else:
lForm = EditClassifiedProfileForm(request.POST)
if lForm.is_valid():
# save new profile
lNewProfile = lForm.save(commit=False)
lNewProfile.person = lPerson
lNewProfile.lastChangedBy = request.user
lNewProfile.owner = request.user
lNewProfile.save()
# email notification
notification(None, lNewProfile, 'people', 'profile', 'edit', request.user, browser_details(request))
# redirect to person page
return HttpResponseRedirect('/people/%s/' % pPersonSlug)
else:
if lProfile:
lForm = EditClassifiedProfileForm(instance=lProfile)
else:
lForm = EditClassifiedProfileForm()
return render_auth(request, 'people/edit_classified.html', {"Person" : lPerson,
"form" : lForm,
})
def forgotten_password(request):
"""
Allow the user's password to be reset
"""
if request.method == "POST":
# send email with password reset in
lForm = PasswordResetForm(request.POST)
if lForm.is_valid():
lPasswordReset = PasswordReset()
lPasswordReset.generateKey()
lPasswordReset.username = lForm.cleaned_data['username']
lPasswordReset.ip = request.META['REMOTE_ADDR']
lPasswordReset.useragent = request.META['HTTP_USER_AGENT']
lPasswordReset.save()
try:
lUser = User.objects.filter(
username__iexact=lPasswordReset.username)[0]
except:
# try looking by email address
try:
lUser = User.objects.filter(
email__iexact=lPasswordReset.username).order_by(
'-last_login')[0]
except:
# don't send email if account not found
return HttpResponseRedirect(
'/accounts/forgottenpassword/sent/')
if lUser.is_active == False:
# don't send email if user is inactive
return HttpResponseRedirect(
'/accounts/forgottenpassword/sent/')
notification(lUser,
lPasswordReset,
'users',
'password_reset',
'request',
request.user,
browser_details(request),
pDestination=lUser.email)
return HttpResponseRedirect('/accounts/forgottenpassword/sent/')
else:
# show password reset form
lForm = PasswordResetForm()
return render_auth(request, "users/resetpassword/forgotten_password.html",
{'form': lForm})
def single_band_alias_delete(request, pBandSlug, pAliasSerial):
"""
Delete a band alias
"""
if request.user.profile.superuser == False:
raise Http404()
try:
lBandAlias = PreviousBandName.objects.filter(band__slug=pBandSlug,
id=pAliasSerial)[0]
except IndexError:
raise Http404
notification(None, lBandAlias, 'bands', 'band_alias', 'delete',
request.user, browser_details(request))
lBandAlias.delete()
return HttpResponseRedirect('/bands/%s/aliases/' % pBandSlug)
def single_venue_alias_delete(request, pVenueSlug, pAliasSerial):
"""
Delete a band alias
"""
if request.user.profile.superuser == False:
raise Http404()
try:
lVenueAlias = VenueAlias.objects.filter(venue__slug=pVenueSlug,
id=pAliasSerial)[0]
except IndexError:
raise Http404
notification(None, lVenueAlias, 'venues', 'venue_alias', 'delete',
request.user, browser_details(request))
lVenueAlias.delete()
return HttpResponseRedirect('/venues/%s/aliases/' % pVenueSlug)
def single_person_alias_hide(request, pPersonSlug, pAliasSerial):
"""
Hide an alias on the person page
"""
if request.user.profile.superuser == False:
raise Http404()
try:
lPersonAlias = PersonAlias.objects.filter(person__slug=pPersonSlug, id=pAliasSerial)[0]
except IndexError:
raise Http404
lPersonAlias.hidden = True
lPersonAlias.lastChangedBy = request.user
lPersonAlias.save()
notification(None, lPersonAlias, 'people', 'person_alias', 'hide', request.user, browser_details(request))
return HttpResponseRedirect('/people/%s/aliases/' % pPersonSlug)
def save(self, request, pContestEvent):
for result in self.processed_results:
lContestResult = ContestResult()
lContestResult.contest_event = pContestEvent
lContestResult.band = result["Band"]
lContestResult.results_position = result["Position"]
lContestResult.band_name = result["BandName"]
lContestResult.draw = result["Draw"]
lContestResult.points = result["Points"]
lContestResult.test_piece = None
lContestResult.notes = ''
lContestResult.person_conducting = result["Conductor"]
lContestResult.conductor_name = result["ConductorName"]
lContestResult.lastChangedBy = request.user
lContestResult.owner = request.user
lContestResult.save()
notification(None, lContestResult, 'contests', 'contest_result', 'new', request.user, browser_details(request))
def save(self, request, pContestEvent, pContestDate):
for result in self.processed_results:
lBand = result["Band"]
lBandName = result["BandName"]
lResults = result["TabulatedResults"]
lUnknownConductor = Person.objects.filter(slug='unknown')[0]
for contest_slug, position in lResults.items():
position = position.strip()
if len(position) == 0 or position == '0' or int(position) > LOWEST_SPECIAL_POSITION:
continue
# create or find matching contest event
lContest = Contest.objects.filter(slug=contest_slug)[0]
try:
lContestEvent = ContestEvent.objects.filter(contest=lContest, date_of_event=pContestDate)[0]
except IndexError:
lContestEvent = ContestEvent()
lContestEvent.contest = lContest
lContestEvent.date_of_event = pContestDate
lContestEvent.name = lContest.name
lContestEvent.lastChangedBy = request.user
lContestEvent.owner = request.user
lContestEvent.save()
# create result
lContestResult = ContestResult()
lContestResult.contest_event = lContestEvent
lContestResult.band = lBand
if self.points_entered:
lContestResult.results_position = 0
lContestResult.points = position
else:
lContestResult.results_position = position
lContestResult.points = 0
lContestResult.band_name = lBandName
lContestResult.draw = 0
lContestResult.test_piece = None
lContestResult.notes = ''
lContestResult.person_conducting = lUnknownConductor
lContestResult.lastChangedBy = request.user
lContestResult.owner = request.user
lContestResult.save()
notification(None, lContestResult, 'contests', 'contest_result', 'new', request.user, browser_details(request))
def feedback_claim_from_queue(request, pUsercode, pFeedbackId):
"""
Claim feedback from the queue
"""
if request.user.profile.superuser == False:
raise Http404()
try:
lFeedback = SiteFeedback.objects.filter(id=pFeedbackId)[0]
except IndexError:
raise Http404()
lFeedback.status = 'Outstanding'
lFeedback.owner = request.user
lFeedback.lastChangedBy = request.user
lFeedback.claim_date = datetime.now()
lFeedback.save("Feedback claimed from queue by %s" % request.user)
lProfile = request.user.profile
if lProfile.superuser:
notification(None, lFeedback, 'feedback', 'feedback', 'claim',
request.user, browser_details(request))
return render_auth(request, 'users/blank.html')
def reject_merge(request, pMergePersonRequestSerial):
"""
Reject a Person merge
"""
if request.user.profile.superuser == False:
raise Http404
try:
lPersonMergeRequest = PersonMergeRequest.objects.filter(
id=pMergePersonRequestSerial)[0]
except IndexError:
raise Http404
# send email back to original submitter
lReason = request.POST['reason']
if lReason:
lSubmitterUser = lPersonMergeRequest.owner
lDestination = lSubmitterUser.email
else:
lDestination = '*****@*****.**'
lContext = {
'Reason': lReason,
}
notification(None,
lPersonMergeRequest,
'move',
'person',
'reject',
request.user,
browser_details(request),
pDestination=lDestination,
pAdditionalContext=lContext)
# delete merge request
lPersonMergeRequest.delete()
return render_auth(request, 'blank.htm')
