root/trunk/djedna/catalog2/models.py

# (c) Copyright 2008 Thomas Bohmbach, Jr.
# 
# This file is part of DJ Edna.
# 
# DJ Edna is free software: you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
# 
# DJ Edna is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
# more details.
# 
# You should have received a copy of the GNU General Public License along with
# DJ Edna.  If not, see <http://www.gnu.org/licenses/>.

import datetime
import logging as log
import mimetypes
import os
import shutil
import StringIO
import time
import wave
import zipfile

from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.sites.models import Site
from django.contrib.sites.managers import CurrentSiteManager
from django.core.urlresolvers import reverse
from django.db import models
from django.dispatch import dispatcher
from django.template import defaultfilters
from django.utils.encoding import smart_unicode, smart_str, force_unicode
from django.utils.encoding import iri_to_uri
from django.utils.http import urlquote

from mutagen.mp3 import MP3

from PIL import Image

from sorl.thumbnail.main import DjangoThumbnail

from djedna import mediaserver
from djedna.catalog2.signals import trackfileupload_update
from djedna.catalog2.signals import imagefileupload_update
from djedna.catalog2.signals import trackfile_update
from djedna.catalog2.signals import track_update, album_update


mimetypes.init()
MP3_EXT = '.mp3'
WAV_EXT = '.wav'
MP3_MIMETYPE = mimetypes.types_map[MP3_EXT]
WAV_MIMETYPE = mimetypes.types_map[WAV_EXT]
TRACKFILE_REGEX = '^.+(\%s|\%s)$' % (MP3_EXT, WAV_EXT)
PNG_EXT = '.png'
JPG_EXT = '.jpg'
GIF_EXT = '.gif'
PNG_MIMETYPE = mimetypes.types_map[PNG_EXT]
JPG_MIMETYPE = mimetypes.types_map[JPG_EXT]
GIF_MIMETYPE = mimetypes.types_map[GIF_EXT]
IMAGEFILE_REGEX = '^.+(\%s|\%s|\%s)$' % (PNG_EXT, JPG_EXT, GIF_EXT)

def pathwalk(path):
    if os.path.isdir(path):
        for f in os.listdir(path):
            newpath = os.path.join(path, f)
            for x in pathwalk(newpath):
                yield x
    else:
        yield path

def is_mimetype(path, mimetype):
    dirpath, filename = os.path.split(path)
    if not filename or filename[0] == '.':
        return False
    path_mimetype, encoding = mimetypes.guess_type(path)
    return mimetype == path_mimetype

def get_group_hash():
    count = 1
    while count:
        group_hash = User.objects.make_random_password(
            allowed_chars='BCDFGHJKLMNPQRSTVWXYZ123456789'
        )
        count = TrackFile.objects.filter(group_hash=group_hash).count()
    return group_hash

def slugify(value):
    return str(defaultfilters.slugify(value))


class PublishableManager(models.Manager):
    def get_published_q(self, now=None):
        if not now:
            now = datetime.datetime.now()
        published_q = \
            models.Q(publish__isnull=True) | \
            models.Q(publish__lte=now)
        not_expired_q = \
            models.Q(expire__isnull=True) | \
            models.Q(expire__gte=now)
        return published_q & not_expired_q
    
    def get_active_q(self, now=None):
        return models.Q(active=True) & self.get_published_q(now=now)
    
    def get_site_q(self, site_id=None):
        if site_id == None:
            site_id = settings.SITE_ID
        return models.Q(sites__id__exact=site_id)
    
    def get_active_site_q(self, now=None, site_id=None):
        return self.get_active_q(now=now) & self.get_site_q(site_id=site_id)
    
    def get_active_query_set(self, now=None):
        return self.get_query_set().filter(self.get_active_q(now=now))
    active = property(get_active_query_set)
    
    def get_inactive_query_set(self, now=None):
        return self.get_query_set().exclude(self.get_active_q(now=now))
    inactive = property(get_inactive_query_set)
    
    def get_site_query_set(self, site_id=None):
        return self.get_query_set().filter(self.get_site_q(site_id=site_id))
    on_site = property(get_site_query_set)
    
    def get_active_site_query_set(self, now=None, site_id=None):
        return self.get_query_set().filter(
            self.get_active_site_q(now=now, site_id=site_id)
        )
    active_on_site = property(get_active_site_query_set)
    
    def get_inactive_site_query_set(self, now=None, site_id=None):
        return self.get_query_set().exclude(
            self.get_active_site_q(now=now, site_id=site_id)
        )
    inactive_on_site = property(get_inactive_site_query_set)
    

