def delete_old_avatar(sender, instance, **kwargs):
    if instance.avatar:
        if not str(instance.avatar).startswith('avatars'):
            user = instance.user
            profile = user.get_profile()
            if profile.avatar:
                delete(profile.avatar)

def termination(request):
    form = TerminationForm()
    if request.method == "POST":
        form = TerminationForm(request.POST)
        if form.is_valid():
            person = Person.objects.get(username=request.user)
            board = Board.objects.filter(user=request.user)
            picture = Picture.objects.filter(board=board)
            for p in picture:
                delete(p.image)
                p.delete()
            for b in board:
                b.delete()
            friend = Friend.objects.friends(person)
            for f in friend:
                Friend.objects.remove_friend(person, f)
            following = Follow.objects.following(request.user)
            for f in following:
                Follow.objects.remove_follower(person, f)
            for f in following:
                Follow.objects.remove_follower(person, f)
            requests = Friend.objects.unread_requests(user=request.user)
            for f in requests:
                f.delete()
            person.is_active = False
            person.email = None
            person.date_of_birth = None
            person.image.delete()
            person.save()
            return HttpResponseRedirect(reverse('world:logout_request'))
    return render(request, 'termination.html', {'form': form})

    def _clear_thumbnails(self):
        """ Actual code to clear the thumbnails.  Private.
        """

        delete(self.image, delete_file=False)
        self.thumbs_created = False
        self.save()

	def delete(self, request, *args, **kwargs):
		self.object = self.get_object()
		user = request.user
		blog_posts = BlogPost.objects.published(for_user=user).select_related().filter(user=user)

		if blog_posts and blog_posts[0]:
			blog_post = blog_posts[0]
			blog_post.num_images = blog_post.num_images - self.object.images.all().count()
			blog_post.save()

		for image in self.object.images.all():
			delete(image.image)
			content_type_id = ContentType.objects.get_for_model(image).pk
			deleteObject(request, content_type_id, image.pk)
			

		media_root = getattr(settings, 'MEDIA_ROOT', '/')
		album_dir = self.object.get_album_path()
		album_abs_dir = os.path.join(media_root, album_dir)
		os.rmdir(album_abs_dir)
		
		content_type_id = ContentType.objects.get_for_model(self.object).pk
		deleteObject(request, content_type_id, self.object.pk)
		
		return HttpResponseRedirect(self.get_success_url())

 def delete_thumbnails(self, source):
     from sorl.thumbnail import delete
     from sorl.thumbnail.helpers import ThumbnailError
     try:
         delete(source)
     except ThumbnailError:
         pass

 def _delete_thumbnail(self, sender, instance=None, delete_file=True,
         **kwargs):
     image = getattr(instance, self.attname)
     if hasattr(image, 'path'):
         # Use sorl.thumbnail.delete to delete thumbnail
         # Key Value Store references, cached files and optionally
         # the source image file
         thumbnail.delete(image.path, delete_file)

    def delete(self):
        # deleting the associated file
        # trying sorl before file system
        try:
            from sorl.thumbnail import delete

            delete(self.file.file)
        except:
            os.remove(self.file.path)

        super(SFFile, self).delete()

def delete_image_files(sender, instance, **kwargs):
    """
    Deletes the original image, created thumbnails, and any entries
    in sorl's key-value store.
    """
    image_fields = (models.ImageField, thumbnail.ImageField)
    for field in instance._meta.fields:
        if isinstance(field, image_fields):
            # Make Django return ImageFieldFile instead of ImageField
            fieldfile = getattr(instance, field.name)
            thumbnail.delete(fieldfile)

 def crop(self, x=None, y=None, x2=None, y2=None):
     if not all((x, y, x2, y2)):
         raise ValueError('All points are required')
     file_name = self.raw_image.name
     im = Image.open(self.raw_image.file)
     cropped = im.copy()
     cropped = cropped.crop((x, y, x2, y2))
     new_file = StringIO()
     cropped.save(new_file, 'jpeg')
     file_content = ContentFile(new_file.getvalue())
     self.image.save(file_name, file_content)
     delete(self.image, delete_file=False)

