def save(self):
        new_sources = self.cleaned_data["sources"]
        old_sources = set(source["id"] for source in self.sound.sources.all().values("id"))
        try:
            new_sources.remove(self.sound.id)  # stop the universe from collapsing :-D
        except KeyError:
            pass

        for sid in old_sources - new_sources:  # in old but not in new
            try:
                source = Sound.objects.get(id=sid)
                self.sound.sources.remove(source)

                # modify remix_group
                send_mail_template(
                    u"Sound removed as remix source",
                    "sounds/email_remix_update.txt",
                    {"source": source, "action": "removed", "remix": self.sound},
                    None,
                    source.user.email,
                )
            except Sound.DoesNotExist:
                pass
            except Exception, e:
                # Report any other type of exception and fail silently
                print("Problem removing source from remix or sending mail: %s" % e)

def flag_user(request, username=None):
    if request.POST:
        flagged_user = User.objects.get(username__iexact=request.POST["username"])
        reporting_user = request.user
        object_id = request.POST["object_id"]
        if object_id:
            if request.POST["flag_type"] == "PM":
                flagged_object = Message.objects.get(id = object_id)
            elif request.POST["flag_type"] == "FP":
                flagged_object = Post.objects.get(id = object_id)
            elif request.POST["flag_type"] == "SC":
                flagged_object = Comment.objects.get(id = object_id)
            else:
                return HttpResponse(json.dumps({"errors":True}), mimetype='application/javascript')
        else:
            return HttpResponse(json.dumps({"errors":True}), mimetype='application/javascript')

        previous_reports_count = UserFlag.objects.filter(user__username=flagged_user.username)\
            .values('reporting_user').distinct().count()
        uflag = UserFlag(user=flagged_user, reporting_user=reporting_user, content_object=flagged_object)
        uflag.save()

        reports_count = UserFlag.objects.filter(user__username = flagged_user.username)\
            .values('reporting_user').distinct().count()
        if reports_count != previous_reports_count and \
                (reports_count == settings.USERFLAG_THRESHOLD_FOR_NOTIFICATION or
                 reports_count == settings.USERFLAG_THRESHOLD_FOR_AUTOMATIC_BLOCKING):

            # Get all flagged objects by the user, create links to admin pages and send email
            flagged_objects = UserFlag.objects.filter(user__username=flagged_user.username)
            urls = []
            added_objects = []
            for f_object in flagged_objects:
                key = str(f_object.content_type) + str(f_object.object_id)
                if key not in added_objects:
                    added_objects.append(key)
                    try:
                        obj = f_object.content_type.get_object_for_this_type(id=f_object.object_id)
                        url = reverse('admin:%s_%s_change' %
                                      (obj._meta.app_label,  obj._meta.module_name), args=[obj.id])
                        urls.append([str(f_object.content_type), request.build_absolute_uri(url)])
                    except Exception:
                        urls.append([str(f_object.content_type), "url not available"])
            user_url = reverse('admin:%s_%s_delete' %
                               (flagged_user._meta.app_label, flagged_user._meta.module_name), args=[flagged_user.id])
            user_url = request.build_absolute_uri(user_url)
            clear_url = reverse("clear-flags-user", args=[flagged_user.username])
            clear_url = request.build_absolute_uri(clear_url)
            if reports_count < settings.USERFLAG_THRESHOLD_FOR_AUTOMATIC_BLOCKING:
                template_to_use = 'accounts/report_spammer_admins.txt'
            else:
                template_to_use = 'accounts/report_blocked_spammer_admins.txt'
            to_emails = []
            for mail in settings.ADMINS:
                to_emails.append(mail[1])
            send_mail_template(u'Spam report for user ' + flagged_user.username,
                               template_to_use, locals(), None, to_emails)
        return HttpResponse(json.dumps({"errors": None}), mimetype='application/javascript')
    else:
        return HttpResponse(json.dumps({"errors": True}), mimetype='application/javascript')

def contact(request):
    email_sent = False
    user = None
    
    if request.user.is_authenticated():
        user = request.user 

    if request.POST:
        form = ContactForm(request, request.POST)
        if form.is_valid():
            subject = u"[support] " + form.cleaned_data['subject']
            email_from = form.cleaned_data['your_email']
            message = form.cleaned_data['message']

            # append some useful admin information to the email:
            if not user:
                try:
                    user = User.objects.get(email__iexact=email_from)
                except User.DoesNotExist: #@UndefinedVariable
                    pass
            
            send_mail_template(subject, "support/email_support.txt", locals(), email_from)

            email_sent = True
    else:
        if user:
            form = ContactForm(request, initial={"your_email": user.email})
        else:
            form = ContactForm(request)

    return render_to_response('support/contact.html', locals(), context_instance=RequestContext(request))

