Python db.DBApiModule类代码示例

def getUserByName(name):
    conn = db.connect()
    rows = db.selectFrom(conn, {"user"}, "*", name = name)
    if rows == []:
        #raise Exception("user not found")
        return None
    return User(rows)

 def testDropPWByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertPW(self.pw.userId, self.pw.value, self.pw.salt)
     
     db.deleteFromTable(self.conn, "user", id=self.id) 
     row = db.selectFrom(self.conn, {"pw_hash"}, "*", user_id=self.id)
     self.assertEqual(row, [])

def addLink(form, userId):
    linkId = utils.uuid()
    kwargs = {}
    kwargs["id"] = linkId
    
    kwargs["user_id"] = userId
    
    if form.has_key("url") :
        kwargs["url"]=form["url"]
        kwargs["url_hash"] = hashlib.md5(kwargs["url"]).hexdigest() 
    else:
        raise Exception("an url must be added")

    if form.has_key("title"): 
        kwargs["title"]=form["title"] 
    
    if form.has_key("description"):
        kwargs["description"]=form["description"]
        
    if form.has_key("typeName"):
        kwargs["type_name"]=form["typeName"]
    
    kwargs["modified_at"]=utils.timeStamp()
    
    #FIXME use other algorithms to get icon logo
    iconUrl = utils.extractHomeUrl(kwargs["url"])+"favicon.ico"

    conn = db.connect()
    db.insertToTable(conn,
                     "link",
                    **kwargs)
    MetaData.addIconUrl(linkId, iconUrl)
    
    return kwargs

 def testDropMetaDataByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertMetaData(self.metaData.linkId, self.metaData.key, self.metaData.value)
     
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"meta_data"}, "*", link_id=self.metaData.linkId)
     self.assertEqual(row, []) 

 def testDropGroupByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertGroup(self.group.id, self.group.name, self.group.public)
     
     db.deleteFromTable(self.conn, "user", id=self.id)
     row = db.selectFrom(self.conn, {"link_group"}, "*" , id=self.group.id)
     # FIXME: when a user is deleted all of his groups must be removed
     self.assertEqual(row, [])

 def testDropTagByUser(self):
     self.insertUser(self.id, self.name, self.email)
     self.insertTag(self.tag.id, self.tag.name)
     
     db.deleteFromTable(self.conn, "user", id=self.id)
     row = db.selectFrom(self.conn, {"tag"}, "*" , id=self.tag.id)
     # FIXME: when a user is deleted all of his tags must be removed 
     self.assertEqual(row, [])

def createUser(userForm):
    conn = db.connect()
    userId = str(uuid.uuid4())
    db.insertToTable(conn, "user",
                     id=userId,
                     name=userForm["username"],
                     email=userForm["email"])
    return userId

 def testDropLinkTagMapByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertTag(self.tag.id, self.tag.name)
     self.insertLinkTagMap(self.linkTagMap.tagId, self.linkTagMap.linkId)
     
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"link_tag_map"}, "*", link_id=self.linkTagMap.linkId)
     self.assertEqual(row, [])

 def testUpdateName(self):
     self.insertTag(self.id, self.name)
     name = mock.randomText()
     db.updateInTable(self.conn, {"name":name}, "tag", id=self.id)
     
     rows = db.selectFrom(self.conn, {"tag"}, "*", id=self.id)
     
     self.assertEqual(self.id, rows[0][0])
     self.assertEqual(name, rows[0][1])

 def testUpdateId(self):
     self.insertTag(self.id, self.name)
     _id = mock.uuid()
     db.updateInTable(self.conn, {"id":_id}, "tag", id=self.id)
     
     rows = db.selectFrom(self.conn, {"tag"}, "*", id=_id)
     
     self.assertEqual(_id, rows[0][0])
     self.assertEqual(self.name, rows[0][1])

 def testUpdatePublic(self):
     self.insertGroup(self.id, self.name, self.public)
     db.updateInTable(self.conn, {"public":"1"}, "link_group", id=self.id)
     
     rows = db.selectFrom(self.conn, {"link_group"}, "*", id=self.id)
     
     self.assertEqual(self.id, rows[0][0])
     self.assertEqual(self.name, rows[0][1])
     self.assertEqual(1, rows[0][2])

def createPasswordForUser(userId, password):
    conn = db.connect()
    value = hashlib.sha256(password).hexdigest()
    salt = hashlib.sha256(value+userId).hexdigest()
    db.insertToTable(conn, "pw_hash",
                     user_id=userId,
                     value=value,
                     salt=salt)
    return True

 def testDropLinkGroupMapByLink(self):
     self.insertLink(self.id, self.userId, self.url, self.urlHash, self.title,
                     self.desc, self.typeName , self.modifiedAt)
     self.insertGroup(self.group.id, self.group.name, self.group.public)
     self.insertLinkGroupMap(self.linkGroupMap.groupId, self.linkGroupMap.linkId)
     
     db.deleteFromTable(self.conn, "link", id=self.id)
     row = db.selectFrom(self.conn, {"link_group_map"}, "*", link_id=self.linkGroupMap.linkId)
     self.assertEqual(row, [])

 def testInsertNoTypeName(self):
     db.insertToTable(self.conn, "link",
                       id=self.id,
                       user_id=self.userId,
                       url=self.url,
                       url_hash=self.urlHash,
                       title=self.title,
                       description=self.desc,
                       modified_at=self.modifiedAt)

 def testEmail(self):
     self.insertUser(self.id, self.name, self.email)
     email = mock.randomText()
     db.updateInTable(self.conn, {"email":email}, "user", id=self.id)
     
     rows = db.selectFrom(self.conn, {"user"}, "*", id=self.id)
     
     self.assertEqual(self.id, rows[0][0])
     self.assertEqual(self.name, rows[0][1])
     self.assertEqual(email, rows[0][2])