Scoremanager: pdf_views

scoremanager/models.py

@@ -0,0 +1,183 @@
+import os
+import re
+
+from django.db import models
+from django.db.models.fields.related import ForeignKey
+from django.utils.translation import ugettext as _
+from django.contrib.auth.models import User
+from django.utils.safestring import mark_safe
+
+
+############################# Helper Functions #######################################################
+
+
+def space_to_camelcase(value):
+    def camelcase(): 
+        yield type(value).lower
+        while True:
+            yield type(value).capitalize
+
+    c = camelcase()
+    return "".join(c.next()(x) if x else '_' for x in value.split() )
+
+
+def score_filename(score,original_name):
+    fileExtension = os.path.splitext(original_name)[1]
+    filename  = "scores/"
+    filename += space_to_camelcase( score.piece.title ) + "/"
+    filename += space_to_camelcase( score.score_type )
+    filename += fileExtension
+    return filename
+
+
+def recordingFileName( recording, originalName ):
+    fileExtension = os.path.splitext(originalName)[1]
+    filename  = "recordings/"
+    filename += space_to_camelcase( recording.piece.title ) + "/"
+    filename += space_to_camelcase( recording.artist )
+    filename += fileExtension
+    return filename
+
+_
+#######################################################################################################
+
+
+class Piece (models.Model):
+    title         = models.CharField( max_length = 255, verbose_name = _("title"), unique=True )
+    composer      = models.CharField( max_length = 255, blank = True, verbose_name = _("composer") ) 
+    repertoire_nr = models.IntegerField( null = True, blank=True, unique=True, default = None )
+    
+    def __unicode__(self):
+        res = self.title
+        return res 
+    
+    def isInRepertoire(self):
+        return self.repertoire_nr is not None
+
+    def get_score_for_user(self, user):
+        try:
+            return ScoreUserMapping.objects.get( user=user, score__in = self.scores.all() ).score
+        except Piece.DoesNotExist:
+            if len( self.scores.all() ) > 0:
+                return self.scores.all()[0]
+            else:
+                return None
+
+
+    @staticmethod
+    def getRepertoire():
+        return Piece.objects.filter( repertoire_nr__isnull = False  ).order_by( 'repertoire_nr' )
+
+    class Meta:
+        permissions = (
+            ("manage_scores", "Administrate and manage scores"),
+        )
+
+
+
+class BookLocation ( models.Model ):
+    piece  = models.ForeignKey ( 'Piece' )
+    book   = models.CharField( max_length = 100, blank = False, verbose_name = _("Buch") )
+    page   = models.IntegerField( verbose_name = _("page") )
+    
+    def __unicode__(self):
+        return  "%s, %d" % ( self.book, self.page )
+        
+
+
+class Score( models.Model ):
+    piece = ForeignKey('Piece', related_name="scores")
+    score_type = models.CharField(max_length=100, verbose_name="score type" ) # for example partitur, unterstimmen ...
+    file = models.FileField(upload_to=score_filename, verbose_name = _("file") )
+    uploaded_by = ForeignKey( User, verbose_name=_("uploaded_by") )
+
+    @property
+    def image_file_name(self):
+        return os.path.splitext("image_cache/" + str(self.file))[0] + ".jpg"
+
+    @staticmethod
+    def pdf2jpg(source_file, target_file, resolution = 100, crop = 15):
+        from wand.image import Image
+        ret = True
+        try:
+            with Image(filename=source_file, resolution=(resolution,resolution)) as img:
+                img.crop( crop,crop, width= img.width - 2*crop, height = int( 0.5 * img.height) - 2*crop )
+                img.format = 'jpeg'
+                img.save(filename = target_file)
+        except Exception as e:
+            print(e)
+            ret = False
+
+        return ret
+
+    def get_image_file(self):
+        from django.conf import settings
+
+        inputFile = settings.MEDIA_ROOT + "/"  + str(self.file)
+        cacheFile = settings.MEDIA_ROOT + "/" + str(self.image_file_name)
+        # Create a jpg for this score, if it does not exist yet
+        if not os.path.exists( cacheFile ):
+            if not os.path.exists( os.path.dirname( cacheFile )):
+                os.makedirs( os.path.dirname(cacheFile) )
+            Score.pdf2jpg ( inputFile, cacheFile )
+
+        return self.image_file_name
+
+    def is_active_score(self,user):
+        return len( ScoreUserMapping.objects.filter( score= self, user=user ) ) > 0
+
+    class Meta:
+        unique_together = (("piece", "score_type"),)
+        ordering = ['score_type']
+
+
+
+    
+class Recording( models.Model ):
+    piece = ForeignKey( 'Piece', related_name='recordings' )
+    artist = models.CharField( max_length = 100, verbose_name = _("Artist") )
+    file = models.FileField( upload_to = recordingFileName, verbose_name = _("file") )
+    uploaded_by = ForeignKey( User, verbose_name=_("uploaded_by") )
+
+    class Meta:
+        unique_together = (("piece", "artist"),)
+        ordering = ['artist']
+    
+
+
+class YoutubeRecording( models.Model ):
+    piece = models.ForeignKey('Piece', related_name="youtubeLinks" )
+    link  = models.CharField( max_length = 300, blank=False)
+    uploaded_by = ForeignKey( User, verbose_name=_("uploaded_by") )
+
+    youtubeRegex = re.compile( u'(?:https://)?(?:http://)?www.youtube.(?:com|de)/watch\?v=(?P<videoID>[-\w]*)' )
+
+    @property
+    def embed_html( self ):
+        replacement = """
+            <div class="embed-container"><iframe src="//www.youtube.de/embed/\g<videoID>" frameborder="0" allowfullscreen></iframe> </div>
+        """
+        return mark_safe( YoutubeRecording.youtubeRegex.sub( replacement, self.link ) )
+
+    class Meta:
+        unique_together = (("link", "piece" ))
+
+
+
+
+class ScoreUserMapping( models.Model):
+    score = ForeignKey( 'Score' )
+    user = models.OneToOneField( User )
+    piece = ForeignKey( 'Piece' )
+
+    @staticmethod
+    def add_user_score_mapping( score, user ):
+        piece = score.piece
+        ScoreUserMapping.objects.filter( user=user, piece=piece ).delete()
+        ScoreUserMapping.objects.create( score=score, user=user, piece= piece )
+
+
+    class Meta:
+        unique_together = (("piece", "user" ))
+
+