Ejemplo n.º 1
0
    def testChgrpImage(self):
        """
        Tests chgrp for a dummny image object (no Pixels)
        """
        # One user in two groups
        client, exp = self.new_client_and_user()
        grp = self.new_group([exp])
        gid = grp.id.val
        client.sf.getAdminService().getEventContext()  # Reset session
        update = client.sf.getUpdateService()
        query = client.sf.getQueryService()
        admin = client.sf.getAdminService()
        first_gid = admin.getEventContext().groupId

        # Create a dataset in the 'first group'
        ds = self.make_dataset(name="testChgrpImage_target", client=client)
        ds_id = ds.id.val

        # Change our context to new group and create image
        admin.setDefaultGroup(exp, ExperimenterGroupI(gid, False))
        self.set_context(client, gid)
        update = client.sf.getUpdateService()  # do we need to get this again?
        img = self.new_image()
        img = update.saveAndReturnObject(img)

        # Move image to new group
        chgrp = Chgrp2(targetObjects={'Image': [img.id.val]},
                       groupId=first_gid)

        # Link to Save
        link = DatasetImageLinkI()
        link.child = ImageI(img.id.val, False)
        link.parent = DatasetI(ds_id, False)
        save = Save()
        save.obj = link
        requests = [chgrp, save]  # we're going to chgrp THEN save DIlink

        # Change our context to original group...
        admin.setDefaultGroup(exp, ExperimenterGroupI(first_gid, False))
        self.set_context(client, first_gid)

        # We have to be in destination group for link Save to work
        self.doSubmit(requests, client)

        # ...check image
        img = client.sf.getQueryService().get("Image", img.id.val)
        assert img.details.group.id.val == first_gid
        # check Dataset
        query = "select link from DatasetImageLink link\
            where link.child.id=%s" % img.id.val
        l = client.sf.getQueryService().findByQuery(query, None)
        assert l is not None, "New DatasetImageLink on image not found"
        assert l.details.group.id.val == first_gid,\
            "Link Created in same group as Image target"
Ejemplo n.º 2
0
 def createGroup(self, name, owners, perm, r=None, description=None):
     new_gr = ExperimenterGroupI()
     new_gr.name = rstring(str(name))
     new_gr.description = (description!="" and description is not None) and rstring(str(description)) or None
     new_gr.details.permissions = self.setActualPermissions(perm, r)
     
     listOfOwners = set()
     for e in self.experimenters:
         for o in owners:
             if long(o) == e.id:
                 listOfOwners.add(e._obj)
     
     return self.conn.createGroup(new_gr, list(listOfOwners))
Ejemplo n.º 3
0
 def new_group(self, experimenters=None, perms=None, config=None, gname=None):
     admin = self.root.sf.getAdminService()
     if gname is None:
         gname = self.uuid()
     group = ExperimenterGroupI()
     group.name = rstring(gname)
     group.ldap = rbool(False)
     group.config = config
     if perms:
         group.details.permissions = PermissionsI(perms)
     gid = admin.createGroup(group)
     group = admin.getGroup(gid)
     self.add_experimenters(group, experimenters)
     return group
Ejemplo n.º 4
0
    def testChgrpPDI(self):
        """
        Tests chgrp for a Project, Dataset, Image hierarchy
        """
        # One user in two groups
        client, exp = self.new_client_and_user()
        grp = self.new_group([exp])
        gid = grp.id.val
        client.sf.getAdminService().getEventContext()  # Reset session

        # Data Setup (image in the P/D hierarchy)
        img = self.make_image(client=client)
        project = self.make_project(name="chgrp-test", client=client)
        dataset = self.make_dataset(name="chgrp-test", client=client)
        self.link(dataset, img, client=client)
        self.link(project, dataset, client=client)

        # Move Project to new group
        chgrp = Chgrp2(targetObjects={'Project': [project.id.val]},
                       groupId=gid)
        self.doSubmit(chgrp, client)

        # Change our context to new group...
        admin = client.sf.getAdminService()
        admin.setDefaultGroup(exp, ExperimenterGroupI(gid, False))
        self.set_context(client, gid)
        # ...check image
        img = client.sf.getQueryService().get("Image", img.id.val)
        assert img.details.group.id.val == gid
        # check Project
        prj = client.sf.getQueryService().get("Project", project.id.val)
        assert prj.details.group.id.val == gid
