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 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 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_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_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 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 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 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_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 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 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 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 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 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_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 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 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 feedback_release_to_queue(request, pUsercode, pFeedbackId): """ Release feedback into the 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) lFeedback.status = 'Queue' lFeedback.lastChangedBy = request.user lFeedback.claim_date = None if request.user.id == lFeedback.owner.id: lFeedback.save("Feedback queued by %s" % request.user) notification(None, lFeedback, 'feedback', 'feedback', 'to_queue', request.user, browser_details(request)) return HttpResponseRedirect('/users/%s/' % pUsercode)
def add_piece(request): """ Add a new test piece """ if request.user.profile.superuser == False: if request.user.profile.enhanced_functionality == False: raise Http404() if request.method == 'POST': form = EditPieceForm(request.POST) if form.is_valid(): lNewPiece = form.save(commit=False) lNewPiece.slug = slugify(lNewPiece.name, instance=lNewPiece) lNewPiece.lastChangedBy = request.user lNewPiece.owner = request.user lNewPiece.save() notification(None, lNewPiece, 'pieces', 'piece', 'new', request.user, browser_details(request)) return HttpResponseRedirect('/pieces/') else: form = EditPieceForm() return render_auth(request, 'pieces/new_piece.html', {'form': form})
def merge_request(request, pSourceBandSlug): """ Request move of all results from one band to another """ try: lSourceBand = Band.objects.filter(slug=pSourceBandSlug)[0] lDestinationBand = Band.objects.filter( id=request.POST['moveToBand'])[0] lBandMergeRequest = BandMergeRequest() lBandMergeRequest.source_band = lSourceBand lBandMergeRequest.destination_band = lDestinationBand lBandMergeRequest.lastChangedBy = request.user lBandMergeRequest.owner = request.user lBandMergeRequest.save() notification(None, lBandMergeRequest, 'move', 'band_merge', 'request', request.user, browser_details(request)) except IndexError: # someone already merged one or either side pass return render_auth(request, 'move/merge_request_received.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')
def merge_request(request, pSourceVenueSlug): """ Request move of all results from one venue to another """ try: lSourceVenue = Venue.objects.filter(slug=pSourceVenueSlug)[0] lDestinationVenue = Venue.objects.filter( id=request.POST['moveToVenue'])[0] lVenueMergeRequest = VenueMergeRequest() lVenueMergeRequest.source_venue = lSourceVenue lVenueMergeRequest.destination_venue = lDestinationVenue lVenueMergeRequest.lastChangedBy = request.user lVenueMergeRequest.owner = request.user lVenueMergeRequest.save() notification(None, lVenueMergeRequest, 'move', 'venue_merge', 'request', request.user, browser_details(request)) except IndexError: # someone already merged one or either side pass return render_auth(request, 'move/merge_request_received.html')
def password_change(request, pUsername): """ Show change password form """ if request.method == "POST": form = PasswordChangeForm(user=request.user, data=request.POST) if form.is_valid(): form.save() notification(None, request.user, 'users', 'password', 'changed', request.user, browser_details(request), pDestination=request.user.email) return HttpResponseRedirect('/users/%s/password_changed/' % pUsername) else: form = PasswordChangeForm(user=request.user) return render_auth(request, 'users/changepassword.html', {'form': form})
def merge_request(request, pSourcePersonSlug): """ Request move of all results from one person to another """ try: lSourcePerson = Person.objects.filter(slug=pSourcePersonSlug)[0] lDestinationPerson = Person.objects.filter( id=request.POST['moveToPerson'])[0] lPersonMergeRequest = PersonMergeRequest() lPersonMergeRequest.source_person = lSourcePerson lPersonMergeRequest.destination_person = lDestinationPerson lPersonMergeRequest.lastChangedBy = request.user lPersonMergeRequest.owner = request.user lPersonMergeRequest.save() notification(None, lPersonMergeRequest, 'move', 'person_merge', 'request', request.user, browser_details(request)) except IndexError: # someone already merged one or either side pass return render_auth(request, 'move/merge_request_received.html')
def feedback_inconclusive(request, pUsercode, pFeedbackId): """ Mark feedback as inconclusive """ if request.user.is_superuser == False: raise Http404 try: lFeedback = SiteFeedback.objects.filter(id=pFeedbackId)[0] except IndexError: raise Http404() if request.POST: if not lFeedback.additional_comments: lFeedback.additional_comments = "" lFeedback.additional_comments += "\n" lFeedback.additional_comments += request.POST['extra'] lFeedback.status = 'Inconclusive' lFeedback.lastChangedBy = request.user lFeedback.save("Feedback marked as inconclusive by %s with comment [%s]" % (request.user, request.POST['extra'])) notification(None, lFeedback, 'feedback', 'feedback', 'inconclusive', request.user, browser_details(request)) return HttpResponseRedirect('/users/%s/' % pUsercode)