import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashSet;
import java.util.List;
+import java.util.Map;
+import java.util.UUID;
import java.util.concurrent.Callable;
+import net.pterodactylus.demoscenemusic.data.Track.Relationship;
import net.pterodactylus.util.collection.Memoizer;
import net.pterodactylus.util.database.Database;
import net.pterodactylus.util.database.DatabaseException;
import net.pterodactylus.util.database.Join;
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.StringParameter;
import net.pterodactylus.util.database.Query;
import net.pterodactylus.util.database.Query.Type;
+import net.pterodactylus.util.database.ResultProcessor;
import net.pterodactylus.util.database.ValueField;
import net.pterodactylus.util.database.ValueFieldWhereClause;
@SuppressWarnings("synthetic-access")
private final ObjectCreator<Style> styleCreator = new StyleCreator();
+ /** The {@link User} object creator. */
+ @SuppressWarnings("synthetic-access")
+ private final ObjectCreator<User> userCreator = new UserCreator();
+
/** The database. */
private final Database database;
public Collection<Artist> getAllArtists() throws DatabaseException {
Query query = new Query(Type.SELECT, "ARTISTS");
query.addField(new Field("ARTISTS.*"));
- return database.getMultiple(query, artistCreator);
+ return loadProperties(database.getMultiple(query, artistCreator));
}
/**
Query query = new Query(Type.SELECT, "ARTISTS");
query.addField(new Field("ARTISTS.*"));
query.addWhereClause(new ValueFieldWhereClause(new ValueField("ARTISTS.ID", new StringParameter(id))));
- return database.getSingle(query, artistCreator);
+ return loadProperties(database.getSingle(query, artistCreator));
}
/**
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 database.getMultiple(query, artistCreator);
+ return loadProperties(database.getMultiple(query, artistCreator));
}
/**
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 database.getMultiple(query, artistCreator);
+ return loadProperties(database.getMultiple(query, artistCreator));
+ }
+
+ /**
+ * Creates a new artist with the given name.
+ *
+ * @param name
+ * The name of the artist
+ * @return The created artist
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public Artist createArtist(String name) throws DatabaseException {
+ Query query = new Query(Type.INSERT, "ARTISTS");
+ 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 loadProperties(getArtistById(id));
+ }
+
+ /**
+ * Saves the given artist.
+ *
+ * @param artist
+ * The artist to save
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public void saveArtist(Artist artist) throws DatabaseException {
+ Query query = new Query(Type.UPDATE, "ARTISTS");
+ query.addValueField(new ValueField("NAME", new StringParameter(artist.getName())));
+ query.addWhereClause(new ValueFieldWhereClause(new ValueField("ID", new StringParameter(artist.getId()))));
+ database.update(query);
+ }
+
+ /**
+ * Loads the properties for an artist.
+ *
+ * @param artist
+ * The artist to load the properties for
+ * @return The artist
+ * @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;
+ }
+
+ /**
+ * Loads the properties of all given artists.
+ *
+ * @param artists
+ * The artists to load the properties for
+ * @return The list of artists
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public List<Artist> loadProperties(List<Artist> artists) throws DatabaseException {
+ for (Artist artist : artists) {
+ loadProperties(artist);
+ }
+ return artists;
}
/**
}
/**
+ * Returns all related tracks for the track with the given ID.
+ *
+ * @param trackId
+ * The ID of the tracks
+ * @return A mapping from relationship to all tracks that match the relation
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public Map<Relationship, Collection<Track>> getRelatedTracksByTrack(String trackId) throws DatabaseException {
+ Query query = new Query(Type.SELECT, "TRACKS");
+ query.addField(new Field("TRACKS.*"));
+ query.addField(new Field("TRACK_RELATIONS.*"));
+ query.addJoin(new Join(JoinType.INNER, "TRACK_RELATIONS", new Field("TRACK_RELATIONS.TRACK"), new Field("TRACK_RELATIONS.RELATED_TRACK")));
+ query.addWhereClause(new ValueFieldWhereClause(new ValueField("TRACK_RELATIONS.TRACK", new StringParameter(trackId))));
+ final Map<Relationship, Collection<Track>> relatedTracks = new EnumMap<Relationship, Collection<Track>>(Relationship.class);
+ database.process(query, new ResultProcessor() {
+
+ @Override
+ @SuppressWarnings("synthetic-access")
+ public void processResult(ResultSet resultSet) throws SQLException {
+ Track track = trackCreator.createObject(resultSet);
+ Relationship relationship = Relationship.valueOf(resultSet.getString("TRACK_RELATIONS.RELATIONSHIP"));
+ if (!relatedTracks.containsKey(relationship)) {
+ relatedTracks.put(relationship, new HashSet<Track>());
+ }
+ relatedTracks.get(relationship).add(track);
+ }
+ });
+ return relatedTracks;
+ }
+
+ /**
* Returns the track with the given ID.
*
* @param id
}
/**
+ * Returns the user with the given name.
+ *
+ * @param username
+ * The name of the user
+ * @return The user, or {@code null} if the user does not exist
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public User getUserByName(String username) throws DatabaseException {
+ Query query = new Query(Type.SELECT, "USERS");
+ query.addField(new Field("USERS.*"));
+ query.addWhereClause(new ValueFieldWhereClause(new ValueField("USERS.NAME", new StringParameter(username))));
+ return database.getSingle(query, userCreator);
+ }
+
+ /**
+ * Returns the user connected with the given OpenID.
+ *
+ * @param openId
+ * The OpenID to find the user for
+ * @return The user connected with the given OpenID, or {@code null} if
+ * there is no such user
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public User getUserByOpenId(String openId) throws DatabaseException {
+ Query query = new Query(Type.SELECT, "USERS");
+ query.addField(new Field("USERS.*"));
+ query.addJoin(new Join(JoinType.INNER, "USER_OPENIDS", new Field("USER_OPENIDS.USER"), new Field("USERS.ID")));
+ query.addWhereClause(new ValueFieldWhereClause(new ValueField("USER_OPENIDS.OPENID", new StringParameter(openId))));
+ return database.getSingle(query, userCreator);
+ }
+
+ /**
+ * Returns all OpenIDs connected with the user with the given ID.
+ *
+ * @param userId
+ * The ID of the user
+ * @return All OpenIDs connected with the given user
+ * @throws DatabaseException
+ * if a database error occurs
+ */
+ public Collection<String> getOpenIdsByUser(String userId) throws DatabaseException {
+ Query query = new Query(Type.SELECT, "USER_OPENIDS");
+ query.addField(new Field("USER_OPENIDS.*"));
+ query.addWhereClause(new ValueFieldWhereClause(new ValueField("USER_OPENIDS.USER", new StringParameter(userId))));
+ return database.getMultiple(query, new StringCreator("USER_OPENIDS.OPENID"));
+ }
+
+ /**
* {@link Artist} implementation that retrieves some attributes (such as
* {@link #getGroups()}, and {@link #getTracks()}) from the
* {@link DataManager} on demand.
});
+ /** Memoizer for the related tracks. */
+ private final Memoizer<Void> relatedTracksMemoizer = new Memoizer<Void>(new Callable<Void>() {
+
+ @Override
+ public Void call() throws Exception {
+ if (!hasValue("relatedTracks")) {
+ getValue("relatedTracks", Map.class).set(getRelatedTracksByTrack(getId()));
+ }
+ return null;
+ }
+ });
+
/**
* Creates a new track.
*
return super.getRemixArtists();
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Map<Relationship, Collection<Track>> getRelatedTracks() {
+ relatedTracksMemoizer.get();
+ return super.getRelatedTracks();
+ }
+
}
/**
}
+ /**
+ * {@link User} implementation that retrieves some attributes (such as
+ * {@link #getOpenIds()}) from the {@link DataManager} on demand.
+ *
+ * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
+ */
+ private class LazyUser extends DefaultUser {
+
+ /** Memoizer for a user’s OpenIDs. */
+ private final Memoizer<Void> openIdMemoizer = new Memoizer<Void>(new Callable<Void>() {
+
+ @Override
+ public Void call() throws Exception {
+ if (!hasValue("openIds")) {
+ getValue("openIds", Collection.class).set(getOpenIdsByUser(getId()));
+ }
+ return null;
+ }
+ });
+
+ /**
+ * Creates a new user.
+ *
+ * @param id
+ * The ID of the user
+ */
+ public LazyUser(String id) {
+ super(id);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Collection<String> getOpenIds() {
+ openIdMemoizer.get();
+ return super.getOpenIds();
+ }
+
+ }
+
+ /**
+ * {@link ObjectCreator} implementation that can create {@link User}
+ * objects. This specific implementation creates {@link LazyUser} instances.
+ *
+ * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
+ */
+ private class UserCreator implements ObjectCreator<User> {
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public User createObject(ResultSet resultSet) throws SQLException {
+ return new LazyUser(resultSet.getString("USERS.ID")).setName(resultSet.getString("USERS.NAME")).setPasswordHash(resultSet.getString("USERS.PASSWORD")).setLevel(resultSet.getInt("USERS.LEVEL"));
+ }
+
+ }
+
}