Page History

public class FlickrBrowserContentConnector implements ContentConnector {
    private FlickrItemId defaultItemId;
    private final FlickrService flickrService;

    @Inject
    public FlickrBrowserContentConnector(FlickrService flickrService) {
        this.flickrService = flickrService;
    }


    public String getItemUrlFragment(Object itemId) {
        if (itemId == null) {
            return null;
        } else if (itemId instanceof String) {
            return (String) itemId;
        } else if (itemId instanceof FlickrItemId) {
            return ((FlickrItemId) itemId).getUuid();
        } else {
            return null;
        }
    }
    public Object getItemIdByUrlFragment(String urlFragment) {
        return FlickrItemUtil.createIdByUrlFragment(urlFragment, flickrService, true);
    }
    public Object getDefaultItemId() {
        if(defaultItemId==null){
            Photo recentPhoto = flickrService.getDefaultPhoto();
            if(recentPhoto!=null){
                defaultItemId = FlickrItemUtil.createIdByPhotoNoParent(recentPhoto);
            }
        }
        return defaultItemId;
    }
    public Item getItem(Object itemId) {
        if (itemId != null && itemId instanceof FlickrItemId) {
            return FlickrItemUtil.createItemById((FlickrItemId) itemId, flickrService);
        }
        return null;
    }
    public Object getItemId(Item item) {
        if (item instanceof FlickrItem) {
            return FlickrItemUtil.createIdByItem((FlickrItem)item, flickrService);
        }
        return null;
    }
    public boolean canHandleItem(Object itemId) {
        return itemId != null && itemId instanceof FlickrItemId;
    }
}

public class FlickrCustomTreeContainer extends AbstractContainer implements Refreshable, Collapsible, Container.Indexed {
    private static Logger logger = LoggerFactory.getLogger(FlickrCustomTreeContainer.class);
    private boolean RESTRICT = false;
    private int RESTRICT_TO = 3;
    private final FlickrService flickrService;
    private Map<Object, Class> properties = new HashMap<Object, Class>();
    private LinkedList<FlickrItemId> albumIds = null;
    private Map<FlickrItemId, FlickrItem> all = new HashMap<FlickrItemId, FlickrItem>();
    private Map<FlickrItemId, LinkedList<FlickrItemId>> childrenIDsMap = new HashMap<FlickrItemId, LinkedList<FlickrItemId>>();
    private Set<FlickrItemId> openFolders = new HashSet<FlickrItemId>();
    private List<FlickrItemId> preorderItemKeys = null;

    public FlickrCustomTreeContainer(FlickrService flickrService) {
        this.flickrService = flickrService;
        configure();
    }

    public void refresh() {
        removeAllItems();
    }

    public Collection<?> getChildren(Object itemId) {
        if (itemId instanceof FlickrItemId) {
            if (!((FlickrItemId) itemId).isForAlbum()) {
                return new LinkedList<FlickrItemId>();
            } else {
                LinkedList<FlickrItemId> children = childrenIDsMap.get(itemId);
                if (children == null) {
                    children = loadAlbumPhotos((FlickrItemId) itemId);
                }
                return children;
            }
        }
        return new LinkedList<FlickrItemId>();
    }

    public Object getParent(Object itemId) {
        return itemId != null &amp;&amp; itemId instanceof FlickrItemId ? ((FlickrItemId) itemId).getParent() : null;
    }

    public Collection<?> rootItemIds() {
        if (albumIds == null) {
            albumIds = loadAccountAlbums();
        }
        return albumIds;
    }

    public boolean areChildrenAllowed(Object itemId) {
        if (!(itemId instanceof FlickrItemId)) {
            return false;
        } else {
            return ((FlickrItemId) itemId).isForAlbum();
        }
    }

    public boolean isRoot(Object itemId) {
        return albumIds.contains(itemId);
    }

    public boolean hasChildren(Object itemId) {
        return isRoot(itemId);
    }

    public FlickrItemId nextItemId(Object itemId) {
        int indexOf = getPreorder().indexOf(itemId) + 1;
        if (indexOf == size()) {
            return null;
        }
        return getPreorder().get(indexOf);
    }