Ejemplo n.º 5
0
    def testChgrpImportedImage(self):
        """
        Tests chgrp for an imported image, moving to a collaborative group
        """
        # One user in two groups
        client, exp = self.new_client_and_user()
        grp = self.new_group(experimenters=[exp], perms=COLLAB)
        gid = grp.id.val
        client.sf.getAdminService().getEventContext()  # Reset session

        # Import an image into the client context
        image = self.importSingleImage(name="testChgrpImportedImage",
                                       client=client)

        # Chgrp
        chgrp = Chgrp2(targetObjects={'Image': [image.id.val]}, groupId=gid)
        self.doSubmit(chgrp, client)

        # Change our context to new group...
        admin = client.sf.getAdminService()
        admin.setDefaultGroup(exp, ExperimenterGroupI(gid, False))
        self.set_context(client, gid)
        # ...check image
        img = client.sf.getQueryService().get("Image", image.id.val)
        assert img.details.group.id.val == gid
Ejemplo n.º 6
0
    def test_chown_pdi(self):
        """
        Tests chown for a Project, Dataset and Image hierarchy
        """
        # Two users in new group. First user is group owner.
        client, exp = self.new_client_and_user(owner=True)
        gid = client.sf.getAdminService().getEventContext().groupId
        new_owner = self.new_user(ExperimenterGroupI(gid, False))
        oid = new_owner.id.val

        # project belongs to first user
        project = self.make_project(name="chown-test", client=client)
        assert project.details.owner.id.val == exp.id.val

        # Data Setup (image in the P/D hierarchy)
        project = self.make_project(name="chown-test", client=client)
        dataset = self.make_dataset(name="chown-test", client=client)
        image = self.make_image(client=client)
        self.link(dataset, image, client=client)
        self.link(project, dataset, client=client)

        # Chown
        chown = Chown2(targetObjects={'Project': [project.id.val]})
        chown.userId = oid
        self.do_submit(chown, client)

        # check owner of each object...
        project = client.sf.getQueryService().get("Project", project.id.val)
        assert project.details.owner.id.val == oid
        dataset = client.sf.getQueryService().get("Dataset", dataset.id.val)
        assert dataset.details.owner.id.val == oid
        image = client.sf.getQueryService().get("Image", image.id.val)
        assert image.details.owner.id.val == oid
Ejemplo n.º 7
0
 def new_group(self,
               experimenters=None,
               perms=None,
               config=None,
               gname=None):
     admin = self.root.sf.getAdminService()
     if gname is None:
         gname = self.uuid()
     group = ExperimenterGroupI()
     group.name = rstring(gname)
     group.ldap = rbool(False)
     group.config = config
     if perms:
         group.details.permissions = PermissionsI(perms)
     gid = admin.createGroup(group)
     group = admin.getGroup(gid)
     self.add_experimenters(group, experimenters)
     return group
Ejemplo n.º 8
0
    def new_user(self,
                 group=None,
                 perms=None,
                 owner=False,
                 system=False,
                 uname=None,
                 email=None):
        """
        :owner: If user is to be an owner of the created group
        :system: If user is to be a system admin
        """

        if not self.root:
            raise Exception("No root client. Cannot create user")

        adminService = self.root.getSession().getAdminService()
        if uname is None:
            uname = self.uuid()

        # Create group if necessary
        if not group:
            g = self.new_group(perms=perms)
            group = g.name.val
        else:
            g, group = self.group_and_name(group)

        # Create user
        e = ExperimenterI()
        e.omeName = rstring(uname)
        e.firstName = rstring(uname)
        e.lastName = rstring(uname)
        e.ldap = rbool(False)
        e.email = rstring(email)
        listOfGroups = list()
        listOfGroups.append(adminService.lookupGroup('user'))
        uid = adminService.createExperimenterWithPassword(
            e, rstring(uname), g, listOfGroups)
        e = adminService.lookupExperimenter(uname)
        if owner:
            adminService.setGroupOwner(g, e)
        if system:
            adminService.addGroups(e, [ExperimenterGroupI(0, False)])

        return adminService.getExperimenter(uid)