class Publishable(models.Model):
    active = models.BooleanField(default=True, blank=True)
    publish = models.DateTimeField(null=True, blank=True)
    expire = models.DateTimeField(null=True, blank=True)
    added = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    sites = models.ManyToManyField(Site)
    
    class Meta:
        abstract = True
    
    def is_active(self, now=None):
        active = self.active
        if active:
            if not now:
                now = datetime.datetime.now()
            published = True
            if self.publish and self.publish > now:
                published = False
            if published and self.expire and self.expire < now:
                published = False
            active = published
        return active
    


class MediaFileManager(PublishableManager):
    def get_or_create_from_path(
            self, path, sites=None, import_path=None, defaults={}
        ):
        media_relative_path = None
        relative_path, absolute_path = mediaserver.media_paths(path)
        if not relative_path:
            import_path = import_path or os.path.join(
                'imported', '%Y', '%m', '%d'
            )
            filename = os.path.basename(path)
            media_relative_path = os.path.join(import_path, filename)
            media_relative_path = os.path.normpath(
                force_unicode(datetime.datetime.now().strftime(
                    smart_str(media_relative_path))
                )
            )
            relative_path = mediaserver.put_file(path, media_relative_path)
        mediafile, created = self.get_or_create(
            relative_path=relative_path,
            defaults=defaults
        )
        if created:
            if not media_relative_path:
                mediaserver.put_file(relative_path)
            if sites:
                mediafile.sites.add(*sites)
        return (mediafile, created)
    
    def get_in_path(self, path):
        relative_path, absolute_path = mediaserver.media_paths(path)
        if not (relative_path and os.path.exists(absolute_path)):
            return self.none()
        return self.filter(relative_path__startswith=relative_path)
    
    def by_mimetype(self, mimetype):
        return self.get_query_set().filter(mimetype=mimetype)
    

class MediaFile(Publishable):
    relative_path = models.CharField(max_length=1000, core=True, unique=True)
    mimetype = models.CharField(max_length=256, default='', blank=True)
    file_modified = models.DateTimeField(null=True, blank=True)
    group_hash = models.CharField(max_length=256, default='', blank=True)
    
    class Meta:
        abstract = True
    
    def __unicode__(self):
        return u"%s: %s" % (self.mimetype, self.relative_path)
    
    def get_media_url(self, user=None, query_auth=None, expires_in=None):
        return mediaserver.get_url(
            self.relative_path,
            query_auth=query_auth,
            expires_in=expires_in,
            user=user
        )
    
    def _get_path(self):
        relative_path, absolute_path = mediaserver.media_paths(
            self.relative_path
        )
        return absolute_path
    path = property(_get_path)
    
    def _get_relative_dirpath(self):
        dirpath, filename = os.path.split(self.relative_path)
        return dirpath
    relative_dirpath = property(_get_relative_dirpath)
    
    def _get_filename(self):
        dirpath, filename = os.path.split(self.relative_path)
        return filename
    filename = property(_get_filename)
    
    def _get_filename_root(self):
        file_root, ext = os.path.splitext(self.filename)
        return file_root
    filename_root = property(_get_filename_root)
    
    def _get_file_modified_datetime(self):
        file_mod_date = None
        if self.file_exists():
            file_mod = os.path.getmtime(self.path)
            file_mod_date = datetime.datetime.fromtimestamp(file_mod)
        return file_mod_date
    
    def _get_file_mimetype(self):
        mimetype = None
        if self.file_exists():
            mimetype, encoding = mimetypes.guess_type(self.path)
        return mimetype
    file_mimetype = property(_get_file_mimetype)
    
    def file_exists(self):
        return mediaserver.media_exists(self.relative_path)
    
    def update(self, group_hash=None, force_update=False):
        needs_update = force_update
        if self.active and not self.file_exists():
            needs_update = True
        file_modified = self._get_file_modified_datetime()
        if file_modified:
            if not self.file_modified or file_modified > self.file_modified:
                needs_update = True
        if needs_update:
            if group_hash:
                self.group_hash = group_hash
            self.save()
        return needs_update
    
    def save(self):
        create = not self.id
        self.file_modified = self._get_file_modified_datetime()
        self.mimetype = self.file_mimetype or ''
        if not self.file_exists():
            self.active = False
        super(MediaFile, self).save()
        if create and not self.sites.count():
            self.sites.add(Site.objects.get_current())
    
    def delete(self, remove_file=False):
        relative_path = self.relative_path
        super(MediaFile, self).delete()
        if remove_file and relative_path:
            mediaserver.remove(relative_path)
    