    public FlickrItemId prevItemId(Object itemId) {
        int indexOf = getPreorder().indexOf(itemId) - 1;
        if (indexOf < 0) {
            return null;
        }
        return getPreorder().get(indexOf);
    }

    public Object firstItemId() {
        FlickrItemId first = null;
        if (albumIds != null) {
            first = albumIds.getFirst();
        }
        return first;
    }

    public FlickrItemId lastItemId() {
        return getPreorder().get(size() - 1);
    }

    public boolean isFirstId(Object itemId) {
        return itemId.equals(firstItemId());
    }

    public boolean isLastId(Object itemId) {
        return itemId.equals(lastItemId());
    }

    public Item getItem(Object itemId) {
        return itemId instanceof FlickrItemId ? all.get(itemId) : null;
    }

    public Collection<?> getContainerPropertyIds() {
        return FlickrItem.IDs.getIDs().keySet();
    }

    public Class<?> getType(Object propertyId) {
        return FlickrItem.IDs.getIDs().get(propertyId);
    }

    public Collection<?> getItemIds() {
        return Collections.unmodifiableCollection(rootItemIds());
    }

    public Property getContainerProperty(Object itemId, Object propertyId) {
        Item item = getItem(itemId);
        if (item != null) {
            Property property = item.getItemProperty(propertyId);
            if (property != null) {
                return property;
            }
        }
        return null;
    }

    public int size() {
        return getPreorder().size();
    }

    public boolean containsId(Object itemId) {
        return all.containsKey(itemId);
    }

    //--------------------------------------------------------------------------------------------------
    // Collapsible
    //

    public void setCollapsed(Object itemId, boolean collapsed) {
        if (collapsed) {
            openFolders.remove(itemId);
        } else {
            openFolders.add((FlickrItemId) itemId);
        }
        preorderItemKeys = null;
    }

    public boolean isCollapsed(Object itemId) {
        return !openFolders.contains(itemId);
    }
    // --------------------------------------------------------------------------------------------------
    // Container.Indexed
    //

    public int indexOfId(Object itemId) {
        return getPreorder().indexOf(itemId);
    }

    public FlickrItemId getIdByIndex(int index) {
        return getPreorder().get(index);
    }

    public List<FlickrItemId> getItemIds(int startIndex, int numberOfItems) {
        ArrayList<FlickrItemId> rangeOfIds = new ArrayList<FlickrItemId>();
        int endIndex = startIndex + numberOfItems;
        if (endIndex > size()) {
            endIndex = size();
        }
        for (int i = startIndex; i < endIndex; i++) {
            FlickrItemId idByIndex = getIdByIndex(i);
            rangeOfIds.add(idByIndex);
        }
        return Collections.unmodifiableList(rangeOfIds);
    }

    public Object addItemAt(int index) throws UnsupportedOperationException {
        throw new UnsupportedOperationException("addItemAt is not supported!");
    }

    public Item addItemAt(int index, Object newItemId) throws UnsupportedOperationException {
        throw new UnsupportedOperationException("addItemAt is not supported!");
    }

    public boolean addContainerProperty(Object propertyId, Class<?> type, Object defaultValue) throws UnsupportedOperationException {
        properties.put(propertyId, type);
        return properties.containsKey(propertyId);
    }

    public boolean removeContainerProperty(Object propertyId) throws UnsupportedOperationException {
        properties.remove(propertyId);
        return !properties.containsKey(propertyId);
    }

    public boolean removeAllItems() throws UnsupportedOperationException {
        all.clear();
        childrenIDsMap.clear();
        albumIds = null;
        openFolders.clear();
        preorderItemKeys = null;
        return all.size() == 0 &amp;&amp; childrenIDsMap.size() == 0 &amp;&amp; albumIds == null &amp;&amp; openFolders.size() == 0 &amp;&amp; preorderItemKeys == null;
    }