Ejemplo n.º 9
0
    def test_chown_project(self):
        """
        Tests chown for a Project
        """
        # Two users in new group. First user is group owner.
        client, exp = self.new_client_and_user(owner=True)
        gid = client.sf.getAdminService().getEventContext().groupId
        new_owner = self.new_user(ExperimenterGroupI(gid, False))
        oid = new_owner.id.val

        # project belongs to first user
        project = self.make_project(name="chown-test", client=client)
        assert project.details.owner.id.val == exp.id.val

        # Chown
        chown = Chown2(targetObjects={'Project': [project.id.val]})
        chown.userId = oid
        self.do_submit(chown, client)

        # check owner...
        pro = client.sf.getQueryService().get("Project", project.id.val)
        assert pro.details.owner.id.val == oid
Ejemplo n.º 10
0
    def test_chown_project(self):
        """
        Tests chown for a Project
        """
        # Two users in new group. First user is group owner.
        client, exp = self.new_client_and_user(owner=True)
        conn = BlitzGateway(client_obj=client)
        gid = client.sf.getAdminService().getEventContext().groupId
        new_owner = self.new_user(ExperimenterGroupI(gid, False))
        oid = new_owner.id.val

        # project belongs to first user
        project = self.make_project(name="chown-test", client=client)
        assert project.details.owner.id.val == exp.id.val

        # Chown
        proxy = conn.chownObjects("Project", [project.id.val], oid)
        self.wait_on_callback(conn, proxy)

        # check owner...
        pro = client.sf.getQueryService().get("Project", project.id.val)
        assert pro.details.owner.id.val == oid
Ejemplo n.º 11
0
def experimenter_group():
    o = ExperimenterGroupI()
    o.id = rlong(1L)
    o.name = rstring("the_name")
    o.description = rstring("the_description")
    return o
Ejemplo n.º 12
0
def experimenter_group():
    o = ExperimenterGroupI()
    o.id = rlong(1L)
    o.name = rstring('the_name')
    o.description = rstring('the_description')
    return o
Ejemplo n.º 13
0
 def set_context(self, client, gid):
     rv = client.getStatefulServices()
     for prx in rv:
         prx.close()
     client.sf.setSecurityContext(ExperimenterGroupI(gid, False))