def flag(request, username, sound_id):
    sound = get_object_or_404(Sound, user__username__iexact=username, id=sound_id, moderation_state="OK", processing_state="OK")

    user = None
    email = None
    if request.user.is_authenticated():
        user = request.user
        email = request.user.email

    if request.method == "POST":
        flag_form = FlagForm(request, request.POST)
        if flag_form.is_valid():
            flag = flag_form.save()
            flag.reporting_user=user
            flag.sound = sound
            flag.save()

            send_mail_template(u"[flag] flagged file", "sounds/email_flag.txt", dict(flag=flag), flag.email)

            return HttpResponseRedirect(sound.get_absolute_url())
    else:
        if user:
            flag_form = FlagForm(request,initial=dict(email=email))
        else:
            flag_form = FlagForm(request)

    return render_to_response('sounds/sound_flag.html', locals(), context_instance=RequestContext(request))

def sound(request, username, sound_id):
    try:
        sound = Sound.objects.select_related("license", "user", "user__profile", "pack", "remix_group").get(id=sound_id)
        if sound.user.username.lower() != username.lower():
            raise Http404
        user_is_owner = request.user.is_authenticated() and (
            sound.user == request.user
            or request.user.is_superuser
            or request.user.is_staff
            or Group.objects.get(name="moderators") in request.user.groups.all()
        )
        # If the user is authenticated and this file is his, don't worry about moderation_state and processing_state
        if user_is_owner:
            if sound.moderation_state != "OK":
                messages.add_message(request, messages.INFO, "Be advised, this file has <b>not been moderated</b> yet.")
            if sound.processing_state != "OK":
                messages.add_message(request, messages.INFO, "Be advised, this file has <b>not been processed</b> yet.")
        else:
            if sound.moderation_state != "OK" or sound.processing_state != "OK":
                raise Http404
    except Sound.DoesNotExist:  # @UndefinedVariable
        try:
            DeletedSound.objects.get(sound_id=sound_id)
            return render_to_response("sounds/deleted_sound.html", {}, context_instance=RequestContext(request))
        except DeletedSound.DoesNotExist:
            raise Http404

    tags = sound.tags.select_related("tag__name")

    if request.method == "POST":
        form = CommentForm(request, request.POST)
        if request.user.profile.is_blocked_for_spam_reports():
            messages.add_message(
                request,
                messages.INFO,
                "You're not allowed to post the comment because your account has been temporaly blocked after multiple spam reports",
            )
        else:
            if form.is_valid():
                comment_text = form.cleaned_data["comment"]
                sound.comments.add(Comment(content_object=sound, user=request.user, comment=comment_text))
                sound.num_comments = sound.num_comments + 1
                sound.save()
                try:
                    # send the user an email to notify him of the new comment!
                    logger.debug(
                        "Notifying user %s of a new comment by %s" % (sound.user.username, request.user.username)
                    )
                    send_mail_template(
                        u"You have a new comment.",
                        "sounds/email_new_comment.txt",
                        {"sound": sound, "user": request.user, "comment": comment_text},
                        None,
                        sound.user.email,
                    )
                except Exception, e:
                    # if the email sending fails, ignore...
                    logger.error("Problem sending email to '%s' about new comment: %s" % (request.user.email, e))

                return HttpResponseRedirect(sound.get_absolute_url())

def contact(request):
    email_sent = False
    user = None
    
    if request.user.is_authenticated():
        user = request.user 

    if request.POST:
        form = ContactForm(request, request.POST)
        if form.is_valid():
            subject = u"[support] " + form.cleaned_data['subject']
            email_from = settings.DEFAULT_FROM_EMAIL
            message = form.cleaned_data['message']
            # append some useful admin information to the email:
            if not user:
                try:
                    user = User.objects.get(email__iexact=form.cleaned_data['your_email'])
                except User.DoesNotExist:
                    pass
            send_mail_template(subject, "support/email_support.txt", locals(), email_from,
                               reply_to=form.cleaned_data['your_email'])
            email_sent = True
    else:
        if user:
            form = ContactForm(request, initial={"your_email": user.email})
        else:
            form = ContactForm(request)
    tvars = {'form': form, 'email_sent': email_sent}
    return render(request, 'support/contact.html', tvars)

    def save(self):
        #print "before save", ",".join([str(source.id) for source in self.sound.sources.all()])

        new_sources = self.cleaned_data['sources']

        old_sources = set(source["id"] for source in self.sound.sources.all().values("id"))

        try:
            new_sources.remove(self.sound.id) # stop the universe from collapsing :-D
        except KeyError:
            pass

        for id in old_sources - new_sources: # in old but not in new
            try:
                source = Sound.objects.get(id=id)
                self.sound.sources.remove(source)
                
                # modify remix_group
                
                
                send_mail_template(
                    u'Sound removed as remix source', 'sounds/email_remix_update.txt',
                    {'source': source, 'action': 'removed', 'remix': self.sound},
                    None, source.user.email
                )
            except Sound.DoesNotExist:
                pass
            except Exception, e:
                # Report any other type of exception and fail silently
                print ("Problem removing source from remix or sending mail: %s" \
                     % e)

