コード例 #1
0
ファイル: resource.py プロジェクト: Purg/girder
    def _lookUpPath(self, path, user, test=False):
        """
        Look up a resource in the data hierarchy by path.

        :param path: path of the resource
        :param user: user with correct privileges to access path
        :param test: defaults to false, when set to true
            will return None instead of throwing exception when
            path doesn't exist
        """
        path = path.lstrip('/')
        pathArray = path_util.split(path)
        model = pathArray[0]

        parent = None
        if model == 'user':
            username = pathArray[1]
            parent = self.model('user').findOne({'login': username})

            if parent is None:
                if test:
                    return None
                else:
                    raise RestException('User not found: %s' % username)

        elif model == 'collection':
            collectionName = pathArray[1]
            parent = self.model('collection').findOne({'name': collectionName})

            if parent is None:
                if test:
                    return None
                else:
                    raise RestException(
                        'Collection not found: %s' % collectionName)

        else:
            raise RestException('Invalid path format')

        try:
            document = parent
            self.model(model).requireAccess(document, user)
            for token in pathArray[2:]:
                document, model = self._lookUpToken(token, model, document)
                self.model(model).requireAccess(document, user)
        except RestException:
            if test:
                return None
            else:
                raise RestException('Path not found: %s' % path)

        result = self.model(model).filter(document, user)
        return result
コード例 #2
0
ファイル: resource.py プロジェクト: chapmanbe/girder
    def _lookUpPath(self, path, user, test=False):
        """
        Look up a resource in the data hierarchy by path.

        :param path: path of the resource
        :param user: user with correct privileges to access path
        :param test: defaults to false, when set to true
            will return None instead of throwing exception when
            path doesn't exist
        """
        path = path.lstrip('/')
        pathArray = path_util.split(path)
        model = pathArray[0]

        parent = None
        if model == 'user':
            username = pathArray[1]
            parent = self.model('user').findOne({'login': username})

            if parent is None:
                if test:
                    return None
                else:
                    raise RestException('User not found: %s' % username)

        elif model == 'collection':
            collectionName = pathArray[1]
            parent = self.model('collection').findOne({'name': collectionName})

            if parent is None:
                if test:
                    return None
                else:
                    raise RestException(
                        'Collection not found: %s' % collectionName)

        else:
            raise RestException('Invalid path format')

        try:
            document = parent
            self.model(model).requireAccess(document, user)
            for token in pathArray[2:]:
                document, model = self._lookUpToken(token, model, document)
                self.model(model).requireAccess(document, user)
        except RestException:
            if test:
                return None
            else:
                raise RestException('Path not found: %s' % path)

        result = self.model(model).filter(document, user)
        return result
コード例 #3
0
ファイル: population.py プロジェクト: girder/geo_browser
def populate(ids, paths, data):
    if not (ids or paths):
        click.echo('Error: No destination specified')
        return

    data = json.load(open(data, 'r'))
    totalTargets = len(ids) + len(paths)
    success = 0

    for collectionId in ids:
        collection = Collection().findOne({'_id': ObjectId(collectionId)})

        if (collection):
            Collection().setMetadata(collection=collection, metadata=data)
            success += 1
        else:
            click.echo('Warning: No collection found with ID: ' + collectionId)

    for path in paths:
        # Truncates anything past the collection level
        path = '/'.join(split(path.lstrip('/'))[0:2])

        try:
            doc = lookUpPath(path, force=True)
            if doc['model'] != 'collection':
                click.echo('Warning: Ignoring non-collection path: ' + path)
                continue
            doc = doc['document']
        except (ResourcePathNotFound):
            name = split(path)[1]
            doc = Collection().createCollection(name, reuseExisting=True)

        Collection().setMetadata(collection=doc, metadata=data)
        success += 1

    click.echo('Successfully set metadata on ' + str(success) + '/' +
               str(totalTargets) + ' targets')
コード例 #4
0
 def _get_vobject(self, document, path, i):
     pathArray = split(path)
     root = document
     n = 3 + i
     fspath = os.path.join(document["fsPath"], "/".join(pathArray[n:]))
     fspath = pathlib.Path(fspath)
     if not fspath.exists():
         raise ValidationException("Path not found: %s" % path)
     if fspath.is_dir():
         document = self.vFolder(fspath, root)
         model = "folder"
     elif fspath.is_file():
         document = self.vItem(fspath, root)
         model = "item"
     # TODO: add vLink here...
     return document, model
コード例 #5
0
    def _lookUpPath(self, path, user=None, test=False, filter=True, force=False):
        """
        Look up a resource in the data hierarchy by path.

        :param path: path of the resource
        :param user: user with correct privileges to access path
        :param test: defaults to false, when set to true
            will return None instead of throwing exception when
            path doesn't exist
        :type test: bool
        :param filter: Whether the returned model should be filtered.
        :type filter: bool
        :param force: if True, don't validate the access.
        :type force: bool
        """
        path = path.lstrip("/")
        pathArray = split(path)

        try:
            document, model = self._get_base(pathArray, test=test)
        except EmptyDocument:
            return {"model": None, "document": None}

        try:
            if not force:
                ModelImporter.model(model).requireAccess(document, user)
            for i, token in enumerate(pathArray[2:]):  # noqa
                document, model = lookUpToken(token, model, document)
                if not force:
                    ModelImporter.model(model).requireAccess(document, user)
                if "fsPath" in document:
                    break
            if token != pathArray[-1]:
                document, model = self._get_vobject(document, path, i)
        except (ValidationException, AccessException):
            if test:
                return {"model": None, "document": None}
            raise ResourcePathNotFound("Path not found: %s" % path)

        if filter:
            document = ModelImporter.model(model).filter(document, user)

        return {"model": model, "document": document}
コード例 #6
0
 def testSplitPath(self):
     for pth, tokens in paths:
         self.assertEqual(path.split(pth), tokens)
コード例 #7
0
 def testSplitPath(self):
     for pth, tokens in paths:
         self.assertEqual(path.split(pth), tokens)
コード例 #8
0
def testSplitAndJoin(pth, tokens):
    assert path.split(pth) == tokens
    assert path.join(tokens) == pth