X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fdemoscenemusic%2Fdata%2FDataManager.java;h=5f20905ee12d4c6695edc47def6158fbdd1cd3e6;hb=6f3371253d6a4398abea9fcd9c78a042b80c5af2;hp=7943401609d28f8a975d32584af2773c13057023;hpb=5f372a5ff952630d8297cfc01d5d2ba1b83a0295;p=demoscenemusic.git diff --git a/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java b/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java index 7943401..5f20905 100644 --- a/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java +++ b/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java @@ -99,7 +99,7 @@ public class DataManager { public Collection getAllArtists() throws DatabaseException { Query query = new Query(Type.SELECT, "ARTISTS"); query.addField(new Field("ARTISTS.*")); - return loadProperties(database.getMultiple(query, artistCreator)); + return loadArtistProperties(database.getMultiple(query, artistCreator)); } /** @@ -116,7 +116,7 @@ public class DataManager { Query query = new Query(Type.SELECT, "ARTISTS"); query.addField(new Field("ARTISTS.*")); query.addWhereClause(new ValueFieldWhereClause(new ValueField("ARTISTS.ID", new StringParameter(id)))); - return loadProperties(database.getSingle(query, artistCreator)); + return loadArtistProperties(database.getSingle(query, artistCreator)); } /** @@ -133,7 +133,7 @@ public class DataManager { query.addField(new Field("ARTISTS.*")); query.addJoin(new Join(JoinType.INNER, "GROUP_ARTISTS", new Field("ARTISTS.ID"), new Field("GROUP_ARTISTS.ARTIST"))); query.addWhereClause(new ValueFieldWhereClause(new ValueField("GROUP_ARTISTS.GROUP_", new StringParameter(groupId)))); - return loadProperties(database.getMultiple(query, artistCreator)); + return loadArtistProperties(database.getMultiple(query, artistCreator)); } /** @@ -151,7 +151,7 @@ public class DataManager { query.addJoin(new Join(JoinType.INNER, "TRACK_ARTISTS", new Field("TRACK_ARTISTS.ARTIST"), new Field("ARTISTS.ID"))); query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_ARTISTS.TRACK", new StringParameter(trackId)))); query.addOrderField(new OrderField(new Field("TRACK_ARTISTS.DISPLAY_ORDER"))); - return loadProperties(database.getMultiple(query, artistCreator)); + return loadArtistProperties(database.getMultiple(query, artistCreator)); } /** @@ -169,7 +169,7 @@ public class DataManager { query.addValueField(new ValueField("ID", new StringParameter(id))); query.addValueField(new ValueField("NAME", new StringParameter(name))); database.insert(query); - return loadProperties(getArtistById(id)); + return loadArtistProperties(getArtistById(id)); } /** @@ -240,23 +240,8 @@ public class DataManager { * @throws DatabaseException * if a database error occurs */ - public Artist loadProperties(final Artist artist) throws DatabaseException { - Query query = new Query(Type.SELECT, "ARTIST_PROPERTIES"); - query.addField(new Field("ARTIST_PROPERTIES.PROPERTY")); - query.addField(new Field("ARTIST_PROPERTIES.VALUE")); - query.addWhereClause(new ValueFieldWhereClause(new ValueField("ARTIST", new StringParameter(artist.getId())))); - database.process(query, new ResultProcessor() { - - @Override - public void processResult(ResultSet resultSet) throws SQLException { - if (resultSet.isFirst()) { - artist.getProperties().removeAll(); - } - artist.getProperties().set(resultSet.getString("ARTIST_PROPERTIES.PROPERTY"), resultSet.getString("ARTIST_PROPERTIES.VALUE")); - } - - }); - return artist; + public Artist loadArtistProperties(final Artist artist) throws DatabaseException { + return loadProperties(artist, "ARTIST_PROPERTIES", "ARTIST"); } /** @@ -268,9 +253,9 @@ public class DataManager { * @throws DatabaseException * if a database error occurs */ - public List loadProperties(List artists) throws DatabaseException { + public List loadArtistProperties(List artists) throws DatabaseException { for (Artist artist : artists) { - loadProperties(artist); + loadArtistProperties(artist); } return artists; } @@ -339,7 +324,7 @@ public class DataManager { Query query = new Query(Type.SELECT, "TRACKS"); query.addField(new Field("TRACKS.*")); query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACKS.ID", new StringParameter(id)))); - return database.getSingle(query, trackCreator); + return loadTrackProperties(database.getSingle(query, trackCreator)); } /** @@ -356,7 +341,133 @@ public class DataManager { query.addField(new Field("TRACKS.*")); query.addJoin(new Join(JoinType.INNER, "TRACK_ARTISTS", new Field("TRACKS.ID"), new Field("TRACK_ARTISTS.TRACK"))); query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_ARTISTS.ARTIST", new StringParameter(artistId)))); - return database.getMultiple(query, trackCreator); + return loadTrackProperties(database.getMultiple(query, trackCreator)); + } + + /** + * Loads the properties for the given track. + * + * @param track + * The track for which to load the properties + * @return The track with the properties loaded + * @throws DatabaseException + * if a database error occurs + */ + public Track loadTrackProperties(Track track) throws DatabaseException { + return loadProperties(track, "TRACK_PROPERTIES", "TRACK"); + } + + /** + * Loads the properties for the given tracks. + * + * @param tracks + * The tracks for which to load the properties + * @return The tracks with the properties loaded + * @throws DatabaseException + * if a database error occurs + */ + public List loadTrackProperties(List tracks) throws DatabaseException { + for (Track track : tracks) { + loadTrackProperties(track); + } + return tracks; + } + + /** + * Creates a new track with the given name. + * + * @param name + * The name of the track + * @return The created track + * @throws DatabaseException + * if a database error occurs + */ + public Track createTrack(String name) throws DatabaseException { + Query query = new Query(Type.INSERT, "TRACKS"); + String id = UUID.randomUUID().toString(); + query.addValueField(new ValueField("ID", new StringParameter(id))); + query.addValueField(new ValueField("NAME", new StringParameter(name))); + database.insert(query); + return getTrackById(id); + } + + /** + * Returns the derivative with the given ID. + * + * @param id + * The ID of the derivatives to load + * @return The derivative with the given ID + * @throws DatabaseException + * if a database error occurs + */ + public TrackDerivative getTrackDerivativeById(String id) throws DatabaseException { + Query query = new Query(Type.SELECT, "TRACK_DERIVATIVES"); + query.addField(new Field("TRACK_DERIVATIVES.*")); + query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_DERIVATIVES.ID", new StringParameter(id)))); + return loadTrackDerivativeProperties(database.getSingle(query, trackDerivativeCreator)); + } + + /** + * Returns the derivatives for the given track. + * + * @param trackId + * The track ID to get the derivatives for + * @return The derivatives for the given track + * @throws DatabaseException + * if a database error occurs + */ + public Collection getTrackDerivativesByTrack(String trackId) throws DatabaseException { + Query query = new Query(Type.SELECT, "TRACK_DERIVATIVES"); + query.addField(new Field("TRACK_DERIVATIVES.*")); + query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_DERIVATIVES.TRACK", new StringParameter(trackId)))); + return loadTrackDerivativeProperties(database.getMultiple(query, trackDerivativeCreator)); + } + + /** + * Creates a new derivative for the given track. + * + * @param track + * The track to create the derivative for + * @return The created derivative + * @throws DatabaseException + * if a database error occurs + */ + public TrackDerivative createTrackDerivative(Track track) throws DatabaseException { + Query query = new Query(Type.INSERT, "TRACK_DERIVATIVES"); + String id = UUID.randomUUID().toString(); + query.addValueField(new ValueField("TRACK_DERIVATIVES.ID", new StringParameter(id))); + query.addValueField(new ValueField("TRACK_DERIVATIVES.TRACK", new StringParameter(track.getId()))); + database.insert(query); + return getTrackDerivativeById(id); + } + + /** + * Loads the properties for the given track derivative. + * + * @param trackDerivative + * The track derivative to load the properties for + * @return The track derivative with its properties loaded + * @throws DatabaseException + * if a database error occurs + */ + public TrackDerivative loadTrackDerivativeProperties(TrackDerivative trackDerivative) throws DatabaseException { + return loadProperties(trackDerivative, "TRACK_DERIVATIVE_PROPERTIES", "TRACK_DERIVATIVE"); + } + + /** + * Loads the properties for the given track derivatives. + * + * @param trackDerivatives + * The track derivatives to load the properties for + * @return The track derivatives with their properties loaded + * @throws DatabaseException + * if a database error occurs + */ + public List loadTrackDerivativeProperties(List trackDerivatives) throws DatabaseException { + for (TrackDerivative trackDerivative : trackDerivatives) { + loadTrackDerivativeProperties(trackDerivative); + } + return trackDerivatives; } /** @@ -443,6 +554,44 @@ public class DataManager { return database.getMultiple(query, new StringCreator("USER_OPENIDS.OPENID")); } + // + // PRIVATE METHODS + // + + /** + * Loads the properties for the given object. + * + * @param + * The type of the object + * @param object + * The object + * @param table + * The table to load the properties from + * @param type + * The type of the object (“ARTIST,” “TRACK,” etc.) + * @return The object with its properties loaded + * @throws DatabaseException + * if a database error occurs + */ + private T loadProperties(final T object, final String table, String type) throws DatabaseException { + Query query = new Query(Type.SELECT, table); + query.addField(new Field(table + ".PROPERTY")); + query.addField(new Field(table + ".VALUE")); + query.addWhereClause(new ValueFieldWhereClause(new ValueField(type, new StringParameter(object.getId())))); + database.process(query, new ResultProcessor() { + + @Override + public void processResult(ResultSet resultSet) throws SQLException { + if (resultSet.isFirst()) { + object.getProperties().removeAll(); + } + object.getProperties().set(resultSet.getString(table + ".PROPERTY"), resultSet.getString(table + ".VALUE")); + } + + }); + return object; + } + /** * {@link Artist} implementation that retrieves some attributes (such as * {@link #getGroups()}, and {@link #getTracks()}) from the @@ -642,6 +791,19 @@ public class DataManager { }); + /** Memoizer for the track derivatives. */ + private final Memoizer derivativesMemoizer = new Memoizer(new Callable() { + + @Override + public Void call() throws Exception { + if (!hasValue("derivatives")) { + getValue("derivatives", Collection.class).set(getTrackDerivativesByTrack(getId())); + } + return null; + } + + }); + /** Memoizer for the related tracks. */ private final Memoizer relatedTracksMemoizer = new Memoizer(new Callable() { @@ -699,6 +861,15 @@ public class DataManager { * {@inheritDoc} */ @Override + public Collection getDerivatives() { + derivativesMemoizer.get(); + return super.getDerivatives(); + } + + /** + * {@inheritDoc} + */ + @Override public Map> getRelatedTracks() { relatedTracksMemoizer.get(); return super.getRelatedTracks();