Attachment #147233 for bug #214666

View | Details | Raw Unified | Return to bug 214666
Collapse All | Expand All




    def close(self):
        """Close the database, after committing any changes, if needed."""

        try:
            self.db.commit()
        finally:
            self.db.close()
            finally:
                self.db.close()


    def get_class(self, classname):
        """Return the class for the given classname."""


    def list(self, username, password, classname, propname=None):
        r = RoundupRequest(self.tracker, username, password)
        try:
            cl = r.get_class(classname)
            if not propname:
                propname = cl.labelprop()
            result = [  cl.get(itemid, propname) for itemid in cl.list()
                     if r.db.security.hasPermission \
                        ('View', r.userid, classname, propname, itemid)
                     ]
        finally:
            r.close()
        return result

    def display(self, username, password, designator, *properties):
        r = RoundupRequest(self.tracker, username, password)
        try:
            classname, itemid = hyperdb.splitDesignator(designator)
            cl    = r.get_class(classname)
            props = properties and list(properties) or cl.properties.keys()
            props.sort()
            for p in props:
                if not r.db.security.hasPermission \
                    ('View', r.userid, classname, p, itemid):
                    raise Unauthorised \
                        ('Permission to view %s of %s denied' % (p, designator))
            result = [(prop, cl.get(itemid, prop)) for prop in props]
        finally:
            r.close()
        return dict(result)

    def create(self, username, password, classname, *args):
        r = RoundupRequest(self.tracker, username, password)
        try:
            if not r.db.security.hasPermission('Create', r.userid, classname):
                raise Unauthorised('Permission to create %s denied'%classname)

            cl = r.get_class(classname)
            raise Unauthorised('Permission to create %s denied'%classname)

        cl = r.get_class(classname)

            # convert types
            props = r.props_from_args(cl, args)

            # check for the key property
            key = cl.getkey()
            if key and not props.has_key(key):
                raise UsageError, 'you must provide the "%s" property.'%key

            # do the actual create
        try:
            try:
                result = cl.create(**props)
            except (TypeError, IndexError, ValueError), message:


    def set(self, username, password, designator, *args):
        r = RoundupRequest(self.tracker, username, password)
        classname, itemid = hyperdb.splitDesignator(designator)

        if not r.db.security.hasPermission('Edit', r.userid, classname,
                itemid=itemid):
            raise Unauthorised('Permission to edit %s denied'%designator)

        cl = r.get_class(classname)

        # convert types
        props = r.props_from_args(cl, args)
        try:
            classname, itemid = hyperdb.splitDesignator(designator)
            cl                = r.get_class(classname)
            props             = r.props_from_args(cl, args) # convert types
            for p in props.iterkeys ():
                if not r.db.security.hasPermission \
                    ('Edit', r.userid, classname, p, itemid):
                    raise Unauthorised\
                        ('Permission to edit %s of %s denied'%(p, designator))
            try:
                return cl.set(itemid, **props)
            except (TypeError, IndexError, ValueError), message:
                raise UsageError, message
        finally:

Lines 62-67 Link Here

(-)test/db_test_base.py (-1 / +2 lines)
62	tracker = instance.open(dirname)	62	tracker = instance.open(dirname)
63	if tracker.exists():	63	if tracker.exists():
64	tracker.nuke()	64	tracker.nuke()
		65	init.write_select_db(dirname, backend)
65	tracker.init(password.Password('sekrit'))	66	tracker.init(password.Password('sekrit'))
66	return tracker	67	return tracker
67		68
Lines 293-299 Link Here
293	l = [u1,u2]; l.sort()	294	l = [u1,u2]; l.sort()
294	m = self.db.issue.get(nid, "nosy"); m.sort()	295	m = self.db.issue.get(nid, "nosy"); m.sort()
295	self.assertEqual(l, m)	296	self.assertEqual(l, m)
296		297
297		298
298	# XXX one day, maybe...	299	# XXX one day, maybe...
299	# def testMultilinkOrdering(self):	300	# def testMultilinkOrdering(self):




from roundup.cgi.exceptions import *
from roundup import init, instance, password, hyperdb, date
from roundup.xmlrpc import RoundupServer
from roundup.backends import list_backends

import db_test_base

NEEDS_INSTANCE = 1

