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))