Ejemplo n.º 14
0
    def testThumbs(self):

        privateGroup = self.new_group(perms='rw----')
        readOnlyGroup = self.new_group(perms='rwr---')
        collaborativeGroup = self.new_group(perms='rwra--')

        # new user (group owner)
        newOwner = self.new_user(group=privateGroup)
        self.add_groups(newOwner, [readOnlyGroup, collaborativeGroup],
                        owner=True)

        # new user1
        user1 = self.new_user(group=privateGroup)
        self.add_groups(user1, [readOnlyGroup, collaborativeGroup])

        # new user2
        user2 = self.new_user(group=privateGroup)
        self.add_groups(user2, [readOnlyGroup, collaborativeGroup])

        # login as user1 (into their default group)
        # create image in private group
        client_share1 = self.new_client(user=user1, password=user1.omeName.val)
        privateImageId = createTestImage(client_share1.sf)

        # if we don't get thumbnail, test fails when another user does
        self.getThumbnail(client_share1.sf, privateImageId)

        # change user into read-only group. Use object Ids for this,
        # NOT objects from a different context
        a = client_share1.sf.getAdminService()
        me = a.getExperimenter(a.getEventContext().userId)
        a.setDefaultGroup(me, ExperimenterGroupI(readOnlyGroup.id.val, False))
        self.set_context(client_share1, readOnlyGroup.id.val)

        # create image and get thumbnail (in read-only group)
        readOnlyImageId = createTestImage(client_share1.sf)
        self.getThumbnail(client_share1.sf, readOnlyImageId)

        # change user into collaborative group. Use object Ids for this, NOT
        # objects from a different context
        a.setDefaultGroup(me,
                          ExperimenterGroupI(collaborativeGroup.id.val, False))
        self.set_context(client_share1, collaborativeGroup.id.val)

        # create image and get thumbnail (in collaborative group)
        collaborativeImageId = createTestImage(client_share1.sf)
        self.getThumbnail(client_share1.sf, collaborativeImageId)

        # check that we can't get thumbnails for images in other groups
        assert self.getThumbnail(client_share1.sf, privateImageId) is None
        assert self.getThumbnail(client_share1.sf, readOnlyImageId) is None

        # now check that the 'owner' of each group can see all 3 thumbnails.
        # login as owner (into private group)
        owner_client = self.new_client(user=newOwner,
                                       password=newOwner.omeName.val)

        group_ctx = {"omero.group": str(privateGroup)}
        self.getThumbnail(owner_client.sf, privateImageId, *group_ctx)
        # check that we can't get thumbnails for images in other groups
        assert self.getThumbnail(owner_client.sf, readOnlyImageId) is None
        assert self.getThumbnail(owner_client.sf, collaborativeImageId) is None

        # change owner into read-only group.
        o = client_share1.sf.getAdminService()
        me = o.getExperimenter(o.getEventContext().userId)
        o.setDefaultGroup(
            me, omero.model.ExperimenterGroupI(readOnlyGroup.id.val, False))
        self.set_context(owner_client, readOnlyGroup.id.val)

        self.getThumbnail(owner_client.sf, readOnlyImageId)
        # check that we can't get thumbnails for images in other groups
        assert self.getThumbnail(owner_client.sf, privateImageId) is None
        assert self.getThumbnail(owner_client.sf, collaborativeImageId) is None

        # change owner into collaborative group.
        o.setDefaultGroup(
            me, omero.model.ExperimenterGroupI(collaborativeGroup.id.val,
                                               False))
        self.set_context(owner_client, collaborativeGroup.id.val)

        self.getThumbnail(owner_client.sf, collaborativeImageId)
        # check that we can't get thumbnails for images in other groups
        assert self.getThumbnail(owner_client.sf, privateImageId) is None
        assert self.getThumbnail(owner_client.sf, readOnlyImageId) is None

        # now check that the 'user2' of each group can see all thumbnails
        # except private. login as user2 (into private group)
        user2_client = self.new_client(user=user2, password=user2.omeName.val)

        # check that we can't get thumbnails for any images in private group
        assert self.getThumbnail(user2_client.sf, privateImageId) is None
        assert self.getThumbnail(user2_client.sf, readOnlyImageId) is None
        assert self.getThumbnail(user2_client.sf, collaborativeImageId) is None

        # change owner into read-only group.
        u = user2_client.sf.getAdminService()
        me = u.getExperimenter(u.getEventContext().userId)
        u.setDefaultGroup(me, ExperimenterGroupI(readOnlyGroup.id.val, False))
        self.set_context(user2_client, readOnlyGroup.id.val)

        self.getThumbnail(user2_client.sf, readOnlyImageId)
        # check that we can't get thumbnails for images in other groups
        assert self.getThumbnail(user2_client.sf, privateImageId) is None
        assert self.getThumbnail(user2_client.sf, collaborativeImageId) is None

        # change owner into collaborative group.
        u.setDefaultGroup(me,
                          ExperimenterGroupI(collaborativeGroup.id.val, False))
        self.set_context(user2_client, collaborativeGroup.id.val)

        self.getThumbnail(user2_client.sf, collaborativeImageId)
        # check that we can't get thumbnails for images in other groups
        assert self.getThumbnail(user2_client.sf, privateImageId) is None
        assert self.getThumbnail(user2_client.sf, readOnlyImageId) is None
# list users with the 'IDs' parameter
#exp_id = script_params["Experimenter"]
experimenters = conn.getObjects("Experimenter")
exp_ids = []

for e in experimenters:
    print e.id, e.firstName, e.lastName
    if e.id > 1:
        exp_ids.append(e.id)

print "list ids", exp_ids

# move users to a single object, in this case public domain

public_group_id = 5
adminService = conn.getAdminService()

for eid in exp_ids:
    adminService.addGroups(ExperimenterI(eid, False),
                           [ExperimenterGroupI(public_group_id, False)])

# Return some value(s).

# Here, we return anything useful the script has produced.
# NB: The Insight and web clients will display the "Message" output.

msg = "Script ran OK"
client.setOutput("Message", rstring(msg))

client.closeSession()
Ejemplo n.º 16
0
def roi_with_unloaded_details_children(roi):
    roi.details.owner = ExperimenterI(1, False)
    roi.details.group = ExperimenterGroupI(1, False)
    return roi