class TestCase(unittest.TestCase):

    backend = None

    def setUp(self):
        self.dirname = '_test_xmlrpc'
        # set up and open a tracker
        self.instance = db_test_base.setupTracker(self.dirname, self.backend)

        # open the database
        self.db = self.instance.open('admin')
        self.joeid = 'user' + self.db.user.create(username='joe',
            password=password.Password('random'), address='random@home.org',
            realname='Joe Random', roles='User')

        self.db.commit()
        self.db.close()



def test_suite():
    suite = unittest.TestSuite()
    for l in list_backends() :
        dct    = dict(backend = l)
        subcls = type(TestCase)('TestCase_%s' % l, (TestCase,), dct)
        suite.addTest(unittest.makeSuite(subcls))
    return suite

if __name__ == '__main__':
    runner = unittest.TextTestRunner()
    unittest.main(testRunner=runner)


Return to bug 214666

Lines 63-75 Link Here

(-)roundup/xmlrpc.py (-51 / +47 lines)
63	def close(self):	63	def close(self):
64	"""Close the database, after committing any changes, if needed."""	64	"""Close the database, after committing any changes, if needed."""
65		65
66	if getattr(self, 'db'):	66	try:
67	try:	67	self.db.commit()
68	if self.db.transactions:	68	finally:
69	self.db.commit()	69	self.db.close()
70	finally:
71	self.db.close()
72
73		70
74	def get_class(self, classname):	71	def get_class(self, classname):
75	"""Return the class for the given classname."""	72	"""Return the class for the given classname."""
Lines 115-165 Link Here
115		112
116	def list(self, username, password, classname, propname=None):	113	def list(self, username, password, classname, propname=None):
117	r = RoundupRequest(self.tracker, username, password)	114	r = RoundupRequest(self.tracker, username, password)
118	cl = r.get_class(classname)	115	try:
119	if not propname:	116	cl = r.get_class(classname)
120	propname = cl.labelprop()	117	if not propname:
121	def has_perm(itemid):	118	propname = cl.labelprop()
122	return True	119	result = [ cl.get(itemid, propname) for itemid in cl.list()
123	r.db.security.hasPermission('View', r.userid, classname,	120	if r.db.security.hasPermission \
124	itemid=itemid, property=propname)	121	('View', r.userid, classname, propname, itemid)
125	result = [cl.get(id, propname) for id in cl.list()	122	]
126	if has_perm(id)]	123	finally:
127	r.close()	124	r.close()
128	return result	125	return result
129		126
130	def display(self, username, password, designator, *properties):	127	def display(self, username, password, designator, *properties):
131	r = RoundupRequest(self.tracker, username, password)	128	r = RoundupRequest(self.tracker, username, password)
132	classname, itemid = hyperdb.splitDesignator(designator)	129	try:
133		130	classname, itemid = hyperdb.splitDesignator(designator)
134	if not r.db.security.hasPermission('View', r.userid, classname,	131	cl = r.get_class(classname)
135	itemid=itemid):	132	props = properties and list(properties) or cl.properties.keys()
136	raise Unauthorised('Permission to view %s denied'%designator)	133	props.sort()
137		134	for p in props:
138	cl = r.get_class(classname)	135	if not r.db.security.hasPermission \
139	props = properties and list(properties) or cl.properties.keys()	136	('View', r.userid, classname, p, itemid):
140	props.sort()	137	raise Unauthorised \
141	result = [(property, cl.get(itemid, property)) for property in props]	138	('Permission to view %s of %s denied' % (p, designator))
142	r.close()	139	result = [(prop, cl.get(itemid, prop)) for prop in props]
		140	finally:
		141	r.close()
143	return dict(result)	142	return dict(result)
144		143
145	def create(self, username, password, classname, *args):	144	def create(self, username, password, classname, *args):
146	r = RoundupRequest(self.tracker, username, password)	145	r = RoundupRequest(self.tracker, username, password)
		146	try:
		147	if not r.db.security.hasPermission('Create', r.userid, classname):
		148	raise Unauthorised('Permission to create %s denied'%classname)