def send_activation(user):
    uid_hash = create_hash(user.id)
    username = user.username
    tvars = {
        'user': user,
        'username': username,
        'hash': uid_hash
    }
    send_mail_template(u'activation link.', 'accounts/email_activation.txt', tvars, None, user.email)

def _save_donation(encoded_data, email, amount, currency, transaction_id, source):
    extra_data = json.loads(base64.b64decode(encoded_data))
    campaign = DonationCampaign.objects.get(id=extra_data['campaign_id'])
    is_anonymous = False
    user = None
    user_id = None
    display_name = None

    if 'user_id' in extra_data:
        user = User.objects.get(id=extra_data['user_id'])
        user_id = user.id
        email = user.profile.get_email_for_delivery()
        # Reset the reminder flag to False so that in a year time user is reminded to donate
        user.profile.donations_reminder_email_sent = False
        user.profile.save()

    if 'name' in extra_data:
        is_anonymous = True
        display_name = extra_data['name']

    donation_data = {
        'email': email,
        'display_name': display_name,
        'amount': amount,
        'currency': currency,
        'display_amount': extra_data['display_amount'],
        'is_anonymous': is_anonymous,
        'user': user,
        'campaign': campaign,
        'source': source
    }
    donation, created = Donation.objects.get_or_create(transaction_id=transaction_id, defaults=donation_data)

    if created:
        email_to = None if user is not None else email
        send_mail_template(
                u'Thanks for your donation!',
                'donations/email_donation.txt', {
                    'user': user,
                    'amount': amount,
                    'display_name': display_name
                    }, user_to=user, email_to=email_to)

        log_data = donation_data
        log_data.update({'user_id': user_id})
        log_data.update({'created': str(donation.created)})
        del log_data['user']  # Don't want to serialize user
        del log_data['campaign']  # Don't want to serialize campaign
        log_data['amount_float'] = float(log_data['amount'])
        logger.info('Recevied donation (%s)' % json.dumps(log_data))
    return True