class MediaFileUpload(models.Model):
    """
    Subclasses should specify a FileField or ImageField called
        'uploaded_file'.  For example:
    
    uploaded_file = models.FileField(
        upload_to=os.path.join('uploaded', '%Y', '%m', '%d')
    )
    
        or
    
    uploaded_file = models.ImageField(
        upload_to=os.path.join('uploaded', '%Y', '%m', '%d')
    )
    """
    user = models.ForeignKey(
        User,
        blank=True,
        null=True,
        related_name='%(class)ss'
    )
    added = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    
    class Meta:
        abstract = True
    
    def __unicode__(self):
        return u"%s" % self.get_uploaded_file_filename()
    
    def delete(self):
        path = self.get_uploaded_file_filename()
        media_path = path[len(settings.MEDIA_ROOT):]
        super(MediaFileUpload, self).delete()
        mediaserver.remove(media_path)
    


class TrackFileManager(MediaFileManager):
    def is_mp3(self, path):
        return is_mimetype(path, MP3_MIMETYPE)
    
    def is_wav(self, path):
        return is_mimetype(path, WAV_MIMETYPE)
    
    def is_music_file(self, path):
        return self.is_mp3(path) or self.is_wav(path)
    
    def get_or_create_from_path(
            self, path, create_track=True, sites=None, import_path=None
        ):
        import_path = import_path or os.path.join(
            settings.FILE_DIRNAME, 'imported', '%Y', '%m', '%d'
        )
        trackfile, created = \
            super(TrackFileManager, self).get_or_create_from_path(
                path,
                sites=sites,
                import_path=import_path
            )
        if created and create_track:
            track, track_created = \
                Track.objects.get_or_create_from_trackfile(trackfile)
            trackfile.track = track
            trackfile.save()
        return (trackfile, created)
    
    def add_from_path(
            self, path, create_track=True, sites=None, import_path=None
        ):
        added_hash = None
        group_hash = get_group_hash()
        relative_path, absolute_path = mediaserver.media_paths(path)
        if absolute_path:
            for f in pathwalk(absolute_path):
                if self.is_music_file(f):
                    trackfile, created = self.get_or_create_from_path(
                        f,
                        create_track=create_track,
                        sites=sites,
                        import_path=import_path
                    )
                    if created:
                        added_hash = group_hash
                        trackfile.group_hash = group_hash
                        trackfile.save()
        return added_hash
    
    def update_in_path(self, path):
        updated_hash = None
        group_hash = get_group_hash()
        trackfiles = self.get_in_path(path)
        for trackfile in trackfiles:
            if trackfile.update(group_hash):
                updated_hash = group_hash
        return updated_hash
    
    def _get_mp3s(self):
        return self.by_mimetype(mimetype=MP3_MIMETYPE)
    mp3s = property(_get_mp3s)
    
    def _get_wavs(self):
        return self.by_mimetype(mimetype=WAV_MIMETYPE)
    wavs = property(_get_wavs)
    

class TrackFileCurrentSiteManager(CurrentSiteManager, TrackFileManager):
    pass