147		149
148	if not r.db.security.hasPermission('Create', r.userid, classname):	150	cl = r.get_class(classname)
149	raise Unauthorised('Permission to create %s denied'%classname)
150
151	cl = r.get_class(classname)
152		151
153	# convert types	152	# convert types
154	props = r.props_from_args(cl, args)	153	props = r.props_from_args(cl, args)
155		154
156	# check for the key property	155	# check for the key property
157	key = cl.getkey()	156	key = cl.getkey()
158	if key and not props.has_key(key):	157	if key and not props.has_key(key):
159	raise UsageError, 'you must provide the "%s" property.'%key	158	raise UsageError, 'you must provide the "%s" property.'%key
160		159
161	# do the actual create	160	# do the actual create
162	try:
163	try:	161	try:
164	result = cl.create(**props)	162	result = cl.create(**props)
165	except (TypeError, IndexError, ValueError), message:	163	except (TypeError, IndexError, ValueError), message:
Lines 170-188 Link Here
170		168
171	def set(self, username, password, designator, *args):	169	def set(self, username, password, designator, *args):
172	r = RoundupRequest(self.tracker, username, password)	170	r = RoundupRequest(self.tracker, username, password)
173	classname, itemid = hyperdb.splitDesignator(designator)
174
175	if not r.db.security.hasPermission('Edit', r.userid, classname,
176	itemid=itemid):
177	raise Unauthorised('Permission to edit %s denied'%designator)
178
179	cl = r.get_class(classname)
180
181	# convert types
182	props = r.props_from_args(cl, args)
183	try:	171	try:
		172	classname, itemid = hyperdb.splitDesignator(designator)
		173	cl = r.get_class(classname)
		174	props = r.props_from_args(cl, args) # convert types
		175	for p in props.iterkeys ():
		176	if not r.db.security.hasPermission \
		177	('Edit', r.userid, classname, p, itemid):
		178	raise Unauthorised\
		179	('Permission to edit %s of %s denied'%(p, designator))
184	try:	180	try:
185	cl.set(itemid, **props)	181	return cl.set(itemid, **props)
186	except (TypeError, IndexError, ValueError), message:	182	except (TypeError, IndexError, ValueError), message:
187	raise UsageError, message	183	raise UsageError, message
188	finally:	184	finally:

Lines 9-31 Link Here

(-)test/test_xmlrpc.py (-4 / +9 lines)
9	from roundup.cgi.exceptions import *	9	from roundup.cgi.exceptions import *
10	from roundup import init, instance, password, hyperdb, date	10	from roundup import init, instance, password, hyperdb, date
11	from roundup.xmlrpc import RoundupServer	11	from roundup.xmlrpc import RoundupServer
		12	from roundup.backends import list_backends
12		13
13	import db_test_base	14	import db_test_base
14		15
15	NEEDS_INSTANCE = 1	16	NEEDS_INSTANCE = 1
16		17
17	class TestCase(unittest.TestCase):	18	class TestCase(unittest.TestCase):
		19
		20	backend = None
		21
18	def setUp(self):	22	def setUp(self):
19	self.dirname = '_test_xmlrpc'	23	self.dirname = '_test_xmlrpc'
20	# set up and open a tracker	24	# set up and open a tracker
21	self.instance = db_test_base.setupTracker(self.dirname)	25	self.instance = db_test_base.setupTracker(self.dirname, self.backend)
22		26
23	# open the database	27	# open the database
24	self.db = self.instance.open('admin')	28	self.db = self.instance.open('admin')
25	self.joeid = 'user' + self.db.user.create(username='joe',	29	self.joeid = 'user' + self.db.user.create(username='joe',
26	password=password.Password('random'), address='random@home.org',	30	password=password.Password('random'), address='random@home.org',
27	realname='Joe Random', roles='User')	31	realname='Joe Random', roles='User')
28
29	self.db.commit()	32	self.db.commit()
30	self.db.close()	33	self.db.close()
31		34
Lines 89-98 Link Here
89		92
90	def test_suite():	93	def test_suite():
91	suite = unittest.TestSuite()	94	suite = unittest.TestSuite()
92	suite.addTest(unittest.makeSuite(TestCase))	95	for l in list_backends() :
		96	dct = dict(backend = l)
		97	subcls = type(TestCase)('TestCase_%s' % l, (TestCase,), dct)
		98	suite.addTest(unittest.makeSuite(subcls))
93	return suite	99	return suite
94		100
95	if __name__ == '__main__':	101	if __name__ == '__main__':
96	runner = unittest.TextTestRunner()	102	runner = unittest.TextTestRunner()
97	unittest.main(testRunner=runner)	103	unittest.main(testRunner=runner)
98