    private List<FlickrItemId> getPreorder() {
        if (preorderItemKeys == null) {
            preorderItemKeys = new ArrayList<FlickrItemId>();
            for (Object root : rootItemIds()) {
                preorderItemKeys.add((FlickrItemId) root);
                loadVisibleSubtree((FlickrItemId) root);
            }
        }
        return preorderItemKeys;
    }
    private void loadVisibleSubtree(FlickrItemId root) {
        if (!isCollapsed(root)) {
            // unsave cast, but it's okay here
            Iterator<FlickrItemId> iterator = (Iterator<FlickrItemId>) getChildren(root).iterator();
            while (iterator.hasNext()) {
                FlickrItemId child = iterator.next();
                preorderItemKeys.add(child);
                // make recursive for deeper tree
            }
        }
    }
    private LinkedList<FlickrItemId> loadAccountAlbums() {
        Photosets photosets = flickrService.getPhotosets();
        Collection<Photoset> photosetCollection = photosets.getPhotosets();
        albumIds = new LinkedList<FlickrItemId>();
        logger.info("Loading photosets meta-data.");
        int i = 0;
        for (Photoset ps : photosetCollection) {
            if (ps.getPhotoCount() > 0) {
                FlickrItemId itemId = FlickrItemUtil.createIdByPhotoset(ps);
                FlickrItem item = FlickrItemUtil.createItemByPhotoSet(ps);
                albumIds.add(itemId);
                all.put(itemId, item);
                i++;
            }
            if (RESTRICT &amp;&amp; i == RESTRICT_TO) {
                break;
            }
        }
        logger.info("Loaded {} photosets.", i);
        return albumIds;
    }
    private LinkedList<FlickrItemId> loadAlbumPhotos(FlickrItemId albumId) {
        String flickr_photosetId = albumId.getPhotosetId();
        LinkedList<FlickrItemId> childrenOfAnAlbum = new LinkedList<FlickrItemId>();
        PhotoList<Photo> photoList = flickrService.getPhotosFromAlbum(flickr_photosetId);
        logger.info("Loading a photo list (with {} photos) for album with photoset_id [{}]. ", photoList.size(), flickr_photosetId);
        int i = 0;
        for (Photo photo : photoList) {
            FlickrItemId itemId = FlickrItemUtil.createIdByPhotoWithParent(albumId, photo);
            FlickrItem item = FlickrItemUtil.createItemByPhotoWithParent(itemId, photo);
            childrenOfAnAlbum.add(itemId);
            all.put(itemId, item);
            i++;
            if (RESTRICT &amp;&amp; i == RESTRICT_TO) {
                break;
            }
        }
        logger.info("Loaded {} photos", i);
        childrenIDsMap.put(albumId, childrenOfAnAlbum);
        return childrenOfAnAlbum;
    }
    private void configure() {
        Map<String, Class> props = FlickrItem.IDs.getIDs();
        for (String id : props.keySet()) {
            addContainerProperty(id, props.get(id), null);
        }
    }

}

public class FlickrBrowserTreePresenterDefinition extends TreePresenterDefinition {
    public FlickrBrowserTreePresenterDefinition() {
        setImplementationClass(FlickrBrowserTreePresenter.class);
    }
}

public class FlickrBrowserTreePresenter extends TreePresenter {
    private final FlickrService flickrService;
    private UiContext uiContext;

    @Inject
    public FlickrBrowserTreePresenter(TreeView view, ComponentProvider componentProvider, FlickrService flickrService, UiContext uiContext) {
        super(view, componentProvider);
        this.flickrService = flickrService;
        this.uiContext = uiContext;
    }
    @Override
    protected Container initializeContainer() {
        return new FlickrCustomTreeContainer(flickrService, uiContext);
    }
    @Override
    public String getIcon(Item item) {
        if (item instanceof FlickrItem) {
            if (FlickrItem.FLICKRITEMTYPE_ALBUM.equals(item.getItemProperty(FlickrItem.PROPERTY_FLICKR_ITEM_TYPE).getValue())) {
                return "icon-folder-l";
            } else {
                return "icon-file-image";
            }
        }
        return super.getIcon(item);
    }
}

public class FlickrFlatIdProvider implements ThumbnailContainer.IdProvider {
    private static Logger log = LoggerFactory.getLogger(FlickrFlatIdProvider.class);
    private boolean RESTRICT = false;
    private int RESTRICT_TO = 3;
    private int MAX_CAPACITY = 500;
    private boolean RESTRICT_MAX_CAPACITY = false;

    private final boolean ADD_UNBOUND_PHOTOS = false;
    private final FlickrService flickrService;
    private List<FlickrItemId> ids = null;