class TrackFile(MediaFile):
    quality = models.CharField(max_length=256, default='', blank=True)
    extracted_image = models.ForeignKey(
        'ImageFile', null=True, blank=True,
        related_name='trackfile_extracted', editable=False
    )
    image_override = models.ForeignKey(
        'ImageFile', null=True, blank=True,
        related_name='trackfile_overrides', edit_inline=models.TABULAR
    )
    track = models.ForeignKey(
        'Track', null=True, blank=True, related_name='trackfiles',
        edit_inline=models.TABULAR
    )
    
    objects = TrackFileManager()
    on_site = TrackFileCurrentSiteManager(field_name='sites')
    
    class Meta:
        ordering = ['relative_path',]
    
    class Admin:
        search_fields = ['relative_path',]
        list_display = ['id',
                        'relative_path',
                        'mimetype',
                        'file_modified',
                        'added',
                        'updated',]
        list_filter = ['file_modified',]
    
    def __unicode__(self):
        info = self.info
        return "%s / %s / %s / %s / %s" % (
            info['title'],
            info['album_title'],
            info['artist_name'],
            info['quality'],
            self.filename
        )
    
    def get_absolute_url(self):
        return reverse(
            'djedna_trackfile_detail',
            kwargs={'trackfile_id' : self.id}
        )
    
    def is_mp3(self):
        return self.mimetype == MP3_MIMETYPE
    
    def is_wav(self):
        return self.mimetype == WAV_MIMETYPE
    
    def _get_image(self):
        if self.image_override:
            return self.image_override
        else:
            return self.extracted_image
    image = property(_get_image)
    
    def _get_info_mp3(self):
        title = None
        artist_name = None
        album_title = None
        year = None
        number = None
        length = None
        quality = None
        cover_image = None
        try:
            mp3 = MP3(self.path)
        except:
            log.exception("Error getting info from '%s'" % self.path)
        else:
            titles = mp3.tags.getall('TIT2')
            if not titles:
                titles = mp3.tags.getall('TT2') #v2.2
            if titles:
                title = titles[0].text[0]
            artist_names = mp3.tags.getall('TPE1')
            if not artist_names:
                artist_names = mp3.tags.getall('TP1') #v2.2
            if artist_names:
                artist_name = artist_names[0].text[0]
            album_titles = mp3.tags.getall('TALB')
            if not album_titles:
                album_titles = mp3.tags.getall('TAL') #v2.2
            if album_titles:
                album_title = album_titles[0].text[0]
            try:
                years = mp3.tags.getall('TDRC')
                year = years[0].text[0].text
            except:
                try:
                    years = mp3.tags.getall('TYER')
                    year = years[0].text[0]
                except:
                    try:
                        years = mp3.tags.getall('TYE') #v2.2
                        year = years[0].text
                    except:
                        year = None
            tracks = mp3.tags.getall('TRCK')
            if not tracks:
                tracks = mp3.tags.getall('TT2') #v2.2
            if tracks:
                track = tracks[0].text[0].strip()
                try:
                    number = int(track)
                except:
                    try:
                        number = int(track[0:track.find('/')].strip())
                    except:
                        log.exception(
                            "Error trying to parse track '%s' from '%s'" %
                            (track, self.path)
                        )
            try:
                length = int(mp3.info.length)
            except:
                log.exception(
                    "Error getting length from '%s'" %
                    self.path
                )
            try:
                quality = "%skbps" % (mp3.info.bitrate / 1000)
            except:
                log.exception(
                    "Error getting quality (bitrate) from '%s'" %
                    self.path
                )
            pictures = mp3.tags.getall('APIC')
            if not pictures:
                pictures = mp3.tags.getall('PIC')
            if pictures:
                try:
                    picture_data = pictures[0].data
                    cover_image = Image.open(StringIO.StringIO(picture_data))
                except:
                    log.exception(
                        "Error getting cover image from '%s'" %
                        self.path
                    )
        return {'title': title,
                'artist_name' : artist_name,
                'album_title' : album_title,
                'year' : year,
                'number' : number,
                'length' : length,
                'quality' : quality,
                'cover_image' : cover_image}
    
    def _get_info_wav(self):
        length = None
        try:
            wav = wave.open(self.path)
            length = round(float(wav.getnframes()) /
                           float(wav.getframerate()))
        except:
            pass
        return {'title': None,
                'artist_name' : None,
                'album_title' : None,
                'year' : None,
                'number' : None,
                'length' : length,
                'quality' : 'lossless',
                'cover_image' : None}
    
    def _get_info(self):
        if self.file_exists():
            if self.is_mp3():
                return self._get_info_mp3()
            if self.is_wav():
                return self._get_info_wav()
        return {'title': None,
                'artist_name' : None,
                'album_title' : None,
                'year' : None,
                'number' : None,
                'length' : None,
                'quality' : None,
                'cover_image' : None}
    info = property(_get_info)
    
    def update(self, group_hash=None, force_update=False):
        needs_update = force_update
        try:
            relative_path, absolute_path = mediaserver.media_paths(
                self.trackfileupload.get_uploaded_file_filename()
            )
            if self.relative_path != relative_path:
                self.relative_path = relative_path
                needs_update = True
        except TrackFileUpload.DoesNotExist:
            pass
        return super(TrackFile, self).update(
            group_hash=group_hash,
            force_update=needs_update
        )
    
    def save(self):
        self.quality = self.info['quality'] or ''
        if not self.extracted_image:
            self.extracted_image, created = \
                ImageFile.objects.get_or_create_from_trackfile(self)
        super(TrackFile, self).save()
    
    def delete(self, remove_file=False):
        if self.extracted_image:
            self.extracted_image.delete(remove_file=True)
            self.extracted_image = None
        super(TrackFile, self).delete(remove_file=remove_file)
    