def username_reminder(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect(reverse("accounts-home"))

    if request.method == "POST":
        form = UsernameReminderForm(request.POST)
        if form.is_valid():
            user = form.cleaned_data["user"]
            send_mail_template(u'username reminder.', 'accounts/email_username_reminder.txt', dict(user=user), None, user.email)

            return render_to_response('accounts/username_reminder.html', dict(form=form, sent=True), context_instance=RequestContext(request))
    else:
        form = UsernameReminderForm()

    return render_to_response('accounts/username_reminder.html', dict(form=form, sent=False), context_instance=RequestContext(request))

def username_reminder(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect(reverse('accounts-home'))

    if request.method == 'POST':
        form = UsernameReminderForm(request.POST)
        if form.is_valid():
            user = form.cleaned_data['user']
            send_mail_template(u'username reminder.', 'accounts/email_username_reminder.txt', {'user': user},
                               None, user.email)

            return render(request, 'accounts/username_reminder.html', {'form': form, 'sent': True})
    else:
        form = UsernameReminderForm()

    return render(request, 'accounts/username_reminder.html', {'form': form, 'sent': False})

def username_reminder(request):
    if request.user.is_authenticated():
        return HttpResponseRedirect(reverse("accounts-home"))

    if request.method == "POST":
        form = UsernameReminderForm(request.POST)
        if form.is_valid():
            user = form.cleaned_data["user"]
            send_mail_template(
                u"username reminder.", "accounts/email_username_reminder.txt", {"user": user}, None, user.email
            )

            return render(request, "accounts/username_reminder.html", {"form": form, "sent": True})
    else:
        form = UsernameReminderForm()

    return render(request, "accounts/username_reminder.html", {"form": form, "sent": False})

 def send_notification_emails(self, notification_type, sender_moderator):
     # send message to assigned moderator
     if sender_moderator in [Ticket.MODERATOR_ONLY, Ticket.USER_AND_MODERATOR]:
         if self.assignee:
             tvars = {'ticket': self,
                      'user_to': self.assignee}
             send_mail_template(u'A freesound moderator handled your upload.',
                                notification_type,
                                tvars,
                                user_to=self.assignee)
     # send message to user
     if sender_moderator in [Ticket.USER_ONLY, Ticket.USER_AND_MODERATOR]:
         if self.sender:
             tvars = {'ticket': self,
                      'user_to': self.sender}
             send_mail_template(u'A freesound moderator handled your upload.',
                                notification_type,
                                tvars,
                                user_to=self.sender)

    def save(self):
        new_sources = self.cleaned_data['sources']
        old_sources = set(source["id"] for source in self.sound.sources.all().values("id"))
        try:
            new_sources.remove(self.sound.id)  # stop the universe from collapsing :-D
        except KeyError:
            pass

        for sid in old_sources - new_sources:  # in old but not in new
            try:
                source = Sound.objects.get(id=sid)
                self.sound.sources.remove(source)

                source.invalidate_template_caches()

                # modify remix_group
                send_mail_template(
                    u'Sound removed as remix source', 'sounds/email_remix_update.txt',
                    {'source': source, 'action': 'removed', 'remix': self.sound},
                    user_to=source.user
                )
            except Sound.DoesNotExist:
                pass
            except Exception as e:
                # Report any other type of exception and fail silently
                print ("Problem removing source from remix or sending mail: %s" % e)

        for sid in new_sources - old_sources:  # in new but not in old
            source = Sound.objects.get(id=sid)

            source.invalidate_template_caches()

            self.sound.sources.add(source)
            try:
                send_mail_template(
                    u'Sound added as remix source', 'sounds/email_remix_update.txt',
                    {'source': source, 'action': 'added', 'remix': self.sound},
                    user_to=source.user
                )
            except Exception as e:
                # Report any exception but fail silently
                print ("Problem sending mail about source added to remix: %s" % e)

 def send_notification_emails(self, notification_type, sender_moderator):
     ticket = self
     send_to = []
     #send message to assigned moderator
     if sender_moderator in [Ticket.MODERATOR_ONLY, Ticket.USER_AND_MODERATOR]:
         if self.assignee:
             user_to = self.assignee if self.assignee else False
             send_mail_template(u'A freesound moderator handled your upload.',
                                notification_type,
                                locals(),
                                '[email protected]',
                                self.assignee.email)
     # send message to user
     if sender_moderator in [Ticket.USER_ONLY, Ticket.USER_AND_MODERATOR]:
         user_to = self.sender if self.sender else False
         email_to = user_to.email if user_to else ticket.sender_email
         if self.sender:
             send_mail_template(u'A freesound moderator handled your upload.',
                                notification_type,
                                locals(),
                                '[email protected]',
                                email_to)

def send_activation(user):
    uid_hash = create_hash(user.id)
    username = user.username
    tvars = {"user": user, "username": username, "hash": uid_hash}
    send_mail_template(u"activation link.", "accounts/email_activation.txt", tvars, None, user.email)

def send_activation2(user):
    hash = create_hash(user.id)
    username = user.username
    send_mail_template(u'activation link.', 'accounts/email_activation2.txt', locals(), None, user.email)

def send_activation(user):
    encrypted_user_id = encrypt(str(user.id))
    username = user.username
    send_mail_template(u'activation link.', 'accounts/email_activation.txt', locals(), None, user.email)

def sound(request, username, sound_id):
    try:
        sound = Sound.objects.select_related("license", "user", "user__profile", "pack").get(id=sound_id, user__username=username)
        user_is_owner = request.user.is_authenticated and \
            (sound.user == request.user or request.user.is_superuser or request.user.is_staff or
             Group.objects.get(name='moderators') in request.user.groups.all())
        # If the user is authenticated and this file is his, don't worry about moderation_state and processing_state
        if user_is_owner:
            if sound.moderation_state != "OK":
                messages.add_message(request, messages.INFO, 'Be advised, this file has <b>not been moderated</b> yet.')
            if sound.processing_state != "OK":
                messages.add_message(request, messages.INFO, 'Be advised, this file has <b>not been processed</b> yet.')
        else:
            if sound.moderation_state != 'OK' or sound.processing_state != 'OK':
                raise Http404
    except Sound.DoesNotExist:
        if DeletedSound.objects.filter(sound_id=sound_id).exists():
            return render(request, 'sounds/deleted_sound.html')
        else:
            raise Http404

    if request.method == "POST":
        form = CommentForm(request, request.POST)
        if request.user.is_authenticated:
            if request.user.profile.is_blocked_for_spam_reports():
                messages.add_message(request, messages.INFO, "You're not allowed to post the comment because your account "
                                                             "has been temporaly blocked after multiple spam reports")
            else:
                if form.is_valid():
                    comment_text = form.cleaned_data["comment"]
                    sound.add_comment(request.user, comment_text)
                    sound.invalidate_template_caches()
                    try:
                        if sound.user.profile.email_not_disabled("new_comment"):
                            # Send the user an email to notify him of the new comment!
                            logger.info("Notifying user %s of a new comment by %s" % (sound.user.username,
                                                                                      request.user.username))
                            send_mail_template(u'You have a new comment.', 'sounds/email_new_comment.txt',
                                               {'sound': sound, 'user': request.user, 'comment': comment_text},
                                               user_to=sound.user)
                    except Exception as e:
                        # If the email sending fails, ignore...
                        logger.error("Problem sending email to '%s' about new comment: %s" % (request.user.username, e))

                    return HttpResponseRedirect(sound.get_absolute_url())
    else:
        form = CommentForm(request)

    qs = Comment.objects.select_related("user", "user__profile")\
        .filter(sound_id=sound_id)
    display_random_link = request.GET.get('random_browsing', False)
    is_following = False
    if request.user.is_authenticated:
        users_following = follow_utils.get_users_following(request.user)
        if sound.user in users_following:
            is_following = True
    is_explicit = sound.is_explicit and (not request.user.is_authenticated or not request.user.profile.is_adult)

    tvars = {
        'sound': sound,
        'username': username,
        'form': form,
        'display_random_link': display_random_link,
        'is_following': is_following,
        'is_explicit': is_explicit,  # if the sound should be shown blurred, already checks for adult profile
        'sizes': settings.IFRAME_PLAYER_SIZE,
    }
    tvars.update(paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE))
    return render(request, 'sounds/sound.html', tvars)

def new_message(request, username=None, message_id=None):
    
    if request.method == 'POST':

        if request.user.profile.num_sounds:
            form = MessageReplyFormNoCaptcha(request.POST)
        else:
            form = MessageReplyForm(request.POST)

        if request.user.profile.is_blocked_for_spam_reports():
            messages.add_message(request, messages.INFO, "You're not allowed to send the message because your account has been temporaly blocked after multiple spam reports")
        else:
            if form.is_valid():
                user_from = request.user
                user_to = form.cleaned_data["to"]
                subject = form.cleaned_data["subject"]
                body = MessageBody.objects.create(body=form.cleaned_data["body"])

                Message.objects.create(user_from=user_from, user_to=user_to, subject=subject, body=body, is_sent=True, is_archived=False, is_read=False)
                Message.objects.create(user_from=user_from, user_to=user_to, subject=subject, body=body, is_sent=False, is_archived=False, is_read=False)

                invalidate_template_cache("user_header", user_to.id)

                try:
                    # send the user an email to notify him of the sent message!
                    send_mail_template(u'you have a private message.', 'messages/email_new_message.txt', locals(), None, user_to.email)
                except:
                    # if the email sending fails, ignore...
                    pass

                return HttpResponseRedirect(reverse("messages"))
    else:
        if request.user.profile.num_sounds:
            form = MessageReplyFormNoCaptcha()
        else:
            form = MessageReplyForm()

        if message_id:
            try:
                message = Message.objects.get(id=message_id)

                if message.user_from != request.user and message.user_to != request.user:
                    raise Http404
                
                body = message.body.body.replace("\r\n", "\n").replace("\r", "\n")
                body = ''.join(BeautifulSoup(body).findAll(text=True))
                body = "\n".join([(">" if line.startswith(">") else "> ") + "\n> ".join(wrap(line.strip(),60)) for line in body.split("\n")])
                body = "> --- " + message.user_from.username + " wrote:\n>\n" + body
                
                subject = "re: " + message.subject
                to = message.user_from.username

                if request.user.profile.num_sounds:
                    form = MessageReplyFormNoCaptcha(initial=dict(to=to, subject=subject, body=body))
                else:
                    form = MessageReplyForm(initial=dict(to=to, subject=subject, body=body))
            except Message.DoesNotExist:
                pass
        elif username:
            if request.user.profile.num_sounds:
                form = MessageReplyFormNoCaptcha(initial=dict(to=username))
            else:
                form = MessageReplyForm(initial=dict(to=username))
    
    return render_to_response('messages/new.html', locals(), context_instance=RequestContext(request))