def public_set(self, path):
s = self.public.select()
- s = s.where(self.xfeaturevals.c.path == path)
+ s = s.where(self.public.c.path == path)
r = self.conn.execute(s)
public = r.fetchall()
r.close()
s = self.xfeaturevals.select()
s = s.where(self.xfeaturevals.c.feature_id == feature)
s = s.where(self.xfeaturevals.c.key == key)
+ s = s.where(self.xfeaturevals.c.value == value)
r = self.conn.execute(s)
xfeaturevals = r.fetchall()
r.close()
from httplib import HTTPConnection, HTTP
from sys import stdin
from xml.dom import minidom
+from StringIO import StringIO
import json
import types
self.token = token
def _req(self, method, path, body=None, headers={}, format='text', params={}):
- full_path = '/%s%s?format=%s' % (self.api, path, format)
+ slash = '/' if self.api else ''
+ full_path = '%s%s%s?format=%s' % (slash, self.api, path, format)
for k,v in params.items():
if v:
return self._req('POST', path, body, headers=headers, format=format,
params=params)
- def put(self, path, body=None, format='text', headers=None):
- return self._req('PUT', path, body, headers=headers, format=format)
+ def put(self, path, body=None, format='text', headers=None, params={}):
+ return self._req('PUT', path, body, headers=headers, format=format,
+ params=params)
def _list(self, path, format='text', params={}, **headers):
status, headers, data = self.get(path, format=format, headers=headers,
def retrieve_object_hashmap(self, container, object, params={},
account=None, **headers):
"""returns the hashmap representing object's data"""
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'object']:
args.pop(elem)
data = self.retrieve_object(container, object, format='json', **args)
**h)
def create_object(self, container, object, f=stdin, format='text', meta={},
- etag=None, content_type=None, content_encoding=None,
+ params={}, etag=None, content_type=None, content_encoding=None,
content_disposition=None, account=None, **headers):
"""creates a zero-length object"""
account = account or self.account
for k,v in meta.items():
headers['x-object-meta-%s' %k.strip()] = v.strip()
data = f.read() if f else None
- return self.put(path, data, format, headers=headers)
+ return self.put(path, data, format, headers=headers, params=params)
def create_zero_length_object(self, container, object, meta={}, etag=None,
content_type=None, content_encoding=None,
content_disposition=None, account=None,
**headers):
account = account or self.account
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'headers', 'account']:
args.pop(elem)
args.update(headers)
params = {'until':until, 'meta':meta}
if shared:
params['shared'] = None
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'params', 'until', 'meta']:
args.pop(elem)
return OOS_Client.list_objects(self, container, params=params, **args)
l = [elem for elem in l if eval(elem)]
for elem in l:
headers.update({elem:eval(elem)})
+ if format != 'text':
+ params['hashmap'] = None
return OOS_Client.retrieve_object(self, container, object,
account=account, format=format,
params=params, **headers)
account=None):
"""returns a specific object version"""
account = account or self.account
- args = locals()
+ args = locals().copy()
l = ['self', 'container', 'object']
for elem in l:
args.pop(elem)
if_unmodified_since=None, account=None):
"""returns the object version list"""
account = account or self.account
- args = locals()
+ args = locals().copy()
l = ['self', 'container', 'object']
for elem in l:
args.pop(elem)
x_object_public=None, account=None):
"""createas a zero length object"""
account = account or self.account
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'object']:
args.pop(elem)
return OOS_Client.create_zero_length_object(self, container, object,
**args)
- def create_object(self, container, object, f=stdin,
- meta={}, etag=None, content_type=None,
+ def create_object(self, container, object, f=stdin, format='text',
+ meta={}, params={}, etag=None, content_type=None,
content_encoding=None, content_disposition=None,
x_object_manifest=None, x_object_sharing=None,
x_object_public=None, account=None):
"""creates an object"""
account = account or self.account
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'object']:
args.pop(elem)
return OOS_Client.create_object(self, container, object, **args)
return self._chunked_transfer(path, 'PUT', f, headers=headers,
blocksize=blocksize)
- def create_object_by_hashmap(container, object, f=stdin, format='json',
+ def create_object_by_hashmap(self, container, object, hashmap={},
meta={}, etag=None, content_encoding=None,
content_disposition=None, content_type=None,
x_object_sharing=None, x_object_manifest=None,
x_object_public = None, account=None):
"""creates an object by uploading hashes representing data instead of data"""
account = account or self.account
- args = locals()
- for elem in ['self', 'container', 'object']:
+ args = locals().copy()
+ for elem in ['self', 'container', 'object', 'hashmap']:
args.pop(elem)
- data = f.read() if f else None
- if data and format == 'json':
- try:
- data = eval(data)
- data = json.dumps(data)
- except SyntaxError:
- raise Fault('Invalid formatting')
+ try:
+ data = json.dumps(hashmap)
+ except SyntaxError:
+ raise Fault('Invalid formatting')
+ args['params'] = {'hashmap':None}
+ args['format'] = 'json'
- #TODO check with xml
- return self.create_object(container, object, **args)
+ return self.create_object(container, object, f=StringIO(data), **args)
def create_manifestation(self, container, object, manifest, account=None):
"""creates a manifestation"""
x_source_object=None, account=None):
"""updates an object"""
account = account or self.account
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'object', 'replace']:
args.pop(elem)
if not replace:
x_object_public=None, account=None):
"""updates an object (incremental upload)"""
account = account or self.account
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'object', 'replace']:
args.pop(elem)
if not replace:
x_object_sharing=None, x_object_public=None, account=None):
"""updates an object"""
account = account or self.account
- args = locals()
+ args = locals().copy()
for elem in ['self', 'container', 'object', 'source']:
args.pop(elem)
self.client.create_object_using_chunks(container, object, f,
meta=meta, **args)
elif self.use_hashes:
- format = 'json' if detail else 'text'
- self.client.create_object_by_hashmap(container, object, f, format,
- meta=meta, **args)
+ data = f.read()
+ if data is object:
+ hashmap = json.loads()
+ self.client.create_object_by_hashmap(container, object, hashmap,
+ meta=meta, **args)
+ else:
+ print "Expected object"
elif self.x_object_manifest:
self.client.create_manifestation(container, object, self.x_object_manifest)
elif not f:
obj['meta'] = args
path = '/%s/%s' % (container, name)
- self.client.create_object(container, name, StringIO(obj['data']),
- meta, **args)
+ self.client.create_object(container, name, f=StringIO(obj['data']),
+ meta=meta, **args)
return obj
except IOError:
self.assertEqual(int(zero_meta['content-length']), 0)
self.assertEqual(zero_hash, [])
self.assertEqual(zero_data, '')
+
+ def test_create_object_by_hashmap(self):
+ c = self.container
+ o = 'object'
+ self.upload_random_data(c, o)
+ hashmap = self.client.retrieve_object(c, o, format='json')
+ o2 = 'object-copy'
+ self.client.create_object_by_hashmap(c, o2, hashmap)
+ self.assertEqual(self.client.retrieve_object(c, o),
+ self.client.retrieve_object(c, o))
class ObjectCopy(BaseTestCase):
def setUp(self):
self.initial_meta = self.client.retrieve_account_metadata(restricted=True)
#create a group
- self.authorized = ['chazapis', 'verigak', 'gtsouk', 'papagian']
+ self.authorized = ['chazapis', 'verigak', 'gtsouk']
groups = {'pithosdev':','.join(self.authorized)}
self.client.set_account_groups(**groups)
BaseTestCase.tearDown(self)
- def test_read_access(self):
- self.client.create_container('c')
- o = self.upload_random_data('c', 'o')
- self.client.share_object('c', 'o', ['%s:pithosdev' % get_user()])
+ def assert_read(self, authorized=[], any=False):
for token, account in OTHER_ACCOUNTS.items():
cl = Pithos_Client(get_server(), token, account, get_api())
- if account in self.authorized:
+ if account in authorized or any:
self.assert_not_raises_fault(401, cl.retrieve_object_metadata,
'c', 'o', account=get_user())
else:
o = self.upload_random_data('c', 'o/also-shared')
for token, account in OTHER_ACCOUNTS.items():
cl = Pithos_Client(get_server(), token, account, get_api())
- if account in self.authorized:
+ if account in authorized or any:
self.assert_not_raises_fault(401, cl.retrieve_object_metadata,
'c', 'o/also-shared', account=get_user())
else:
self.assert_raises_fault(401, cl.retrieve_object_metadata,
'c', 'o/also-shared', account=get_user())
- def test_write_access(self):
- self.client.create_container('c')
- o = self.upload_random_data('c', 'o')
- self.client.share_object('c', 'o', ['chazapis'], read=False)
- o_data = o['data']
+ def assert_write(self, o_data, authorized=[], any=False):
for token, account in OTHER_ACCOUNTS.items():
cl = Pithos_Client(get_server(), token, account, get_api())
new_data = get_random_data()
- if account in [get_user(), 'chazapis']:
+ if account in authorized or any:
+ # test write access
self.assert_not_raises_fault(401, cl.update_object,
'c', 'o', StringIO(new_data),
account=get_user())
- server_data = self.client.retrieve_object('c', 'o')
- self.assertEqual(o_data, server_data[:len(o_data)])
- self.assertEqual(new_data, server_data[len(o_data):])
- o_data = server_data
+ try:
+ # test read access
+ server_data = cl.retrieve_object('c', 'o', account=get_user())
+ self.assertEqual(o_data, server_data[:len(o_data)])
+ self.assertEqual(new_data, server_data[len(o_data):])
+ o_data = server_data
+ except Fault, f:
+ self.failIf(f.status == 401)
else:
self.assert_raises_fault(401, cl.update_object,
'c', 'o', StringIO(new_data),
for token, account in OTHER_ACCOUNTS.items():
cl = Pithos_Client(get_server(), token, account, get_api())
new_data = get_random_data()
- if account in [get_user(), 'chazapis']:
+ if account in authorized or any:
+ # test write access
self.assert_not_raises_fault(401, cl.update_object,
'c', o['name'],
StringIO(new_data),
account=get_user())
- server_data = self.client.retrieve_object('c', o['name'])
- self.assertEqual(o_data, server_data[:len(o_data)])
- self.assertEqual(new_data, server_data[len(o_data):])
- o_data = server_data
+ try:
+ server_data = cl.retrieve_object('c', o['name'], account=get_user())
+ self.assertEqual(o_data, server_data[:len(o_data)])
+ self.assertEqual(new_data, server_data[len(o_data):])
+ o_data = server_data
+ except Fault, f:
+ self.failIf(f.status == 401)
else:
self.assert_raises_fault(401, cl.update_object,
'c', o['name'],
StringIO(new_data),
account=get_user())
+
+ def test_group_read(self):
+ self.client.create_container('c')
+ o = self.upload_random_data('c', 'o')
+ self.client.share_object('c', 'o', ['%s:pithosdev' % get_user()])
+ self.assert_read(authorized=self.authorized)
+
+ def test_read_many(self):
+ #test read access
+ self.client.create_container('c')
+ o = self.upload_random_data('c', 'o')
+ self.client.share_object('c', 'o', self.authorized)
+ self.assert_read(authorized=self.authorized)
+
+ def test_read_by_everyone(self):
+ self.client.create_container('c')
+ o = self.upload_random_data('c', 'o')
+ self.client.share_object('c', 'o', ['*'])
+ self.assert_read(any=True)
+
+ def test_group_write(self):
+ self.client.create_container('c')
+ o = self.upload_random_data('c', 'o')
+ self.client.share_object('c', 'o', ['%s:pithosdev' % get_user()], read=False)
+ self.assert_write(o['data'], authorized=self.authorized)
+
+ def test_write_many(self):
+ self.client.create_container('c')
+ o = self.upload_random_data('c', 'o')
+ self.client.share_object('c', 'o', self.authorized, read=False)
+ self.assert_write(o['data'], authorized=self.authorized)
+
+ def test_write_by_everyone(self):
+ self.client.create_container('c')
+ o = self.upload_random_data('c', 'o')
+ self.client.share_object('c', 'o', ['*'], read=False)
+ o_data = o['data']
+ self.assert_write(o['data'], any=True)
+
+class TestPublish(BaseTestCase):
+ def test_publish(self):
+ self.client.create_container('c')
+ o_data = self.upload_random_data('c', 'o')['data']
+ self.client.publish_object('c', 'o')
+ meta = self.client.retrieve_object_metadata('c', 'o')
+ self.assertTrue('x-object-public' in meta)
+ url = '/public/%s/c/o' % get_user()
+ self.assertEqual(meta['x-object-public'], url)
+ public_client = Pithos_Client(get_server(), get_auth(), get_user(), api='')
+ data = public_client.get(url)[2]
+ self.assertEqual(o_data, data)
class AssertMappingInvariant(object):
def __init__(self, callable, *args, **kwargs):
if (iter.hasNext()) {\r
File f = iter.next();\r
String path = f.getUri();\r
- DeleteRequest deleteFile = new DeleteRequest(app.getApiPath(), app.getUsername(), path) {\r
+ DeleteRequest deleteFile = new DeleteRequest(app.getApiPath(), f.getOwner(), path) {\r
@Override\r
public void onSuccess(@SuppressWarnings("unused") Resource result) {\r
deleteFile(iter);\r
*
* @param newImages the image bundle passed on by the parent object
*/
- public FileContextMenu(final Pithos app, Images newImages, Folder selectedFolder, List<File> selectedFiles, boolean isTrash) {
+ public FileContextMenu(final Pithos app, Images newImages, TreeView selectedTree, Folder selectedFolder, List<File> selectedFiles, boolean isTrash) {
// The popup's constructor's argument is a boolean specifying that it
// auto-close itself when the user clicks outside of it.
super(true);
setAnimationEnabled(true);
images = newImages;
MenuBar contextMenu = new MenuBar(true);
+ Boolean[] permissions = null;
+ boolean canWrite = true;
+ if (selectedFolder != null) {
+ permissions = selectedFolder.getPermissions().get(app.getUsername());
+ canWrite = selectedFolder.getOwner().equals(app.getUsername()) || (permissions!= null && permissions[1] != null && permissions[1]);
+ }
+ else {
+ for (File f : selectedFiles) {
+ permissions = f.getPermissions().get(app.getUsername());
+ canWrite &= (f.getOwner().equals(app.getUsername()) || (permissions!= null && permissions[1] != null && permissions[1]));
+ }
+ }
- if (!selectedFolder.isInTrash()) {
- if (app.getClipboard().hasFiles()) {
+ if (selectedFolder != null && !selectedFolder.isInTrash()) {
+ if (canWrite && app.getClipboard().hasFiles()) {
pasteItem = new MenuItem("<span>" + AbstractImagePrototype.create(images.paste()).getHTML() + " Paste</span>", true, new PasteCommand(app, this, selectedFolder));
contextMenu.addItem(pasteItem);
}
- MenuItem upload = new MenuItem("<span>" + AbstractImagePrototype.create(images.fileUpdate()).getHTML() + " Upload</span>", true, new UploadFileCommand(app, this, selectedFolder));
- contextMenu.addItem(upload);
-
- cutItem = new MenuItem("<span id='fileContextMenu.cut'>" + AbstractImagePrototype.create(newImages.cut()).getHTML() + " Cut</span>", true, new CutCommand(app, this, selectedFiles));
- contextMenu.addItem(cutItem);
+ if (canWrite) {
+ MenuItem upload = new MenuItem("<span>" + AbstractImagePrototype.create(images.fileUpdate()).getHTML() + " Upload</span>", true, new UploadFileCommand(app, this, selectedFolder));
+ contextMenu.addItem(upload);
+
+ cutItem = new MenuItem("<span id='fileContextMenu.cut'>" + AbstractImagePrototype.create(newImages.cut()).getHTML() + " Cut</span>", true, new CutCommand(app, this, selectedFiles));
+ contextMenu.addItem(cutItem);
+ }
copyItem = new MenuItem("<span>" + AbstractImagePrototype.create(newImages.copy()).getHTML() + " Copy</span>", true, new CopyCommand(app, this, selectedFiles));
contextMenu.addItem(copyItem);
- trashItem = new MenuItem("<span>" + AbstractImagePrototype.create(newImages.emptyTrash()).getHTML() + " Move to Trash</span>", true, new ToTrashCommand(app, this, selectedFiles));
- contextMenu.addItem(trashItem);
+ if (selectedTree.equals(app.getFolderTreeView())) {
+ trashItem = new MenuItem("<span>" + AbstractImagePrototype.create(newImages.emptyTrash()).getHTML() + " Move to Trash</span>", true, new ToTrashCommand(app, this, selectedFiles));
+ contextMenu.addItem(trashItem);
+ }
}
else {
MenuItem restore = new MenuItem("<span>" + AbstractImagePrototype.create(images.versions()).getHTML() + " Restore</span>", true, new RestoreTrashCommand(app, this, selectedFiles));
contextMenu.addItem(restore);
}
- deleteItem = new MenuItem("<span>" + AbstractImagePrototype.create(newImages.delete()).getHTML() + " Delete</span>", true, new DeleteCommand(app, this, selectedFiles, MessagePanel.images));
- contextMenu.addItem(deleteItem);
+ if (canWrite) {
+ deleteItem = new MenuItem("<span>" + AbstractImagePrototype.create(newImages.delete()).getHTML() + " Delete</span>", true, new DeleteCommand(app, this, selectedFiles, MessagePanel.images));
+ contextMenu.addItem(deleteItem);
+ }
// MenuItem refresh = new MenuItem("<span>" + AbstractImagePrototype.create(images.refresh()).getHTML() + " Refresh</span>", true, new RefreshCommand(this, images));
// contextMenu.addItem(refresh);
// sharingItem = new MenuItem("<span>" + AbstractImagePrototype.create(newImages.sharing()).getHTML() + " Sharing</span>", true, new PropertiesCommand(this, images, 1));
// contextMenu.addItem(sharingItem);
if (!selectedFolder.isInTrash()) {
- if (selectedFiles.size() == 1)
+ if (canWrite && selectedFiles.size() == 1)
contextMenu.addItem(new MenuItem("<span>" + AbstractImagePrototype.create(newImages.viewText()).getHTML() + " Properties</span>", true, new PropertiesCommand(app, this, selectedFiles, images, 0)));
if (!selectedFiles.isEmpty())
vp.addHandler(new ContextMenuHandler() {
@Override
public void onContextMenu(ContextMenuEvent event) {
- Folder selectedFolder = treeView.getSelection();
- FileContextMenu contextMenu = new FileContextMenu(app, images, selectedFolder, getSelectedFiles(), false);
- int x = event.getNativeEvent().getClientX();
- int y = event.getNativeEvent().getClientY();
- contextMenu.setPopupPosition(x, y);
- contextMenu.show();
+ TreeView tree = app.getSelectedTree();
+ if (tree != null && (tree.equals(app.getFolderTreeView()) || tree.equals(app.getOtherSharedTreeView()))) {
+ Folder selectedFolder = app.getSelection();
+ FileContextMenu contextMenu = new FileContextMenu(app, images, tree, selectedFolder, getSelectedFiles(), false);
+ int x = event.getNativeEvent().getClientX();
+ int y = event.getNativeEvent().getClientY();
+ contextMenu.setPopupPosition(x, y);
+ contextMenu.show();
+ }
}
}, ContextMenuEvent.getType());
initWidget(vp);
PutRequest updateFile = new PutRequest(app.getApiPath(), app.getUsername(), path) {\r
@Override\r
public void onSuccess(@SuppressWarnings("unused") Resource result) {\r
- updateMetaData(app.getApiPath(), app.getUsername(), path + "?update=", newTags, finalPublished, perms);\r
+ updateMetaData(app.getApiPath(), file.getOwner(), path + "?update=", newTags, finalPublished, perms);\r
}\r
\r
@Override\r
GWT.log(results, null);
app.displayError(results);
}
- app.updateFolder(folder, true, null);
+ if (app.getSelectedTree().equals(app.getFolderTreeView()))
+ app.updateFolder(folder, true, null);
+ else
+ app.updateOtherSharedFolder(folder, true);
hide();
}
});
return;
}
final String fname = getFilename(upload.getFilename());
- String apath = app.getApiPath() + app.getUsername() + folder.getUri() + "/" + fname;
+ String apath = app.getApiPath() + folder.getOwner() + folder.getUri() + "/" + fname;
form.setAction(apath);
submit.setEnabled(false);
upload.setVisible(false);
images = newImages;
MenuBar contextMenu = new MenuBar(true);
- if (!folder.isInTrash()) {
- MenuItem newFolder = new MenuItem("<span id = 'folderContextMenu.newFolder'>" + AbstractImagePrototype.create(newImages.folderNew()).getHTML() + " New Folder</span>", true, new NewFolderCommand(app, this, folder, images));
- contextMenu.addItem(newFolder);
+ Boolean[] permissions = folder.getPermissions().get(app.getUsername());
+ boolean canWrite = folder.getOwner().equals(app.getUsername()) || (permissions!= null && permissions[1] != null && permissions[1]);
- if (!folder.isContainer()) {
- MenuItem cut = new MenuItem("<span id = 'folderContextMenu.cut'>" + AbstractImagePrototype.create(newImages.cut()).getHTML() + " Cut</span>", true, new CutCommand(app, this, folder));
- contextMenu.addItem(cut);
- }
+ if (!folder.isInTrash()) {
+ if (canWrite) {
+ MenuItem newFolder = new MenuItem("<span id = 'folderContextMenu.newFolder'>" + AbstractImagePrototype.create(newImages.folderNew()).getHTML() + " New Folder</span>", true, new NewFolderCommand(app, this, folder, images));
+ contextMenu.addItem(newFolder);
+
+ if (!folder.isContainer()) {
+ MenuItem cut = new MenuItem("<span id = 'folderContextMenu.cut'>" + AbstractImagePrototype.create(newImages.cut()).getHTML() + " Cut</span>", true, new CutCommand(app, this, folder));
+ contextMenu.addItem(cut);
+ }
+ }
MenuItem copy = new MenuItem("<span id = 'folderContextMenu.copy'>" + AbstractImagePrototype.create(newImages.copy()).getHTML() + " Copy</span>", true, new CopyCommand(app, this, folder));
contextMenu.addItem(copy);
- if (!app.getClipboard().isEmpty()) {
- pasteItem = new MenuItem("<span id = 'folderContextMenu.paste'>" + AbstractImagePrototype.create(newImages.paste()).getHTML() + " Paste</span>", true, new PasteCommand(app, this, folder));
- contextMenu.addItem(pasteItem);
- }
-
- if (!folder.isContainer()) {
- MenuItem moveToTrash = new MenuItem("<span id = 'folderContextMenu.moveToTrash'>" + AbstractImagePrototype.create(newImages.emptyTrash()).getHTML() + " Move to Trash</span>", true, new ToTrashCommand(app, this, folder));
- contextMenu.addItem(moveToTrash);
-
- MenuItem delete = new MenuItem("<span id = 'folderContextMenu.delete'>" + AbstractImagePrototype.create(newImages.delete()).getHTML() + " Delete</span>", true, new DeleteCommand(app, this, folder, MessagePanel.images));
- contextMenu.addItem(delete);
-
- MenuItem properties = new MenuItem("<span id = 'folderContextMenu.properties'>" + AbstractImagePrototype.create(newImages.viewText()).getHTML() + " Properties</span>", true, new PropertiesCommand(app, this, folder, newImages, 0));
- contextMenu.addItem(properties);
- }
+ if (canWrite) {
+ if (!app.getClipboard().isEmpty()) {
+ pasteItem = new MenuItem("<span id = 'folderContextMenu.paste'>" + AbstractImagePrototype.create(newImages.paste()).getHTML() + " Paste</span>", true, new PasteCommand(app, this, folder));
+ contextMenu.addItem(pasteItem);
+ }
+
+ if (!folder.isContainer()) {
+ MenuItem moveToTrash = new MenuItem("<span id = 'folderContextMenu.moveToTrash'>" + AbstractImagePrototype.create(newImages.emptyTrash()).getHTML() + " Move to Trash</span>", true, new ToTrashCommand(app, this, folder));
+ contextMenu.addItem(moveToTrash);
+
+ MenuItem delete = new MenuItem("<span id = 'folderContextMenu.delete'>" + AbstractImagePrototype.create(newImages.delete()).getHTML() + " Delete</span>", true, new DeleteCommand(app, this, folder, MessagePanel.images));
+ contextMenu.addItem(delete);
+
+ MenuItem properties = new MenuItem("<span id = 'folderContextMenu.properties'>" + AbstractImagePrototype.create(newImages.viewText()).getHTML() + " Properties</span>", true, new PropertiesCommand(app, this, folder, newImages, 0));
+ contextMenu.addItem(properties);
+ }
+ }
}
else {
if (!folder.isTrash()) {
import com.google.gwt.event.dom.client.ClickEvent;\r
import com.google.gwt.event.dom.client.ClickHandler;\r
import com.google.gwt.event.dom.client.KeyCodes;\r
+import com.google.gwt.http.client.Response;\r
import com.google.gwt.i18n.client.DateTimeFormat;\r
import com.google.gwt.user.client.Event.NativePreviewEvent;\r
import com.google.gwt.user.client.ui.Button;\r
private void createFolder() {\r
String name = folderName.getText();\r
String path = folder.getUri() + "/" + name;\r
- PutRequest createFolder = new PutRequest(app.getApiPath(), app.getUsername(), path) {\r
+ PutRequest createFolder = new PutRequest(app.getApiPath(), folder.getOwner(), path) {\r
@Override\r
public void onSuccess(@SuppressWarnings("unused") Resource result) {\r
app.updateFolder(folder, true, null);\r
final String newName = folderName.getText().trim();\r
if (!folder.isContainer() && !folder.getName().equals(newName)) {\r
final String path = folder.getParent().getUri() + "/" + newName;\r
- PutRequest newFolder = new PutRequest(app.getApiPath(), app.getUsername(), path) {\r
+ PutRequest newFolder = new PutRequest(app.getApiPath(), folder.getParent().getOwner(), path) {\r
@Override\r
public void onSuccess(@SuppressWarnings("unused") Resource result) {\r
Iterator<File> iter = folder.getFiles().iterator();\r
- app.copyFiles(iter, folder.getParent().getUri() + "/" + newName, new Command() {\r
+ app.copyFiles(iter, folder.getParent().getOwner(), folder.getParent().getUri() + "/" + newName, new Command() {\r
@Override\r
public void execute() {\r
Iterator<Folder> iterf = folder.getSubfolders().iterator();\r
- app.copySubfolders(iterf, folder.getParent().getUri() + "/" + newName, new Command() {\r
+ app.copySubfolders(iterf, folder.getParent().getOwner(), folder.getParent().getUri() + "/" + newName, new Command() {\r
@Override\r
public void execute() {\r
app.deleteFolder(folder);\r
updateMetadata(folder.getUri() + "?update=", perms);\r
}\r
\r
- protected void updateMetadata(String path, Map<String, Boolean[]> newPermissions) {\r
+ protected void updateMetadata(final String path, final Map<String, Boolean[]> newPermissions) {\r
if (newPermissions != null) {\r
PostRequest updateFolder = new PostRequest(app.getApiPath(), folder.getOwner(), path) {\r
@Override\r
@Override\r
public void onError(Throwable t) {\r
GWT.log("", t);\r
- app.displayError("System error modifying folder: " + t.getMessage());\r
+ if (t instanceof RestException) {\r
+ if (((RestException) t).getHttpStatusCode() == Response.SC_NOT_FOUND) { //Probably a virtual folder\r
+ final String path1 = folder.getUri();\r
+ PutRequest newFolder = new PutRequest(app.getApiPath(), folder.getOwner(), path1) {\r
+ @Override\r
+ public void onSuccess(@SuppressWarnings("unused") Resource result) {\r
+ updateMetadata(path, newPermissions);\r
+ }\r
+\r
+ @Override\r
+ public void onError(Throwable t) {\r
+ GWT.log("", t);\r
+ if(t instanceof RestException){\r
+ app.displayError("Unable to update folder: " + ((RestException) t).getHttpStatusText());\r
+ }\r
+ else\r
+ app.displayError("System error modifying folder: " + t.getMessage());\r
+ }\r
+ };\r
+ newFolder.setHeader("X-Auth-Token", app.getToken());\r
+ newFolder.setHeader("Content-Type", "application/folder");\r
+ newFolder.setHeader("Accept", "*/*");\r
+ newFolder.setHeader("Content-Length", "0");\r
+ Scheduler.get().scheduleDeferred(newFolder);\r
+ }\r
+ }\r
+ else\r
+ app.displayError("System error modifying folder: " + t.getMessage());\r
}\r
};\r
updateFolder.setHeader("X-Auth-Token", app.getToken());\r
public void onValueChange(ValueChangeEvent<Boolean> booleanValueChangeEvent) {
Boolean[] ps = permissions.get(user);
ps[0] = booleanValueChangeEvent.getValue();
+ hasChanges = true;
}
});
write.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
public void onValueChange(ValueChangeEvent<Boolean> booleanValueChangeEvent) {
Boolean[] ps = permissions.get(user);
ps[1] = booleanValueChangeEvent.getValue();
+ hasChanges = true;
}
});
PushButton removeButton = new PushButton(AbstractImagePrototype.create(images.delete()).createImage(), new ClickHandler() {
*/
private String token;
- protected SingleSelectionModel<Folder> folderTreeSelectionModel;
- protected FolderTreeViewModel folderTreeViewModel;
- protected FolderTreeView folderTreeView;
+ SingleSelectionModel<Folder> folderTreeSelectionModel;
+ FolderTreeViewModel folderTreeViewModel;
+ FolderTreeView folderTreeView;
- protected SingleSelectionModel<Folder> mysharedTreeSelectionModel;
+ SingleSelectionModel<Folder> mysharedTreeSelectionModel;
private MysharedTreeViewModel mysharedTreeViewModel;
- private MysharedTreeView mysharedTreeView;
+ MysharedTreeView mysharedTreeView;
protected SingleSelectionModel<Folder> otherSharedTreeSelectionModel;
private OtherSharedTreeViewModel otherSharedTreeViewModel;
- private OtherSharedTreeView otherSharedTreeView;
+ OtherSharedTreeView otherSharedTreeView;
protected SingleSelectionModel<Tag> tagTreeSelectionModel;
private TagTreeViewModel tagTreeViewModel;
private GroupTreeViewModel groupTreeViewModel;
private GroupTreeView groupTreeView;
+ private TreeView selectedTree;
protected AccountResource account;
private Folder trash;
@SuppressWarnings("rawtypes")
private List<SingleSelectionModel> selectionModels = new ArrayList<SingleSelectionModel>();
+
+ Button upload;
+
+ private HTML totalFiles;
+
+ private HTML usedBytes;
+
+ private HTML totalBytes;
+
+ private HTML usedPercent;
@Override
public void onModuleLoad() {
rightside.addStyleName("pithos-rightSide");
rightside.setSpacing(5);
- PushButton parentButton = new PushButton(new Image(images.asc()), new ClickHandler() {
- @Override
- public void onClick(@SuppressWarnings("unused") ClickEvent event) {
-
- }
- });
- parentButton.addStyleName("pithos-parentButton");
- rightside.add(parentButton);
-
HTML folderStatistics = new HTML("5 Files (size: 1.1GB)");
folderStatistics.addStyleName("pithos-folderStatistics");
rightside.add(folderStatistics);
@Override
public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
if (folderTreeSelectionModel.getSelectedObject() != null) {
- deselectOthers(folderTreeSelectionModel);
+ deselectOthers(folderTreeView, folderTreeSelectionModel);
+ applyPermissions(folderTreeSelectionModel.getSelectedObject());
Folder f = folderTreeSelectionModel.getSelectedObject();
updateFolder(f, true, null);
}
@Override
public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
if (mysharedTreeSelectionModel.getSelectedObject() != null) {
- deselectOthers(mysharedTreeSelectionModel);
+ deselectOthers(mysharedTreeView, mysharedTreeSelectionModel);
+ upload.setEnabled(false);
updateSharedFolder(mysharedTreeSelectionModel.getSelectedObject(), true);
}
}
@Override
public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
if (otherSharedTreeSelectionModel.getSelectedObject() != null) {
- deselectOthers(otherSharedTreeSelectionModel);
+ deselectOthers(otherSharedTreeView, otherSharedTreeSelectionModel);
+ applyPermissions(otherSharedTreeSelectionModel.getSelectedObject());
updateOtherSharedFolder(otherSharedTreeSelectionModel.getSelectedObject(), true);
}
}
otherSharedTreeViewModel = new OtherSharedTreeViewModel(this, otherSharedTreeSelectionModel);
otherSharedTreeView = new OtherSharedTreeView(otherSharedTreeViewModel);
- tagTreeSelectionModel = new SingleSelectionModel<Tag>();
- tagTreeSelectionModel.addSelectionChangeHandler(new Handler() {
- @Override
- public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
- if (tagTreeSelectionModel.getSelectedObject() != null) {
- deselectOthers(tagTreeSelectionModel);
- Tag t = tagTreeSelectionModel.getSelectedObject();
- updateTag(t);
- }
- }
- });
- selectionModels.add(tagTreeSelectionModel);
- tagTreeViewModel = new TagTreeViewModel(this, tagTreeSelectionModel);
- tagTreeView = new TagTreeView(tagTreeViewModel);
-
groupTreeViewModel = new GroupTreeViewModel(this);
groupTreeView = new GroupTreeView(groupTreeViewModel);
VerticalPanel trees = new VerticalPanel();
- Button upload = new Button("Upload File", new ClickHandler() {
+ upload = new Button("Upload File", new ClickHandler() {
@Override
public void onClick(@SuppressWarnings("unused") ClickEvent event) {
- new UploadFileCommand(Pithos.this, null, folderTreeView.getSelection()).execute();
+ new UploadFileCommand(Pithos.this, null, getSelection()).execute();
}
});
upload.addStyleName("pithos-uploadButton");
HorizontalPanel treeHeader = new HorizontalPanel();
treeHeader.addStyleName("pithos-treeHeader");
- treeHeader.add(new HTML("Total Files: 6 | Used: 2.1 of 50 GB (4.2%)"));
+ HorizontalPanel statistics = new HorizontalPanel();
+ statistics.add(new HTML("Total Files: "));
+ totalFiles = new HTML();
+ statistics.add(totalFiles);
+ statistics.add(new HTML(" | Used: "));
+ usedBytes = new HTML();
+ statistics.add(usedBytes);
+ statistics.add(new HTML(" of "));
+ totalBytes = new HTML();
+ statistics.add(totalBytes);
+ statistics.add(new HTML(" ("));
+ usedPercent = new HTML();
+ statistics.add(usedPercent);
+ statistics.add(new HTML("%)"));
+ treeHeader.add(statistics);
trees.add(treeHeader);
trees.add(folderTreeView);
});
}
- @SuppressWarnings({ "rawtypes", "unchecked" })
- public void deselectOthers(SingleSelectionModel model) {
+ public void applyPermissions(Folder f) {
+ if (f != null) {
+ if (f.isInTrash())
+ upload.setEnabled(false);
+ else {
+ Boolean[] perms = f.getPermissions().get(username);
+ if (f.getOwner().equals(username) || (perms != null && perms[1] != null && perms[1])) {
+ upload.setEnabled(true);
+ }
+ else
+ upload.setEnabled(false);
+ }
+ }
+ else
+ upload.setEnabled(false);
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ public void deselectOthers(TreeView _selectedTree, SingleSelectionModel model) {
+ selectedTree = _selectedTree;
for (SingleSelectionModel s : selectionModels)
if (!s.equals(model))
s.setSelected(s.getSelectedObject(), false);
*/
protected void authenticateUser() {
Configuration conf = (Configuration) GWT.create(Configuration.class);
- Window.Location.assign(Window.Location.getHost() + conf.loginUrl() + "?next=" + Window.Location.getHref());
+ Window.Location.assign(conf.loginUrl() + "?next=" + Window.Location.getHref());
}
protected void fetchAccount() {
}
folderTreeViewModel.initialize(account);
groupTreeViewModel.initialize();
+ updateStatistics();
}
}
Scheduler.get().scheduleDeferred(getAccount);
}
- protected void createHomeContainer(final AccountResource account) {
+ protected void updateStatistics() {
+ totalFiles.setHTML(String.valueOf(account.getNumberOfObjects()));
+ usedBytes.setHTML(String.valueOf(account.getFileSizeAsString()));
+ totalBytes.setHTML(String.valueOf(account.getQuotaAsString()));
+ usedPercent.setHTML(String.valueOf(account.getUsedPercentage()));
+ }
+
+ protected void createHomeContainer(final AccountResource account) {
String path = "/" + Pithos.HOME_CONTAINER;
PutRequest createPithos = new PutRequest(getApiPath(), getUsername(), path) {
@Override
}
public void deleteFolder(final Folder folder) {
- String path = getApiPath() + getUsername() + "/" + folder.getContainer() + "?format=json&delimiter=/&prefix=" + folder.getPrefix();
+ String path = getApiPath() + folder.getOwner() + "/" + folder.getContainer() + "?format=json&delimiter=/&prefix=" + folder.getPrefix();
RequestBuilder builder = new RequestBuilder(RequestBuilder.GET, path);
builder.setHeader("If-Modified-Since", "0");
builder.setHeader("X-Auth-Token", getToken());
if (o != null && !o.containsKey("subdir")) {
JSONString name = o.get("name").isString();
String path = "/" + folder.getContainer() + "/" + name.stringValue();
- DeleteRequest delete = new DeleteRequest(getApiPath(), getUsername(), path) {
+ DeleteRequest delete = new DeleteRequest(getApiPath(), folder.getOwner(), path) {
@Override
public void onSuccess(@SuppressWarnings("unused") Resource result) {
deleteObject(folder, i + 1, array);
return folderTreeView;
}
- public void copyFiles(final Iterator<File> iter, final String targetUri, final Command callback) {
+ public void copyFiles(final Iterator<File> iter, final String targetUsername, final String targetUri, final Command callback) {
if (iter.hasNext()) {
File file = iter.next();
String path = targetUri + "/" + file.getName();
- PutRequest copyFile = new PutRequest(getApiPath(), getUsername(), path) {
+ PutRequest copyFile = new PutRequest(getApiPath(), targetUsername, path) {
@Override
public void onSuccess(@SuppressWarnings("unused") Resource result) {
- copyFiles(iter, targetUri, callback);
+ copyFiles(iter, targetUsername, targetUri, callback);
}
@Override
}
}
- public void copySubfolders(final Iterator<Folder> iter, final String targetUri, final Command callback) {
+ public void copySubfolders(final Iterator<Folder> iter, final String targetUsername, final String targetUri, final Command callback) {
if (iter.hasNext()) {
final Folder f = iter.next();
- copyFolder(f, targetUri, callback);
+ copyFolder(f, targetUsername, targetUri, callback);
}
else if (callback != null) {
callback.execute();
}
}
- public void copyFolder(final Folder f, final String targetUri, final Command callback) {
+ public void copyFolder(final Folder f, final String targetUsername, final String targetUri, final Command callback) {
String path = targetUri + "/" + f.getName();
- PutRequest createFolder = new PutRequest(getApiPath(), getUsername(), path) {
+ PutRequest createFolder = new PutRequest(getApiPath(), targetUsername, path) {
@Override
public void onSuccess(@SuppressWarnings("unused") Resource result) {
Iterator<File> iter = f.getFiles().iterator();
- copyFiles(iter, targetUri + "/" + f.getName(), new Command() {
+ copyFiles(iter, targetUsername, targetUri + "/" + f.getName(), new Command() {
@Override
public void execute() {
Iterator<Folder> iterf = f.getSubfolders().iterator();
- copySubfolders(iterf, targetUri + "/" + f.getName(), new Command() {
+ copySubfolders(iterf, targetUsername, targetUri + "/" + f.getName(), new Command() {
@Override
public void execute() {
callback.execute();
account.removeGroup(group);
updateGroupsNode();
}
+
+ public TreeView getSelectedTree() {
+ return selectedTree;
+ }
+
+ public Folder getSelection() {
+ return selectedTree.getSelection();
+ }
}
--- /dev/null
+package gr.grnet.pithos.web.client;
+
+import gr.grnet.pithos.web.client.foldertree.Folder;
+
+public interface TreeView {
+ public Folder getSelection();
+}
downloadHtml.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
- String fileUrl = app.getApiPath() + app.getUsername() + file.getUri() + "?X-Auth-Token=" + app.getToken() + "&version=" + v.getVersion();
+ String fileUrl = app.getApiPath() + file.getOwner() + file.getUri() + "?X-Auth-Token=" + app.getToken() + "&version=" + v.getVersion();
Window.open(fileUrl, "_BLANK", "");
}
});
*/
package gr.grnet.pithos.web.client.commands;
+import java.util.Iterator;
+
import gr.grnet.pithos.web.client.Pithos;
+import gr.grnet.pithos.web.client.foldertree.File;
+import gr.grnet.pithos.web.client.foldertree.Folder;
+import gr.grnet.pithos.web.client.foldertree.Resource;
+import gr.grnet.pithos.web.client.rest.DeleteRequest;
+import gr.grnet.pithos.web.client.rest.RestException;
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.Scheduler;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.ui.PopupPanel;
public class EmptyTrashCommand implements Command{
private PopupPanel containerPanel;
- private Pithos app;
+ Pithos app;
public EmptyTrashCommand(Pithos _app, PopupPanel _containerPanel){
app = _app;
public void execute() {
if (containerPanel != null)
containerPanel.hide();
+
+ final Folder trash = app.getAccount().getTrash();
+ if (trash != null) {
+ Iterator<File> iter = trash.getFiles().iterator();
+ deleteFile(iter, new Command() {
+
+ @Override
+ public void execute() {
+ Iterator<Folder> iter2 = trash.getSubfolders().iterator();
+ deleteSubfolder(iter2, new Command() {
+
+ @Override
+ public void execute() {
+ app.updateTrash(true, null);
+ }
+ });
+ }
+ });
+ }
+ }
+
+ protected void deleteSubfolder(final Iterator<Folder> iter2, final Command callback) {
+ if (iter2.hasNext()) {
+ final Folder f = iter2.next();
+ Iterator<File> iter3 = f.getFiles().iterator();
+ deleteFile(iter3, new Command() {
+
+ @Override
+ public void execute() {
+ Iterator<Folder> iter4 = f.getSubfolders().iterator();
+ deleteSubfolder(iter4, new Command() {
+
+ @Override
+ public void execute() {
+ String path = f.getUri();
+ DeleteRequest deleteF = new DeleteRequest(app.getApiPath(), f.getOwner(), path) {
+
+ @Override
+ public void onSuccess(Resource result) {
+ deleteSubfolder(iter2, callback);
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ GWT.log("", t);
+ if (t instanceof RestException) {
+ app.displayError("Unable to delete file:" + ((RestException) t).getHttpStatusText());
+ }
+ else
+ app.displayError("System error deleting file:" + t.getMessage());
+ }
+ };
+ deleteF.setHeader("X-Auth-Token", app.getToken());
+ Scheduler.get().scheduleDeferred(deleteF);
+ }
+ });
+ }
+ });
+ }
+ else {
+ if (callback != null)
+ callback.execute();
+ }
+ }
+
+ void deleteFile(final Iterator<File> iter, final Command callback) {
+ if (iter.hasNext()) {
+ File f = iter.next();
+ String path = f.getUri();
+ DeleteRequest deleteF = new DeleteRequest(app.getApiPath(), f.getOwner(), path) {
+
+ @Override
+ public void onSuccess(Resource result) {
+ deleteFile(iter, callback);
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ GWT.log("", t);
+ if (t instanceof RestException) {
+ app.displayError("Unable to delete file:" + ((RestException) t).getHttpStatusText());
+ }
+ else
+ app.displayError("System error deleting file:" + t.getMessage());
+ }
+ };
+ deleteF.setHeader("X-Auth-Token", app.getToken());
+ Scheduler.get().scheduleDeferred(deleteF);
+ }
+ else {
+ if (callback != null)
+ callback.execute();
+ }
}
}
if (clipboardItem instanceof Folder) {
final Folder tobeCopied = (Folder) clipboardItem;
if (operation == Clipboard.COPY) {
- app.copyFolder(tobeCopied, folder.getUri(), new Command() {
+ app.copyFolder(tobeCopied, folder.getOwner(), folder.getUri(), new Command() {
@Override
public void execute() {
app.getClipboard().clear();
});
}
else {
- app.copyFolder(tobeCopied, folder.getUri(), new Command() {
+ app.copyFolder(tobeCopied, folder.getOwner(), folder.getUri(), new Command() {
@Override
public void execute() {
app.getClipboard().clear();
List<File> tobeCopied = (List<File>) clipboardItem;
Iterator<File> iter = tobeCopied.iterator();
if (operation == Clipboard.COPY) {
- app.copyFiles(iter, folder.getUri(), new Command() {
+ app.copyFiles(iter, folder.getOwner(), folder.getUri(), new Command() {
@Override
public void execute() {
app.getClipboard().clear();
if (iter.hasNext()) {
File file = iter.next();
String path = folder.getUri() + "/" + file.getName();
- PutRequest copyFile = new PutRequest(app.getApiPath(), app.getUsername(), path) {
+ PutRequest copyFile = new PutRequest(app.getApiPath(), folder.getOwner(), path) {
@Override
public void onSuccess(@SuppressWarnings("unused") Resource result) {
moveFiles(iter, callback);
return getSize(bytesUsed , (1024D*1024D*1024D)) + " GB";
}
- public String getQuotaLeftAsString() {
- if (bytesRemaining < 1024)
- return String.valueOf(bytesRemaining) + " B";
- else if (bytesRemaining < 1024 * 1024)
- return getSize(bytesRemaining, 1024D) + " KB";
- else if (bytesRemaining < 1024 * 1024 * 1024)
- return getSize(bytesRemaining,(1024D * 1024D)) + " MB";
- return getSize(bytesRemaining , (1024D * 1024D * 1024D)) + " GB";
+ public String getQuotaAsString() {
+ long quota = bytesUsed + bytesRemaining;
+ if (quota < 1024)
+ return String.valueOf(quota) + " B";
+ else if (quota < 1024 * 1024)
+ return getSize(quota, 1024D) + " KB";
+ else if (quota < 1024 * 1024 * 1024)
+ return getSize(quota,(1024D * 1024D)) + " MB";
+ return getSize(quota , (1024D * 1024D * 1024D)) + " GB";
}
public List<Group> getGroups() {
public void removeGroup(Group group) {
groups.remove(group);
}
+
+ public Folder getTrash() {
+ for (Folder c : containers) {
+ if (c.getName().equals(Pithos.TRASH_CONTAINER))
+ return c;
+ }
+ return null;
+ }
+
+ public double getUsedPercentage() {
+ return 100.0 * bytesUsed / (bytesUsed + bytesRemaining);
+ }
}
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.Tree;
import gr.grnet.pithos.web.client.FolderContextMenu;
+import gr.grnet.pithos.web.client.TreeView;
-public class FolderTreeView extends Composite {
+public class FolderTreeView extends Composite implements TreeView {
public void updateChildren(Folder folder) {
TreeNode root = ((CellTree) getWidget()).getRootTreeNode();
private void updateChildren(TreeNode node, Folder folder) {
for (int i=0; i<node.getChildCount(); i++) {
- if (node.isChildOpen(i)) {
- if (folder.equals(node.getChildValue(i))) {
- node.setChildOpen(i, false, true);
- node.setChildOpen(i, true, true);
- }
- else {
+ if (folder.equals(node.getChildValue(i))) {
+ node.setChildOpen(i, false, true);
+ node.setChildOpen(i, true, true);
+ }
+ else {
+ if (node.isChildOpen(i)) {
TreeNode n = node.setChildOpen(i, true);
updateChildren(n, folder);
}
}
- }
+ }
}
static interface BasicResources extends CellTree.Resources {
final Folder f = iter.next();
String path = "/" + f.getContainer() + "?format=json&delimiter=/&prefix=" + f.getPrefix();
- GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), app.getUsername(), path, f) {
+ GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), f.getOwner(), path, f) {
@Override
public void onSuccess(@SuppressWarnings("unused") Folder _result) {
fetchFolder(iter, callback);
@Override
public void execute() {
String path = "/" + f.getContainer() + "?format=json&delimiter=/&prefix=" + f.getPrefix();
- GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), app.getUsername(), path, f) {
+ GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), f.getOwner(), path, f) {
@Override
public void onSuccess(final Folder _result) {
if (showfiles)
package gr.grnet.pithos.web.client.mysharedtree;
import gr.grnet.pithos.web.client.FolderContextMenu;
+import gr.grnet.pithos.web.client.TreeView;
import gr.grnet.pithos.web.client.foldertree.Folder;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.Tree;
-public class MysharedTreeView extends Composite {
+public class MysharedTreeView extends Composite implements TreeView {
public void updateChildren(Folder folder) {
TreeNode root = ((CellTree) getWidget()).getRootTreeNode();
protected Pithos app;
- private Cell<Folder> folderCell = new AbstractCell<Folder>(ContextMenuEvent.getType().getName()) {
+ private Cell<Folder> folderCell = new AbstractCell<Folder>() {
@Override
public void render(@SuppressWarnings("unused") Context context, Folder folder, SafeHtmlBuilder safeHtmlBuilder) {
@Override
public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
if (selectionModel2.getSelectedObject() != null) {
- app.deselectOthers(selectionModel2);
+ app.deselectOthers(app.getMySharedTreeView(), selectionModel2);
+ app.applyPermissions(null);
fetchSharedFiles();
}
}
final Folder f = iter.next();
String path = "/" + f.getContainer() + "?format=json&delimiter=/&prefix=" + f.getPrefix();
- GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), app.getUsername(), path, f) {
+ GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), f.getOwner(), path, f) {
@Override
public void onSuccess(Folder _result) {
if (!_result.isShared()) {
public void fetchFolder(final Folder f, final ListDataProvider<Folder> dataProvider, final boolean showfiles) {
String path = "/" + f.getContainer() + "?format=json&delimiter=/&prefix=" + f.getPrefix();
- GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), app.getUsername(), path, f) {
+ GetRequest<Folder> getFolder = new GetRequest<Folder>(Folder.class, app.getApiPath(), f.getOwner(), path, f) {
@Override
public void onSuccess(final Folder _result) {
if (showfiles)
package gr.grnet.pithos.web.client.othersharedtree;
import gr.grnet.pithos.web.client.FolderContextMenu;
+import gr.grnet.pithos.web.client.TreeView;
import gr.grnet.pithos.web.client.foldertree.Folder;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.Tree;
-public class OtherSharedTreeView extends Composite {
+public class OtherSharedTreeView extends Composite implements TreeView {
public void updateChildren(Folder folder) {
TreeNode root = ((CellTree) getWidget()).getRootTreeNode();
@Override
public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
if (selectionModel2.getSelectedObject() != null) {
- app.deselectOthers(selectionModel2);
+ app.deselectOthers(app.getOtherSharedTreeView(), selectionModel2);
+ app.applyPermissions(null);
app.showFiles(new HashSet<File>());
}
}
@Override
public void onSelectionChange(@SuppressWarnings("unused") SelectionChangeEvent event) {
if (selectionModel3.getSelectedObject() != null) {
- app.deselectOthers(selectionModel3);
+ app.deselectOthers(app.getOtherSharedTreeView(), selectionModel3);
+ app.applyPermissions(null);
String username = selectionModel3.getSelectedObject();
+ if (userDataProviderMap.get(username) == null) {
+ userDataProviderMap.put(username, new ListDataProvider<Folder>());
+ }
fetchSharedFiles(username, userDataProviderMap.get(username));
}
}