def delete_images(sender, **kwargs):
    u"""Удаление изображений при удалении объявления."""
    instance   = kwargs['instance']
    all_images = [instance.image_1, instance.image_2,instance.image_3,
                  instance.image_4]
    
    for image in all_images:
        if image:
            try:
                thumbnail.delete(image)
            except IOError as e:
                logger.error(u'Не удалось удалить изображение: {0}'.format(e))

    def clean_thumbnails(self):
        Thumbnail.objects.filter(media=self).delete()
        try:
            delete(self.original_file.file, delete_file=False)
        except (IOError, ValueError):
            pass

        try:
            if self.custom_file:
                delete(self.custom_file.file, delete_file=False)
        except (IOError, ValueError):
            pass

 def save(self, *args, **kwargs):
     if not self.id:
         # Have to save the image (and imagefield) first
         super(BaseImage, self).save(*args, **kwargs)
         # obj is being created for the first time - resize
         quality = getattr(settings, 'IMAGESTORE_IMAGE_QUALITY', 95)
         resized = get_thumbnail(self.image, "1000x1000", quality=quality)
         # Delete the original image and reassign the resized image to the image field
         self.image.delete()
         self.image.save(resized.name, ContentFile(resized.read()), True)
         delete(resized)
     super(BaseImage, self).save(*args, **kwargs)

    def save(self, *args, **kwargs):
        """
        Override default save operation.

        Username will be swapped with email.
        """
        self.username = self.email

        if self.previous_avatar and self.avatar != self.previous_avatar:
            delete(self.previous_avatar)
            self.previous_avatar = None

        super(User, self).save(*args, **kwargs)

def cat_album_thumb(request, album_id, thumb_size=250):
    a = CatAlbum.objects.filter(pk=album_id).first()
    random_image = a.photos.order_by('?').first()
    thumb_str = str(thumb_size) + 'x' + str(thumb_size)
    im = get_thumbnail(random_image.image, thumb_str, upscale=False)
    try:
        content = im.read()
    except IOError:
        delete(im)
        im = get_thumbnail(random_image.image, thumb_str, upscale=False)
        content = im.read()
    response = HttpResponse(content, content_type='image/jpg')
    response['Content-Length'] = len(content)

    return response

def cat_photo(request, photo_id=None, thumb_size=600, slug=None):
    p = get_object_or_404(CatPhoto, id=photo_id)
    thumb_str = str(thumb_size) + 'x' + str(thumb_size)
    im = get_thumbnail(p.image, thumb_str, upscale=False)
    try:
        content = im.read()
    except IOError:
        delete(im)
        im = get_thumbnail(p.image, thumb_str, upscale=False)
        content = im.read()

    response = HttpResponse(content, content_type='image/jpg')
    response['Content-Length'] = len(content)

    return response

def upload_photo(request, eb_id=None, id=None):
    if id:
        attendee = get_object_or_404(Attendee, id=id)
    elif eb_id:
        attendee = get_object_or_404(Attendee, eb_id=eb_id)
    else:
        raise Exception("missing parameter")
    photo = request.FILES['photo']
    if not photo:
        return HttpResponseBadRequest("missing photo")
    if attendee.photo:
        thumbnail.delete(attendee.photo.name, delete_file=False)
    attendee.photo.save(photo.name, photo)
    photo_url = attendee.photo.url
    return HttpResponse(json.dumps({
        'eb_id': attendee.eb_id,
        'id': attendee.id,
        'first_name': attendee.first_name,
        'last_name': attendee.last_name,
        'photo': photo_url}), mimetype='application/json')

    def test_delete(self):
        im1 = Item.objects.get(image='100x100.jpg').image
        im2 = Item.objects.get(image='500x500.jpg').image
        default.kvstore.get_or_set(ImageFile(im1))
        # exists in kvstore and in storage 
        self.assertTrue(bool(default.kvstore.get(ImageFile(im1))))
        self.assertTrue(ImageFile(im1).exists())
        # delete
        delete(im1)
        self.assertFalse(bool(default.kvstore.get(ImageFile(im1))))
        self.assertFalse(ImageFile(im1).exists())

        default.kvstore.get_or_set(ImageFile(im2))
        # exists in kvstore and in storage 
        self.assertTrue(bool(default.kvstore.get(ImageFile(im2))))
        self.assertTrue(ImageFile(im2).exists())
        # delete
        delete(im2, delete_file=False)
        self.assertFalse(bool(default.kvstore.get(ImageFile(im2))))
        self.assertTrue(ImageFile(im2).exists())

 def rotate(self, rotate_angle):
     """
     Make sure we rotate both images.
     """
     if not self.raw_image:
         self.raw_image = self.image
         self.raw_image.save()
     for image_field in (
         # self.raw_image,
         self.image,
         ):
         file_name = image_field.name
         im = Image.open(image_field.file)
         rotated = im.copy()
         rotated = rotated.rotate(rotate_angle)
         new_file = StringIO()
         rotated.save(new_file, 'jpeg')
         file_content = ContentFile(new_file.getvalue())
         image_field.save(file_name, file_content)
         delete(self.image, delete_file=False)

