def _save(self, storable, factory): """ Internal function that is responsible for doing the actual saving. """ if not(storable.is_dirty()): return False table = storable.get_table() data = storable.get_data() locks_allowed = (not bool(self.req)) or self.req.app.config.get('use_db_locks', True) use_locks = False primary_key = factory.get_primary_key() if(storable.is_new()): if(factory.uses_guids()): data[primary_key] = self.fetch_id(storable) elif(locks_allowed): use_locks = True self.pool.runOperation('LOCK TABLES `%s` WRITE' % table) else: raise RuntimeError("Broken program logic is trying to lock an unlockable database.") query = sql.build_insert(table, data) else: query = sql.build_update(table, data, {primary_key:storable.get_id()}) self.log(query) try: self.pool.runOperation(query) if not(factory.uses_guids()): if not(storable.get_id()): rows = self.pool.runQuery('SELECT MAX(%s) AS `id` FROM `%s`' % (primary_key, table)) new_id = rows[0]['id'] storable.set_id(new_id) finally: if(use_locks): self.pool.runOperation('UNLOCK TABLES') storable.clean() storable.set_new(False) storable.set_factory(factory) return True
def fetch_id(self, storable): """ Fetch an ID for this object, if possible. "Predict" the id for this storable. If GUIDs are being used, this method will fetch a new GUID, set it, and return that ID immediately (assuming that this object will ultimately be saved with that ID). If GUIDs are not being used, this method will return 0 if this is an unsaved object. It's not possible to use "predictive" IDs in that case. @see: L{IFactory.fetch_id()} @param storable: the object whose ID you wish to fetch @type storable: L{storable.Storable} @returns: the item's id, or 0 @rtype: int @raises LookupError: if no factory has been registered for this Storable's table """ id = storable.get_id() if(id == 0): table = storable.get_table() if not(self.has_factory(table)): raise LookupError('There is no factory registered for the table `%s`' % table) factory = self.get_factory(table) use_locks = (not bool(self.req)) or self.req.app.config.get('use_db_locks', True) new_id = factory.get_id(use_locks=use_locks) storable.set_id(new_id, set_old=False) return new_id return id
def get_form_element(self, req, style, storable): """ Get a FormNode element that represents this field. The parent itemdef class will call this function, which will call the get_element() method, and set a few default values. @param req: The current request @type req: L{modu.web.app.Request} @param style: Generate for 'listing', 'search', or 'detail' views. @type style: str @param storable: The Storable instance to fill form data with. @type storable: L{modu.persist.storable.Storable} subclass @return: form element @rtype: L{modu.util.form.FormNode} """ frm = self.get_element(req, style, storable) classes = [self.__class__] while(classes): for cls in classes: if not(hasattr(cls, 'inherited_attributes')): continue for name in cls.inherited_attributes: if(name in self and name not in frm.attributes): frm.attributes[name] = self[name] classes = cls.__bases__ for name, value in self.get('attributes', {}).iteritems(): frm.attributes[name] = value # Since the templates take care of the wrapper, all # elements are defined as basic elements unless set # explicitly by the field definition. if(style != 'search' and 'basic_element' not in frm.attributes): frm(basic_element=True) if(style == 'listing' and self.get('link', False)): href = req.get_path(req.prepath, 'detail', storable.get_table(), storable.get_id()) frm(prefix=tags.a(href=href, __no_close=True), suffix='</a>') if(self.get('required', False)): frm(required=True) if(callable(self.get('form_alter', None))): self['form_alter'](req, style, frm, storable, self) return frm
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 delete(self, req, form, storable): """ The delete function for forms generated from this itemdef. @param req: The current request @type req: L{modu.web.app.Request} @param frm: The current form @type frm: L{modu.util.form.FormNode} @param storable: The Storable instance to delete. @type storable: list(L{modu.persist.storable.Storable}) @return: True if deleted @rtype: bool """ if not(self.deletable(req)): req.messages.report('error', "You are not allowed to delete `%s` records." % storable.get_table()) return False if('predelete_callback' in self.config): result = self.config['predelete_callback'](req, form, storable) if(result is False): return False deleted_id = storable.get_id() deleted_table = storable.get_table() storable.get_store().destroy(storable, self.config.get('delete_related_storables', False)) if('postdelete_callback' in self.config): self.config['postdelete_callback'](req, form, storable) req.messages.report('message', "Record #%d in %s was deleted." % (deleted_id, deleted_table)) if('referer' in form): referer = form['referer'].value else: referer = None app.redirect(referer) return True
req.messages.report('error', "An exception occurred during postwrite: %s" % e) reason = failure.Failure() reason.printTraceback(req['wsgi.errors']) postwrite_succeeded = False # call postwrite_callback if('postwrite_callback' in self.config): postwrite_callback = self.config['postwrite_callback'] if not(isinstance(postwrite_callback, (list, tuple))): postwrite_callback = [postwrite_callback] for callback in postwrite_callback: if not(callback(req, form, storable)): postwrite_succeeded = False if(postwrite_succeeded): req.messages.report('message', 'Your changes to %s record #%s have been saved.' % (storable.get_table(), storable.get_id())) if('referer' in form): referer = form['referer'].value else: referer = None if(referer): app.redirect(referer) else: req.messages.report('error', 'There was an error in the postwrite process, but primary record data was saved.') return postwrite_succeeded def deletable(self, req): allow_delete = True if('delete_acl' in self.config):