Python models.DBSession類代碼示例

 def add_category(self, category):
     """ Inserts new category """
     log.debug("categories-add")
     category.dt = datetime.now()
     category.id = DBSession.add(category)
     DBSession.flush()
     return category

 def edit(self, idx = None, name = None):
     """ Lets to change name of existing group """
     log.debug("edit")
     response = Return()
     # Look for already existing record
     org = self.get(name = name)
     if org is None:
         # Group found
         if idx != None and name != None:
             group = self.get(idx = idx)
             old_name = group.name
             group.id = idx
             group.name = name
             group.dt = helpers.dtnow()
             DBSession.add(group)
             #response.data = group
             DBSession.flush()
             response.success()
             response.msg = "Successfully changed from {0} to {1}".format(old_name, name)
             log.info(response.msg)
             self.history.add(static.options.groups, static.actions.edit, response.msg)
         else:
             response.nodata()
             log.error(response.msg)
     else:
         # Group exist - name have to be unique
         response.msg = "Group already exists - not unique group name: {0}".format(name)
         log.error(response.msg)
     return response

 def add(self, name, permissions = ""):
     log.debug("add")
     response = Return()
     group = None
     if name is None:
         response.nodata()
         log.error(response.msg)
     else:
         try:
             if not(self.get(name = name)):
                 group = Group(name = name)
                 group.permissions = permissions
                 group.id = DBSession.add(group)
                 response.data = group
                 DBSession.flush()
                 response.success()
                 response.msg = "Group {0} has been added".format(name)
                 log.info(response.msg)
                 self.history.add(static.options.groups, static.actions.add, response.msg)
             else:
                 response.msg = "Group {0} already exists".format(name)
                 log.error(response.msg)
         except Exception as ex:
             log.exception(ex)
             response.exception()
     return response

 def changepassword(self, identifier, old, new, rpt):
     log.debug("change password")
     result = Return()
     try:
         if identifier and old and new and rpt:
             if new == rpt:
                 account = self.by_identifier(identifier)
                 if account:
                     if self.encryptor.compare(old, account.password, account.salt):
                         account.salt = self.encryptor.salt()
                         account.password = self.encryptor.encode(new, account.salt)
                         account.dt = helpers.dtnow()
                         DBSession.add(account)
                         result.success()
                         result.data = new
                     else:
                         result.msg = "Incorrect password"
                 else:
                     result.notfound(identifier)
             else:
                 result.msg = "Passwords are not equal"
         else:
             result.nodata()
         log.info(result.msg)
     except Exception as ex:
         log.exception(ex)
         result.exception()
     return result

 def modify(self, identifier, new_user):
     log.debug("modify")
     result = Return()
     try:
         if identifier and new_user:
             result = self.validate_existing(new_user)
             if result.status:
                 user = self.by_identifier(identifier)
                 if user:
                     user.name = new_user.get("name")
                     user.lastname = new_user.get("lastname")
                     user.email = new_user.get("email")
                     user.dt = helpers.dtnow()
                     DBSession.add(user)
                     result.data = self.get_details(user)
                     DBSession.flush()
                     result.success()
                     self.history.add(static.options.users, static.actions.edit, "User: {0} modified".format(user.name))
                 else:
                     result.notfound()
         else:
             result.nodata()
         log.info(result.msg)
     except Exception as ex:
         log.exception(ex)
         result.exception()
     return result

 def delete_category(self, idx):
     """ Removes category by id """
     log.debug("categories-delete")
     category = self.get_category_by_id(idx)
     if category:
         DBSession.delete(category)
         DBSession.flush()
     return category

 def delete_entry(self, idx):
     log.debug("delete-entry")
     entry = self.get_entry_by_id(idx)
     if entry:
         DBSession.delete(entry)
         DBSession.flush()
         return True
     else:
         log.error("Entry with id: {0} doesn't exists".format(idx))
     return False

 def add_entry(self, entry, category):
     log.debug("entries-add")
     catEntry = self.get_category_by_id(category)
     entry.dt = datetime.now()
     catEntry.entries.append(entry)
     data = DBSession.add(catEntry)
     entry = self.get_entry_by_code(entry.code)
     log.info("New id: {0}".format(data))
     DBSession.flush()
     return entry

 def get(self, idx = None, name = None):
     log.debug("get place by id: {0}, name: {1}", idx, name)
     place = None
     try:
         if idx:
             place = DBSession.query(Place).filter_by(id = int(idx)).first()
         elif name:
             place = DBSession.query(Place).filter_by(name = name).first()
     except Exception as ex:
         log.exception(ex)
     return place

 def edit_entry(self, idx, entry):
     log.debug("edit-entry")
     original = self.get_entry_by_id(idx)
     if original:
         original.name = entry.name
         original.value = entry.value
         original.type = entry.type
         original.dt = datetime.now()
         DBSession.add(original)
         DBSession.flush()
         return True
     return False

 def delete(self, place):
     log.debug("places_delete")
     if place:
         try:
             DBSession.delete(place)
             DBSession.flush()
             return True
         except Exception as ex:
             log.exception(ex)
     else:
         log.error("Empty place object")
     return False

 def update(self, place = None):
     log.debug("places_update")
     if place:
         try:
             DBSession.add(place)
             log.info("Place {0} removed")
             return True
         except Exception as ex:
             log.exception(ex)
     else: 
         log.error("Place obj is empty")
     return False

 def setgroups(self, identifier, jsongroups):
     log.debug("setgroups")
     groups = []
     account = self.by_identifier(identifier)
     for json in jsongroups:
         g = json.get("group")
         if json.get("assigned"):
             group = self.groups.get(idx = g.get("id"))
             groups.append(group)
     account.dt = helpers.dtnow()
     account.groups = groups
     DBSession.add(account)

 def get(self, idx = None, name = None, group = None):
     log.debug("get")
     org = None
     try:
         if group is not None:
             org = DBSession.query(Group).filter_by(id = group.id).first()
         elif idx is not None:
             org = DBSession.query(Group).filter_by(id = int(idx)).first()
         elif name is not None:
             org = DBSession.query(Group).filter_by(name = name).first()
     except Exception as ex:
         log.exception(ex)
     return org

 def edit_category(self, idx, category):
     """ Updates existing cateogry by id """
     log.debug("categories-edit")
     original = self.get_category_by_id(idx)
     if original is not None:
         original.name = category.name
         original.code = category.code
         original.options = category.options
         original.dt = datetime.now()
         DBSession.add(original)
         DBSession.flush()
         return original
     else:
         return None