def validate_resizable(image):
    """Check if image can't be resized with solr-thumbnail.
    Some resizing backend fail to resize specific images so check is needed

    """
    try:
        # if file is just uploaded then it's not saved. Save it to temp location
        data = image.file
        path = default_storage.save(
            'tmp/' + uuid1().hex, ContentFile(data.read()))
        temp_file = default_storage.open(path)
        get_thumbnail(temp_file, "100x100")
        temp_file.close()
        delete(temp_file)
    except Exception, msg:
        if settings.DEBUG:
            traceback.print_exc()
            raise ValidationError(u"Image is corrupted: %s" % msg)
        else:
            raise ValidationError(
                u"Image is corrupted and can't be resized by server.")

def add_watermark(main_folder, image_file, path_watermark, all_size={'x':0,'x2':100,'y':0,'y2':100},opacity=0.5):
    if all_size['x']=="" or all_size['x2']=="" or all_size['y']=="" \
        or all_size['y2']=="" or all_size['w_view']=="" or all_size['h_view']=="":
        return False

    path_to_folder = MEDIA_ROOT + main_folder
    result_file = WATERMARK_PREFIX + image_file
    path_watermark = MEDIA_ROOT + path_watermark

    if os.path.isfile(path_to_folder+image_file):
        shutil.copyfile(path_to_folder+image_file, path_to_folder+result_file)

        if os.path.isfile(path_to_folder+result_file):
            os.chmod(path_to_folder+result_file, 0755)
            result_file_path = path_to_folder+result_file

            # Открываем текущее изобразение изображение
            image = Image.open(result_file_path, 'r')

            w_orig = image.size[0]
            h_orig = image.size[1]
            w_koef = float(w_orig)/int(all_size['w_view'])
            h_koef = float(h_orig)/int(all_size['h_view'])

            x = int(int(all_size['x'])*w_koef)
            x2 = int(int(all_size['x2'])*w_koef)
            y = int(int(all_size['y'])*h_koef)
            y2 = int(int(all_size['y2'])*h_koef)
            w_watermark = x2 - x
            h_watermark = y2 - y

            if w_watermark!=0 and h_watermark!=0:
                watermark_size = str(w_watermark)+'x'+str(h_watermark)
                path_watermark = MEDIA_ROOT.replace('/media/','')+get_thumbnail(path_watermark, watermark_size,
                                                           crop='center', quality=99).url
                # Открываем водяной знак
                if os.path.isfile(path_watermark):
                    watermark = Image.open(path_watermark, 'r')
                    assert opacity >= 0 and opacity <= 1
                    if opacity < 1:
                        if watermark.mode != 'RGBA':
                            watermark = watermark.convert('RGBA')
                        else:
                            watermark = watermark.copy()
                        alpha = watermark.split()[3]
                        alpha = ImageEnhance.Brightness(alpha).enhance(opacity)
                        watermark.putalpha(alpha)

                    layer = Image.new('RGBA', image.size, (0,0,0,0))
                    layer.paste(watermark, (x, y))

                    Image.composite(layer,  image,  layer).save(result_file_path)
                    Image.composite(layer,  image,  layer).save(result_file_path)



                    # Delete the Key Value Store reference but **not** the file.
                    # Use this if you have changed the source
                    delete(main_folder + result_file, delete_file=False)

                    return result_file
    return False