# Call track.update() (via trackfileupload_update()) after save
dispatcher.connect(
    trackfile_update,
    signal=models.signals.post_save,
    sender=TrackFile
)

class TrackFileUpload(MediaFileUpload):
    uploaded_file = models.FileField(
        upload_to=os.path.join(
            settings.FILE_DIRNAME, 'uploaded', '%Y', '%m', '%d'
        ),
        max_length=1000
    )
    trackfile = models.OneToOneField(
        'TrackFile', blank=True, null=True, related_name='trackfileupload'
    )
    
    def save(self):
        if not self.trackfile:
            path = self.get_uploaded_file_filename()
            group_hash = TrackFile.objects.add_from_path(
                path, create_track=False
            )
            if group_hash:
                trackfiles = TrackFile.objects.filter(group_hash=group_hash)
                self.trackfile = trackfiles[0]
        super(TrackFileUpload, self).save()
    
    
    class Admin:
        search_fields = ['trackfile__relative_path']
        list_display = ['id', 'trackfile', 'user', 'added', 'updated']
    
# Call trackfile.update() (via trackfileupload_update()) after save
dispatcher.connect(
    trackfileupload_update,
    signal=models.signals.post_save,
    sender=TrackFileUpload
)


class ImageFileManager(MediaFileManager):
    def is_png(self, path):
        return is_mimetype(path, PNG_MIMETYPE)
    
    def is_jpg(self, path):
        return is_mimetype(path, JPG_MIMETYPE)
    
    def is_gif(self, path):
        return is_mimetype(path, GIF_MIMETYPE)
    
    def is_image_file(self, path):
        return self.is_png(path) or self.is_jpg(path) or self.is_gif(path)
    
    def get_in_path(self, path):
        return super(ImageFileManager, self).get_in_path(path).filter(
            master=None
        )
    
    def get_or_create_from_path(
            self, path, master=None, sites=None, import_path=None
        ):
        import_path = import_path or os.path.join(
            settings.IMAGE_DIRNAME, 'imported', '%Y', '%m', '%d'
        )
        return super(ImageFileManager, self).get_or_create_from_path(
            path,
            sites=sites,
            import_path=import_path,
            defaults={'master' : master}
        )
    
    def get_or_create_from_trackfile(
            self, trackfile, filename='cover.png', base_path=None
        ):
        base_path = base_path or os.path.join(
            settings.IMAGE_DIRNAME, 'trackfile'
        )
        relative_path = os.path.join(
            base_path,
            smart_str(trackfile.id),
            filename
        )
        imagefile = None
        created = False
        try:
            imagefile = ImageFile.objects.get(relative_path=relative_path)
        except ImageFile.DoesNotExist:
            relative_path, absolute_path = mediaserver.media_paths(
                relative_path
            )
            image = trackfile.info['cover_image']
            if image:
                mediaserver.remove(relative_path)
                try:
                    os.makedirs(os.path.split(absolute_path)[0])
                except:
                    pass
                image.save(absolute_path)
                imagefile, created = self.get_or_create_from_path(
                    relative_path, sites=trackfile.sites.all()
                )
        return (imagefile, created)
    

class ImageFileCurrentSiteManager(CurrentSiteManager, ImageFileManager):
    pass

