Album.java :  » Music » netmus » it » unipd » netmus » server » persistent » Java Open Source

package it.unipd.netmus.server.persistent;

import it.unipd.netmus.server.utils.Utils;
import it.unipd.netmus.server.utils.cache.CacheSupport;
import it.unipd.netmus.server.utils.cache.Cacheable;
import it.unipd.netmus.shared.FieldVerifier;

import java.io.Serializable;

import com.google.code.twig.annotation.Id;

/**
 * Nome: MusicLibrary.java 
 * Autore: VT.G 
 * Licenza: GNU GPL v3 
 * Data Creazione: 10 Marzo 2011
 * 
 */

/**
 * Questa classe opera come un contenitore per la lista degli album disponibili
 * da cui gli altri oggetti possono attingere. Fornisce inoltre la businness
 * logic necessaria alla ricerca esterna di copertine tramite le API di Last.fm
 * ed alla ricerca interna al Datastore. Implementa le interfacce Serializable e
 * Cacheable poich viene gli album vengono gestiti anche nella Memcache. Ogni
 * album  rappresentato da una chiave univoca (id) e dal link alla copertina ad
 * esso associata. Questa classe ha lo scopo di mantenere nel Datastore tutte le
 * copertine ricercate su Last.fm in modo ordinato, minimizzando cos le
 * richieste esterne.
 */

public class Album implements Serializable, Cacheable {

    private static final long serialVersionUID = 3984724119207948622L;

    /**
     * Ritorna il link alla copertina dell'album associato al nome e all'artista
     * dati in input. Se l'album non  presente nel Datastore o se la copertina
     * non  ancora stata ricercata su Last.fm viene ritornata la stringa vuota.
     */
    public static String getAlbumCover(String name, String artist) {
        Album tmp = Album.load(FieldVerifier.generateAlbumId(name, artist));
        if (tmp != null) {
            return tmp.getCover();
        } else {
            return "";
        }
    }

    /**
     * Ritorna il link alla copertina dell'album associato al nome e all'artista
     * dati in input. Se l'album non  presente nel Datastore viene effettuata
     * la ricerca esterna su Last.fm e ne viene salvato e ritornato il
     * risultato.
     */
    public static String getAlbumCoverLastFm(String name, String artist) {
        Album tmp = Album.load(FieldVerifier.generateAlbumId(name, artist));
        if (tmp != null) {
            if (!tmp.getCover().equals("")) {
                return tmp.getCover();
            } else {
                tmp.setCover(Utils.getCoverImage(artist, name));
                tmp.update();
                return tmp.getCover();
            }
        } else {
            return "";
        }
    }

    /**
     * Legge dalla cache e, se non presente, dal Datastore l'album la cui chiave
     * univoca \`e data in input.
     */
    public static Album load(String id) {

        Album album = (Album) CacheSupport.cacheGet(id);

        if (album == null) {
            album = ODF.get().load().type(Album.class).id(id).now();
            if (album != null) {
                album.addToCache();
            }
        }

        return album;
    }

    /**
     * Salva nel Datastore l'album con il nome e l'artista dati in input.
     * Ritorna false nel caso in cui l'album specificato sia gi presente.
     */
    public static boolean storeNewAlbum(String name, String artist) {
        try {
            new Album(name, artist);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * Chiave univoca assegnata ad un album,  generata a partire dal nome
     * dell'album e dall'artista.
     */
    @Id
    private String id;

    private String cover;

    public Album() {
    }

    public Album(String name, String artist) throws Exception {
        setId(FieldVerifier.generateAlbumId(name, artist));
        setCover("");
        this.store();
    }

    @Override
    public void addToCache() {
        CacheSupport.cachePut(this.id, this);
    }

    @Override
    public void removeFromCache() {
        CacheSupport.cacheRemove(this.id);
    }

    /**
     * Aggiorna o inserisce i dati dell'album nel DataStore.
     */
    public void update() {
        ODF.get().storeOrUpdate(this);
        this.addToCache();
    }

    private String getCover() {
        return cover;
    }

    private void setCover(String cover) {
        this.cover = cover;
    }

    private void setId(String id) {
        this.id = id;
    }

    /**
     * Inserisce nel database per la prima volta l'album. Se esiste gi un album
     * con lo stesso id lancia un'eccezione di tipo IllegalStateException.
     */
    private void store() {
        ODF.get().store().instance(this).ensureUniqueKey().now();

        this.addToCache();
    }

}