X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fdemoscenemusic%2Fdata%2FDataManager.java;h=c0001c41050e86a333a847718b39434ad9679987;hb=b2ab3fd2aefa2815f8c55b5b0e8b8d2eb912a192;hp=449965b622b1a6f4e658bf3ceedfcad04e9f1dd7;hpb=5580bfd42efd17a09314e551f9166e27bfbd329e;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 449965b..c0001c4 100644 --- a/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java +++ b/src/main/java/net/pterodactylus/demoscenemusic/data/DataManager.java @@ -38,6 +38,7 @@ import net.pterodactylus.util.database.Join.JoinType; import net.pterodactylus.util.database.ObjectCreator; import net.pterodactylus.util.database.ObjectCreator.StringCreator; import net.pterodactylus.util.database.OrderField; +import net.pterodactylus.util.database.Parameter.IntegerParameter; import net.pterodactylus.util.database.Parameter.StringParameter; import net.pterodactylus.util.database.Query; import net.pterodactylus.util.database.Query.Type; @@ -324,7 +325,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)); } /** @@ -341,26 +342,137 @@ 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)); } /** - * Returns the derivatives for the given track. + * 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); + } + + /** + * Saves the given track. This also saves all relationships of the track. * * @param track - * The track to get the derivatives for + * The track to save + * @throws DatabaseException + * if a database error occurs + */ + public void saveTrack(Track track) throws DatabaseException { + Query query = new Query(Type.UPDATE, "TRACKS"); + query.addValueField(new ValueField("TRACKS.NAME", new StringParameter(track.getName()))); + query.addValueField(new ValueField("TRACKS.REMIX", new StringParameter(track.getRemix()))); + query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACKS.ID", new StringParameter(track.getId())))); + database.update(query); + /* store artist information. */ + track.getArtists(); /* prefetch artists. */ + query = new Query(Type.DELETE, "TRACK_ARTISTS"); + query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_ARTISTS.TRACK", new StringParameter(track.getId())))); + database.update(query); + for (int index = 0; index < track.getArtists().size(); ++index) { + query = new Query(Type.INSERT, "TRACK_ARTISTS"); + query.addValueField(new ValueField("TRACK_ARTISTS.TRACK", new StringParameter(track.getId()))); + query.addValueField(new ValueField("TRACK_ARTISTS.ARTIST", new StringParameter(track.getArtists().get(index).getId()))); + query.addValueField(new ValueField("TRACK_ARTISTS.DISPLAY_ORDER", new IntegerParameter(index + 1))); + database.insert(query); + } + /* store properties. */ + saveProperties(track.getProperties(), "TRACK_PROPERTIES", "TRACK", track.getId()); + } + + /** + * 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(Track track) throws DatabaseException { + 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(track.getId())))); + 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 @@ -390,6 +502,36 @@ public class DataManager { } /** + * Saves the given track derivative. As a track derivative does not have any + * attributes of its own only its properties are saved. + * + * @param trackDerivative + * The track derivative to save + * @throws DatabaseException + * if a database error occurs + */ + public void saveTrackDerivate(TrackDerivative trackDerivative) throws DatabaseException { + saveProperties(trackDerivative.getProperties(), "TRACK_DERIVATIVE_PROPERTIES", "TRACK_DERIVATIVE", trackDerivative.getId()); + } + + /** + * Removes the given track derivative and all its properties from the + * database. + * + * @param trackDerivative + * The track derivative to remove + * @throws DatabaseException + * if a database error occurs + */ + public void removeTrackDerivative(TrackDerivative trackDerivative) throws DatabaseException { + Query query = new Query(Type.DELETE, "TRACK_DERIVATIVES"); + query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_DERIVATIVES.ID", new StringParameter(trackDerivative.getId())))); + database.update(query); + /* remove the properties. */ + saveProperties(new Properties().set("dirty", "true").removeAll(), "TRACK_DERIVATIVE_PROPERTIES", "TRACK_DERIVATIVE", trackDerivative.getId()); + } + + /** * Returns all groups the artist with the given ID belongs to. * * @param artistId @@ -522,6 +664,7 @@ public class DataManager { /** Memoizer for the tracks by this artist. */ private final Memoizer tracksMemoizer = new Memoizer(new Callable() { + @Override public Void call() throws DatabaseException { if (!hasValue("tracks")) { @@ -716,7 +859,7 @@ public class DataManager { @Override public Void call() throws Exception { if (!hasValue("derivatives")) { - getValue("derivatives", Collection.class).set(getTrackDerivativesByTrack(LazyTrack.this)); + getValue("derivatives", Collection.class).set(getTrackDerivativesByTrack(getId())); } return null; } @@ -733,6 +876,7 @@ public class DataManager { } return null; } + }); /**