class ImageFile(MediaFile):
    width = models.PositiveIntegerField(blank=True, null=True)
    height = models.PositiveIntegerField(blank=True, null=True)
    master = models.ForeignKey('self', null=True, related_name="scaled")
    
    objects = ImageFileManager()
    on_site = ImageFileCurrentSiteManager(field_name='sites')
    
    def get_absolute_url(self):
        return reverse(
            'djedna_imagefile_detail',
            kwargs={'imagefile_id' : self.id}
        )
    
    def get_scaled(self, requested_size=None, scale=0.0):
        imagefile = self
        if not requested_size and scale:
            requested_size = (
                int(float(self.width) * float(scale)),
                int(float(self.height) * float(scale))
            )
        # Did we request a specific width and height
        if requested_size:
            width, height = requested_size
            # Is this cover_file not the correct size?
            if self.width != width or self.height != height:
                scaled_imagefiles = self.scaled.filter(
                    width=width, height=height
                )
                # Is there a scaled cover_file that's the right size?
                try:
                    imagefile = scaled_imagefiles[0]
                except:
                    thumbnail = DjangoThumbnail(
                        self.relative_path, requested_size
                    )
                    imagefile, created = \
                        ImageFile.objects.get_or_create_from_path(
                            thumbnail.relative_dest,
                            master=self,
                            sites=self.sites.all()
                        )
        return imagefile
    
    def is_png(self):
        return self.mimetype == PNG_MIMETYPE
    
    def is_jpg(self):
        return self.mimetype == JPG_MIMETYPE
    
    def is_gif(self):
        return self.mimetype == GIF_MIMETYPE
    
    def update(self, group_hash=None, force_update=False):
        needs_update = force_update
        try:
            relative_path, absolute_path = mediaserver.media_paths(
                self.imagefileupload.get_uploaded_file_filename()
            )
            if self.relative_path != relative_path:
                self.relative_path = relative_path
                needs_update = True
        except ImageFileUpload.DoesNotExist:
            pass
        return super(ImageFile, self).update(
            group_hash=group_hash,
            force_update=needs_update
        )
    
    def save(self):
        if not (self.width and self.height) and self.file_exists():
            image = Image.open(
                mediaserver.get_media_path(self.relative_path)
            )
            size = image.size
            self.width = size[0]
            self.height = size[1]
        super(ImageFile, self).save()
    

class ImageFileUpload(MediaFileUpload):
    uploaded_file = models.ImageField(
        upload_to=os.path.join(
            settings.IMAGE_DIRNAME, 'uploaded', '%Y', '%m', '%d'
        ),
        max_length=1000
    )
    imagefile = models.OneToOneField(
        'ImageFile', blank=True, null=True, related_name='imagefileupload'
    )
    
    def save(self):
        if not self.imagefile:
            path = self.get_uploaded_file_filename()
            self.imagefile, created = \
                ImageFile.objects.get_or_create_from_path(path)
            if self.imagefile and created:
                self.imagefile.group_hash = get_group_hash()
                self.imagefile.save()
        super(ImageFileUpload, self).save()
    
    
    class Admin:
        search_fields = ['imagefile__relative_path']
        list_display = ['id', 'imagefile', 'user', 'added', 'updated']
    
# Call trackfile.update() (via trackfileupload_update()) after save
dispatcher.connect(
    imagefileupload_update,
    signal=models.signals.post_save,
    sender=ImageFileUpload
)


class ArchiveFile(MediaFile):
    trackfiles = models.ManyToManyField(TrackFile)
    imagefiles = models.ManyToManyField(ImageFile)
    
    def get_absolute_url(self):
        return reverse(
            'djedna_downloadfile_detail',
            kwargs={'downloadfile_id' : self.id}
        )
    
    def get_models(self):
        tracks = []
        artists = []
        albums = []
        for trackfile in self.trackfiles.all():
            track = trackfile.track
            artist = trackfile.track.artist
            album = trackfile.track.album
            if track and track not in tracks:
                tracks.append(track)
            if artist and artist not in artists:
                artists.append(artist)
            if album and album not in albums:
                albums.append(album)
        return tracks, albums, artists
        trackfiles = self.trackfiles.filter(TrackFile.objects.get_active_q())
        tracks = Track.objects.filter(
            id__in=[trackfile.track.id for trackfile in trackfiles]
        )
    
    def remove_archive(self):
        if self.file_exists():
            mediaserver.remove_media(self.relative_path)