    protected FlickrFlatIdProvider(FlickrService flickrService) {
        this.flickrService = flickrService;
    }

    public List<?> getItemIds() {
        if (ids == null) {
            refresh();
        }
        return ids;
    }
    private void refresh() {
        long start = System.currentTimeMillis();
        ids = new ArrayList<FlickrItemId>();
        HashSet<String> photoIds = new HashSet<String>();
        int sectionCounter = 0;
        log.info("Loading IDs in {}", this.getClass().getName());
        // the list of all photos which are NOT within an album (aka photoset)
        // unfortunately, (request which require auth.) doesn't work yet.
        if (ADD_UNBOUND_PHOTOS) {
            PhotoList<Photo> unboundPhotos = flickrService.getPhotosNotInAnyAlbum(0, 0);
            if (unboundPhotos != null) {
                for (Photo photo : unboundPhotos) {
                    String photoId = photo.getId();
                    if (!photoIds.contains(photoId)) {
                        photoIds.add(photoId);
                        FlickrItemId itemId = FlickrItemUtil.createIdByPhotoNoParent(photo);
                        if (itemId != null) {
                            photoIds.add(photoId);
                            itemId.setThumbnailUrl(photo.getSmall320Url());
                            ids.add(itemId);
                            sectionCounter++;
                        }
                    }
                }
                log.info("Loaded IDs for {} photos which are not bound to an album.", sectionCounter);
            }
        }
        //
        // now all the photos from all albums. (this can be a lot! Find a possibility to filter!)
        // restrict! requires some filter!
        Photosets albums = flickrService.getPhotosets();
        int albumCount = 0;
        if (albums != null &amp;&amp; albums.getTotal() > 0) {
            sectionCounter = 0;
            for (Photoset photoset : albums.getPhotosets()) {
                if (photoset != null &amp;&amp; photoset.getPhotoCount() > 0) {
                    String albumId = photoset.getId();
                    int photoCounter = 0;
                    PhotoList<Photo> photoList = flickrService.getPhotosFromAlbum(albumId);
                    for (Photo photo : photoList) {
                        String photoId = photo.getId();
                        if (!photoIds.contains(photoId)) {
                            FlickrItemId itemId = FlickrItemUtil.createIdByPhotoNoParent(photo);
                            if (itemId != null) {
                                photoIds.add(photoId);
                                itemId.setThumbnailUrl(photo.getSmall320Url());
                                ids.add(itemId);
                                sectionCounter++;
                                photoCounter++;
                            }
                        }
                        if (RESTRICT &amp;&amp; photoCounter > RESTRICT_TO || RESTRICT_MAX_CAPACITY &amp;&amp; MAX_CAPACITY < photoIds.size()) {
                            break;
                        }
                    }
                }
                albumCount++;
                if (RESTRICT &amp;&amp; albumCount > RESTRICT_TO || RESTRICT_MAX_CAPACITY &amp;&amp; MAX_CAPACITY < photoIds.size()) {
                    break;
                }
            }
        }
    }
}

public class FlickrThumbnailPresenter extends ThumbnailPresenter {
    private final FlickrService flickrService;
    private final ImageProvider imageProvider;
    private final UiContext uiContext;
    private static int thumbnailSize = 150;

    @Inject
    public FlickrThumbnailPresenter(ThumbnailView view, ImageProvider imageProvider, ComponentProvider componentProvider, FlickrService flickrService, UiContext uiContext) {
        super(view, imageProvider, componentProvider);
        this.flickrService = flickrService;
        this.imageProvider = imageProvider;
        this.uiContext = uiContext;
    }

    public ThumbnailView start(WorkbenchDefinition workbench, EventBus eventBus, String viewTypeName, ContentConnector contentConnector) {
        ThumbnailView view = (ThumbnailView) super.start(workbench, eventBus, viewTypeName, contentConnector);
        view.setThumbnailSize(thumbnailSize, thumbnailSize);
        return view;
    }

    protected Container initializeContainer() {
        ThumbnailContainer container = new FlickrThumbnailContainer(imageProvider, flickrService, uiContext);
        container.setThumbnailHeight(thumbnailSize);
        container.setThumbnailWidth(thumbnailSize);
        return container;
    }
}