Agregada integracion a cache de recordings

Fue un leseo la parte de recordings_of_release, pero ya esta esa parte

Me faltan un par de recordings no mas :3

fetcher/medium.py

@@ -120,6 +120,18 @@ def map_release(mb_release, cover_art=None):
     }
 
 
+def map_media(mb_media):
+    """Transforma una instancia de media dentro de una release a una util para mis propósitos"""
+    media = {
+        'format': mb_media.get('format'),
+        'position': mb_media.get('position'),
+        'track_count': mb_media.get('track_count'),
+        'recordings': [track.get('recording') for track in mb_media.get('tracks')]
+    }
+
+    return media
+
+
 def map_recording(mb_recording):
     """Mapea el modelo de recording entregado por musicbrainz a uno propio"""
     return {
@@ -341,32 +353,58 @@ def get_artist_of_release(mbid, limit, page):
 
 
 def get_recording(mbid):
-    """Obtiene una grabación incluyendo a su artista"""
-    mb_recording = mb.get_recording_by_mbid(mbid)
-    if mb_recording is None:
-        mb_recording = mb.get_recording_by_mbid(mbid)
-    else:
-        mb_recording = json.loads(mb_recording)
-    if 'error' in mb_recording:
-        return mb_recording
+    """Obtiene una grabación"""
 
-    recording = map_recording(mb_recording)
+    with get_redis_connection() as redis:
+        mb_recording = redis.get(f'recording:{mbid}')
+        if mb_recording is None:
+            mb_recording = mb.get_recording_by_mbid(mbid)
+        else:
+            mb_recording = json.loads(mb_recording)
 
-    return recording
+        if 'error' in mb_recording:
+            return mb_recording
+
+        jobs.load_entities_of_recording.delay(mbid)
+
+    return map_recording(mb_recording)
 
 
-def get_recordings_of_release(mbid, limit, page):
-    """Obtiene las grabaciones de una release incluyendo los creditos a su artista"""
-    mb_recordings = mb.browse_recordings(params={'release': mbid}, includes=['artist-credits'],
-                                         limit=limit, offset=limit * (page - 1))
+def get_recordings_of_release(mbid):
+    """Obtiene las grabaciones de una release
 
-    if 'error' in mb_recordings:
-        return mb_recordings
+    Realmente no existen grabaciones para este caso de uso, si no, media, el cual representa
+    los medios físicos en los que esta una grabación, asi que se entrega una lista de medias con sus
+    grabaciones acopladas, todo ordenado y con indexes de orden
+    """
 
-    return {
-        'paginate': paginate(mb_recordings.get('recording_count', 0), limit, page),
-        'recordings': [map_recording(recording) for recording in mb_recordings['recordings']]
-    }
+    medias = []
+
+    with get_redis_connection() as redis:
+        medias_key = f'release:{mbid}:media'
+        count = redis.get(f'{medias_key}:count')
+        if count and redis.zcard(medias_key) == int(count):
+            medias = [json.loads(media) for media in redis.zrange(medias_key, 0, -1)]
+            for media in medias:
+                recordings_key = f'{medias_key}:{media.get("position")}:recordings'
+                recordings_id = redis.zrange(recordings_key, 0, -1)
+                media['recordings'] = []
+                for recording_id in recordings_id:
+                    media['recordings'].append(json.loads(redis.get(f'recording:{recording_id}')))
+
+    if len(medias) == 0:
+        # Si es que no habían medias cargadas en cache, puede ser que la release nunca se alla
+        # cargado.
+        jobs.load_entities_of_release.delay(mbid)
+
+        mb_release = mb.get_release_by_mbid(mbid, ['recordings'])
+
+        if 'error' in mb_release:
+            return mb_release
+
+        medias = [map_media(media) for media in mb_release.get('media', [])]
+
+    return {'medias': medias}
 
 
 def get_release_of_recording(mbid, limit, page):