def _destroy(self, storable):
"""
Internal function that is responsible for doing the
actual destruction.
"""
factory = storable.get_factory()
if(factory.uses_guids()):
primary_key = factory.get_primary_key()
delete_query = sql.build_delete(storable.get_table(), {primary_key:storable.get_id()})
else:
delete_query = sql.build_delete(storable.get_table(), storable.get_data())
self.pool.runOperation(delete_query)
storable.reset_id()
def prepare_content(self, req):
"""
@see: L{modu.web.resource.IContent.prepare_content()}
"""
form_data = req.data
if "new" in form_data:
new_data = form_data["new"]
if "permission" in new_data:
req.store.ensure_factory("permission")
p = storable.Storable("permission")
p.name = new_data["permission"].value
req.store.save(p)
elif "role" in new_data:
req.store.ensure_factory("role")
r = storable.Storable("role")
r.name = new_data["role"].value
req.store.save(r)
permission_query = "SELECT id, name FROM permission ORDER BY name"
result = req.store.pool.runQuery(permission_query)
permissions = util.OrderedDict([(item["id"], item["name"]) for item in result])
role_query = "SELECT id, name FROM role ORDER BY name"
result = req.store.pool.runQuery(role_query)
roles = util.OrderedDict([(item["id"], item["name"]) for item in result])
if "acl" in form_data:
acl_data = form_data["acl"]
checked = []
unchecked = []
for pid in permissions.keys():
pid = str(pid)
for rid in roles.keys():
rid = str(rid)
if pid in acl_data and rid in acl_data[pid]:
checked.append({"role_id": rid, "permission_id": pid})
else:
unchecked.append({"role_id": rid, "permission_id": pid})
for perm in checked:
replace_query = sql.build_replace("role_permission", perm)
req.store.pool.runOperation(replace_query)
for perm in unchecked:
delete_query = sql.build_delete("role_permission", perm)
req.store.pool.runOperation(delete_query)
acl_query = """SELECT * FROM role_permission"""
acl_results = req.store.pool.runQuery(acl_query)
acl_map = {}
for item in acl_results:
acl_map.setdefault(item["permission_id"], []).append(item["role_id"])
self.set_slot("permissions", permissions)
self.set_slot("roles", roles)
self.set_slot("acl_map", acl_map)
role_assignments = user.get_role_assignments(req.store)
self.set_slot("role_assignments", role_assignments)
def update_storable(self, req, form, storable):
"""
@see: L{modu.editable.define.definition.get_element()}
"""
form_data = req.data[form.name]
store = storable.get_store()
item_id = storable.get_id()
delete_query = sql.build_delete(self['ntof'], {self['ntof_n_id']:item_id})
store.pool.runOperation(delete_query)
if(self.name in form_data):
values = form_data[self.name].value
if(isinstance(values, dict)):
values = values[self.name + '-autocomplete']
if not(isinstance(values, list)):
values = [values]
data = [{self['ntof_n_id']:item_id, self['ntof_f_id']:getattr(val, 'value', val)} for val in values]
insert_query = sql.build_insert(self['ntof'], data, **self.get('ntof_extras', {}))
store.pool.runOperation(insert_query)
elif(self.get('required', False)):
# A conundrum...
# It's got to be a postwrite field, because a new record would
# have to be saved before we could insert a record elsewhere with
# a foreign key (supposing for a minute we weren't use MySQL, argh)
#
# This means that it's impossible for this field to stop the writing
# of the record at this point, thus 'required' is currently meaningless.
#
# Should there be a way for a postwrite field to validate separately,
# before the write?
#
# I think the way it was supposed to work in Procuro was that if you
# are using GUIDs, you can fill the field at creation time, otherwise
# you saw a field that told you to save before editing (lame).
return False
return True
def test_build_delete2(self):
query = sql.build_delete('table', col1='col1_data', col2='col2_data');
expecting = "DELETE FROM `table` WHERE `col1` = 'col1_data' AND `col2` = 'col2_data'"
self.failUnlessEqual(query, expecting, 'Got "%s" when expecting "%s"' % (sql, expecting))
