import static com.google.common.base.Preconditions.checkNotNull;
import java.net.MalformedURLException;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;
import com.google.common.eventbus.EventBus;
return posts;
}
- /**
- * Returns the album with the given ID, creating a new album if no album
- * with the given ID can be found.
- *
- * @param albumId
- * The ID of the album
- * @return The album with the given ID
- */
- public Album getAlbum(String albumId) {
- return getAlbum(albumId, true);
- }
-
- /**
- * Returns the album with the given ID, optionally creating a new album if
- * an album with the given ID can not be found.
- *
- * @param albumId
- * The ID of the album
- * @param create
- * {@code true} to create a new album if none exists for the
- * given ID
- * @return The album with the given ID, or {@code null} if no album with the
- * given ID exists and {@code create} is {@code false}
- */
- public Album getAlbum(String albumId, boolean create) {
- Optional<Album> album = database.getAlbum(albumId);
- if (album.isPresent()) {
- return album.get();
- }
- if (!create) {
- return null;
- }
- Album newAlbum = database.newAlbumBuilder().withId(albumId).build();
- database.storeAlbum(newAlbum);
- return newAlbum;
+ public Optional<Album> getAlbum(String albumId) {
+ return database.getAlbum(albumId);
}
- /**
- * Returns the image with the given ID, creating it if necessary.
- *
- * @param imageId
- * The ID of the image
- * @return The image with the given ID
- */
- public Image getImage(String imageId) {
- return getImage(imageId, true);
- }
-
- /**
- * Returns the image with the given ID, optionally creating it if it does
- * not exist.
- *
- * @param imageId
- * The ID of the image
- * @param create
- * {@code true} to create an image if none exists with the given
- * ID
- * @return The image with the given ID, or {@code null} if none exists and
- * none was created
- */
- public Image getImage(String imageId, boolean create) {
- Optional<Image> image = database.getImage(imageId);
- if (image.isPresent()) {
- return image.get();
- }
- if (!create) {
- return null;
- }
- Image newImage = database.newImageBuilder().withId(imageId).build();
- database.storeImage(newImage);
- return newImage;
+ public Optional<Image> getImage(String imageId) {
+ return database.getImage(imageId);
}
/**
}
/* load albums. */
- List<Album> topLevelAlbums = new ArrayList<Album>();
+ Map<String, Album> albums = Maps.newHashMap();
int albumCounter = 0;
while (true) {
String albumPrefix = sonePrefix + "/Albums/" + albumCounter++;
logger.log(Level.WARNING, "Invalid album found, aborting load!");
return;
}
- Album album = getAlbum(albumId).setSone(sone).modify().setTitle(albumTitle).setDescription(albumDescription).setAlbumImage(albumImageId).update();
+ Album parentAlbum = sone.getRootAlbum();
if (albumParentId != null) {
- Album parentAlbum = getAlbum(albumParentId, false);
- if (parentAlbum == null) {
- logger.log(Level.WARNING, String.format("Invalid parent album ID: %s", albumParentId));
- return;
- }
- parentAlbum.addAlbum(album);
- } else {
- if (!topLevelAlbums.contains(album)) {
- topLevelAlbums.add(album);
- }
+ parentAlbum = albums.get(albumParentId);
}
+ Album album = parentAlbum.newAlbumBuilder().withId(albumId).build().modify().setTitle(albumTitle).setDescription(albumDescription).setAlbumImage(albumImageId).update();
+ albums.put(album.getId(), album);
}
/* load images. */
logger.log(Level.WARNING, "Invalid image found, aborting load!");
return;
}
- Album album = getAlbum(albumId, false);
+ Album album = albums.get(albumId);
if (album == null) {
logger.log(Level.WARNING, "Invalid album image encountered, aborting load!");
return;
}
- Image image = getImage(imageId).modify().setSone(sone).setCreationTime(creationTime).setKey(key).setTitle(title).setDescription(description).setWidth(width).setHeight(height).update();
- album.addImage(image);
+ album.newImageBuilder().withId(imageId).created(creationTime).at(key).sized(width, height).build().modify().setTitle(title).setDescription(description).update();
}
/* load avatar. */
String avatarId = configuration.getStringValue(sonePrefix + "/Profile/Avatar").getValue(null);
if (avatarId != null) {
- profile.setAvatar(getImage(avatarId, false));
+ profile.setAvatar(getImage(avatarId).orNull());
}
/* load options. */
for (Album album : sone.getRootAlbum().getAlbums()) {
sone.getRootAlbum().removeAlbum(album);
}
- for (Album album : topLevelAlbums) {
- sone.getRootAlbum().addAlbum(album);
- }
soneInserters.get(sone).setLastInsertFingerprint(lastInsertFingerprint);
}
synchronized (knownSones) {
}
/**
- * Creates a new top-level album for the given Sone.
- *
- * @param sone
- * The Sone to create the album for
- * @return The new album
- */
- public Album createAlbum(Sone sone) {
- return createAlbum(sone, sone.getRootAlbum());
- }
-
- /**
- * Creates a new album for the given Sone.
- *
- * @param sone
- * The Sone to create the album for
- * @param parent
- * The parent of the album (may be {@code null} to create a
- * top-level album)
- * @return The new album
- */
- public Album createAlbum(Sone sone, Album parent) {
- Album album = database.newAlbumBuilder().randomId().build();
- database.storeAlbum(album);
- album.setSone(sone);
- parent.addAlbum(album);
- return album;
- }
-
- /**
* Deletes the given album. The owner of the album has to be a local Sone,
* and the album has to be {@link Album#isEmpty() empty} to be deleted.
*
checkNotNull(temporaryImage, "temporaryImage must not be null");
checkArgument(sone.isLocal(), "sone must be a local Sone");
checkArgument(sone.equals(album.getSone()), "album must belong to the given Sone");
- Image image = database.newImageBuilder().withId(temporaryImage.getId()).build().modify().setSone(sone).setCreationTime(System.currentTimeMillis()).update();
- album.addImage(image);
+ Image image = album.newImageBuilder().withId(temporaryImage.getId()).createdNow().sized(temporaryImage.getWidth(), temporaryImage.getHeight()).build();
database.storeImage(image);
imageInserter.insertImage(temporaryImage, image);
return image;
synchronized (temporaryImages) {
temporaryImages.remove(imageId);
}
- Image image = getImage(imageId, false);
- if (image != null) {
- imageInserter.cancelImageInsert(image);
+ Optional<Image> image = getImage(imageId);
+ if (image.isPresent()) {
+ imageInserter.cancelImageInsert(image.get());
}
}