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 })