def test_register_user_existed(self):
logger.info("############test_register_user_existed############")
username = '******' % random.randrange(100)
resp = self.register_user(username, 'wulaoshi2019', '*****@*****.**')
resp = self.register_user(username, 'wulaoshi2019', '*****@*****.**')
logger.info("resp of test_register_user_existed: %s" % resp.json())
self.assertEqual(200, resp.status_code)
self.assertEqual("01", resp.json()['code'])
def md5Hash(password):
"""md5 加密分为digest和hexdigest两种格式，前者是二进制，后者是十六进制格式，这里默认为十六进制"""
try:
m5 = hashlib.md5()
m5.update(password.encode(encoding='utf-8'))
pwd = m5.hexdigest()
return pwd
except Exception as e:
logger.info("md5Hash error: %s" % e)
def validateUsernameExistInDB(userName):
try:
if User.query.filter(
User.username == userName).all(): # 查询数据库里是否存在userName
return True
else:
return False
except Exception as e:
logger.info("error : %s" % e)
def compareMd5Pwd(str1, str2):
md51 = hashlib.md5()
md51.update(str1)
pwd1 = md51.hexdigest()
logger.info("pwd1: %s" % pwd1)
md52 = hashlib.md5()
md52.update(str2)
pwd2 = md52.hexdigest()
logger.info("pwd2: %s" % pwd2)
return True if (pwd1 == pwd2) else False
def test_login_user_not_existed(self):
logger.info("############test_login_user_not_existed############")
username = '******' % random.randrange(1000)
passwordToLogin = md5Hash("wulaoshi2019")
# 登录用户
resp = self.login_user(username,passwordToLogin)
logger.info("resp of test_login_user_not_existed: %s" % resp.json())
self.assertEqual(200, resp.status_code)
# 登录的用户不存在，返回"03": 参数错误
self.assertEqual("02", resp.json()['code'])
def post(self):
try:
logger.info("Login -> args.keys(): %s" % self.args.keys())
userName = self.args['username']
userPassword = self.args['password']
neededParams = self.args.keys(
) # 记录self.reqparse.add_argument中添加的参数列表
logger.info("neededParams: %s" % neededParams)
requestParams = request.json.keys() # 记录发送请求中携带的参数列表
logger.info("requestParams: %s " % requestParams)
# 判断参数是否都有传过来，都传过来了，并且没有多传或少传，继续做参数值的校验，否则返回“参数错误”
if userName and userPassword and util.paramsNumResult(
neededParams, requestParams):
#到表里查询，是否存在这个用户，如果存在则校验密码
userToLogin = User.query.filter(
User.username == userName).first()
logger.info("userToLogin: %s" % userToLogin)
#判断用户是否存在db中
if userToLogin: #如果数据库中有这个user，则校验密码是否正确
passwordResult = util.validateMd5Password(
userPassword, userName) # 验证发过来的密码是否和用户存在db里的密码加密后相等
if passwordResult: # 如果密码正确，处理token和loginTime
#先把用户的token取出来
userTokenInDB = userToLogin.token
logger.info("userTokenInDB: %s" % userTokenInDB)
#userToken = generateUUID() if not userTokenInDB else generateUUID() #这样更简洁一些
# 登录的时候，把数据库里的loginTime和token都做更新
userToken = util.generateUUID()
userToLogin.token = userToken
timeStr = time.strftime("%Y-%m-%d %H:%M:%S")
userToLogin.loginTime = timeStr
db.session.commit()
return {
"token": "%s" % userToken,
"code": "00",
"userid": int(userToLogin.id),
"login_time": "%s" % timeStr
}
else: #密码不正确
return {"code": "02", "message": u"参数值不合法，密码不正确"}
else:
# 数据库中没有这个user
return {"code": "02", "message": u"参数值不合法，用户不存在"}
else:
return {"code": "03", "message": u"参数错误，可能原因：参数少传了、多传了、写错了"}
except Exception as e:
logger.error("error of login: %s" % e)
return {"code": "999", "message": u"未知错误"}
def get(self, articleId):
try:
# 到UserBlog模型类中找articleId的博文
blog = UserBlog.query.filter(UserBlog.articleId == articleId).first()
logger.info("blog: %s" % blog)
#如果找到了blog，则返回blog
if blog:
return {"code": "00", "data": [{"update_time": blog.updateTime, "title": blog.blogTitle, "content": blog.blogContent, "articleId": articleId, "owner": blog.user_id, "posted_on": blog.createTime}]}
# 没找到blog，提示参数值不合法，articleId不存在
else:
return {"code": "02", "message": u"参数值不合法，articleId不存在"}
except Exception as e:
logger.info("error of getBlogContent: %s" % e)
return {"code": "999", "message": u"未知错误"}
def calculateTimeDiff(userLoginTimeStr, timestamp):
try:
timestampNew = timestamp
logger.info("timestampNew : time when post request: %s" % timestampNew)
timeArray = time.strptime(userLoginTimeStr,
"%Y-%m-%d %H:%M:%S") # 把userLogin时间字符串转成时间元祖
logger.info("timeArray after time.strptime func: %s" % str(timeArray))
timestampOld = time.mktime(timeArray) # 把时间元祖转换成时间戳
logger.info("timestampOld format from timeArray: %s" % timestampOld)
timeStampDiff = timestampNew - timestampOld # 两个时间戳相减，得出时间差（单位：秒）
logger.info("timeStampDiff: %s" % timeStampDiff)
if timeStampDiff > 0:
timeHourDiff = int(divmod(
timeStampDiff, 3600)[0]) # 把时间差（秒）换算成小时，处理3600，得到一个元祖，第一个值为小时
logger.info("the time difference is : %s hour" % timeHourDiff)
return timeHourDiff
else:
logger.error("timestamp different is negative")
return "wrong"
except Exception as e:
logger.error("calculate time difference error: %s" % e)
def delete_blog(self, userid, token, articleIdList):
#{"userid":1, "token": "2d406f40e9544b45a162289af15145b4", "articleId":[1]}
url = "%s/delete/" % (self.host)
logger.info("url for delete: %s" % url)
logger.info("articleIdList: %s" % articleIdList)
data = json.dumps({"userid": userid, "token": token, "articleId": articleIdList})
logger.info("request data of delete_blog: %s" % data)
return self.api_client.delete(url, data = data)
def test_login_user_existed(self):
logger.info("############test_create_blog############")
username = '******' % random.randrange(100)
passwordToRegister = "wulaoshi2019"
# 注册新用户
resp = self.register_user(username, passwordToRegister, '*****@*****.**')
passwordToLogin = md5Hash(passwordToRegister)
logger.info("username: %s" % username)
logger.info("passwordToLogin: %s" % passwordToLogin)
# 登录用户
resp = self.login_user(username, passwordToLogin)
logger.info("resp of test_login_user_existed: %s" % resp.json())
self.assertEqual(200, resp.status_code)
self.assertEqual("00", resp.json()['code'])
def register_user(self, username, password, email):
url = "%s/register/" % self.host
logger.info("register_user->url: %s" % url)
data = {"username": username, "password": password, "email": email}
requestData = json.dumps(data)
logger.info("requestData of register: %s" % requestData)
resp = self.api_client.post(url, data = requestData)
logger.info("resp of register: %s" % resp.json())
return resp
def get(self, articleIdString):
try:
logger.info("articleIdString: %s" % articleIdString)
# 用正则匹配articleIds=1,2,3中等号后面的部分
reMatchResult = re.match(r"articleIds=(.*)", articleIdString)
# 如果匹配到了，说明传了articleIds=部分，继续取articleId
if reMatchResult:
articleIdResultString = reMatchResult.group(1)
logger.info("articleIdResultString: %s" %
articleIdResultString)
# 判断articleIds=后边的id是否有传，传了就把所有的id取出来
if articleIdResultString:
articleIdList = articleIdResultString.split(',')
logger.info("articleIdList: %s" % articleIdList)
responseDict = {"code": "00", "data": []}
blogList = [] # 用于存查询到的blog
# 遍历articleIdList，判断每个id是否在db里存在
for id in articleIdList:
# 校验id值的类型，把字符型转为整形
try:
idValue = int(id)
# 如果不能专属数字，提示不是数字
except:
return {
"code": "02",
"message": u"参数值不合法，articleId: %s 不是数字" % id
}
blog = UserBlog.query.filter(
UserBlog.articleId == idValue).first()
# 如果这个id有，则把blog对象存到blogList里
if blog:
blogList.append(blog)
# 如果这个id没有，则提示参数值错误
else:
return {
"code": "02",
"message": u"参数值不合法，不存在articleId: %s " % id
}
# 获取到的blog都存到blogList后，把blog填充到responseDict
responseDictFilled = util.fillInResponseDict(
responseDict, blogList)
return responseDictFilled
# 没有传后边的id，则提示articleId没有传articleIdResultString
else:
return {"code": "02", "message": u"参数值不合法，articleId没有传"}
# 没匹配到，提示articleIds=没有传值
else:
return {"code": "02", "message": u"参数值不合法，articleIds=没有传值"}
except Exception as e:
logger.error("error of getBlogContent: %s" % e)
return {"code": "999", "message": u"未知错误"}
def post(self):
try:
logger.info("self.args.keys(): %s" % self.args.keys())
userName = self.args['username']
userPassword = self.args['password']
email = self.args['email']
neededParams = self.args.keys()
logger.info("neededParams: %s" % neededParams)
requestParams = request.json.keys()
logger.info("requestParams: %s" % requestParams)
# 判断参数是否都有传过来，是否多了，是否错了
if userName and userPassword and email and util.paramsNumResult(
neededParams, requestParams):
userNameResult = util.validateUsername(userName)
emailResult = util.validateEmail(email)
passwordResult = util.validatePassword(userPassword)
#校验各个参数值是否合法
if userNameResult and emailResult and passwordResult:
if not User.query.filter(User.username == userName).all(
): # 查询数据库里是否存在该username
userNew = User(username=userName,
password=userPassword,
email=email)
db.session.add(userNew)
db.session.commit()
return {
"code": "00",
"userid": userNew.id,
"message": u"成功"
}
else:
# 数据库里有重名的
return {"code": "01", "message": u"参数值不合法，用户名已存在"}
else:
return {"code": "02", "message": u"参数值不合法，不符合约束条件"}
else:
return {
"code": "03",
"message": u"参数错误，可能原因：参数少传了、多传了、写错了、值为空"
}
except Exception as e:
logger.error("error of register: %s" % e)
return {"code": "999", "message": u"未知错误"}
def fillInResponseDict(responseDict, blogs):
# 遍历用户的所有博文，把博文的各字段赋值给博文字典的各个值（按照接口文档的格式）
#blogDict = {}
for blog in blogs:
# 定义一个临时字典，组装博文的数据
blogDict = {
} # 如果定义在for前面，由于append的是blogDict的引用，在填充完response后，存的blogDict最后都会替换为最后一次blogDict的值
logger.info("----blog: %s" % blog)
blogDict["update_time"] = blog.updateTime
blogDict["title"] = blog.blogTitle
blogDict["content"] = blog.blogContent
blogDict["articleId"] = blog.articleId
blogDict["owner"] = blog.user.id
blogDict["posted_on"] = blog.createTime
logger.info("blogDict: %s" % blogDict)
#遍历完一个博文后，把blogDict添加到responseDict的"data"列表中
responseDict["data"].append(blogDict)
logger.info("responseDict: %s" % responseDict)
#把blogs内容填充到responseDict后，把responseDict返回
return responseDict
def get_blogs_of_user(self, userid, token):
#{"userid":"4", "token": "2d406f40e9544b45a162289af15145b4","offset": "1", "lines": "1"}
url = "%s/getBlogsOfUser/" % (self.host)
data = json.dumps({"userid":userid, "token": token})
logger.info("request data of get_blogs_of_user: %s" % data)
return self.api_client.post(url = url, data = data)
def get_blogs_content(self,articleIds):
# 'articleIds=' 后边传'1,2'这样的值
url = "%s/getBlogsContent/articleIds=%s" % (self.host, articleIds)
logger.info("url of get_blogs_content: %s" % url)
return self.api_client.get(url)
def create_blog(self, userid, token, title, content):
#{"userid": "2", "token": "4282a87824884246aa0d8ef6974bbbf5", "title":"dddddd", "content":"HttpRunner is a api test interface"}
url = "%s/create/" % self.host
data = json.dumps({"userid": userid, "token": token, "title": title, "content": content})
logger.info("request data of create_blog: %s" % data)
return self.api_client.post(url, data = data)
def login_user(self, username, password):
url = "%s/login/" % self.host
data = json.dumps({"username": username, "password": password})
logger.info("request data of login_user: %s" % data)
return self.api_client.post(url, data = data)
def test_delete_blogs(self):
logger.info("############test_delete_blogs############")
passwordToRegister = "wulaoshi2019"
logger.info("passwordToRegister")
# 先注册用户
username = '******' % random.randrange(1000)
logger.info("username: %s" % username)
passwordToRegister = "wulaoshi2019"
logger.info("passwordToRegister: %s" % passwordToRegister)
respOfRegister = self.register_user(username, passwordToRegister, '*****@*****.**')
logger.info("respOfRegister: %s" % respOfRegister.json())
# 记录password的md5加密串
passwordOfUser = md5Hash(passwordToRegister)
logger.info("passwordToLogin: %s" % passwordOfUser)
# 然后登录，获取token和userid
respOfLogin = self.login_user(username, passwordOfUser)
logger.info("respOfLogin: %s" % respOfLogin.json())
# 获取登录返回的userid
useridOfUser = respOfLogin.json()['userid']
logger.info("useridOfUser: %s" % useridOfUser)
# 获取登录返回token
tokenOfUser = respOfLogin.json()['token']
logger.info("tokenOfUser: %s" % tokenOfUser)
# 创建第一个博文
respOfCreate1 = self.create_blog(useridOfUser, tokenOfUser, title="mysql", content="mysql learn")
logger.info("resp of create_blog1: %s" % respOfCreate1.json())
# 再创第二个博文
respOfCreate2 = self.create_blog(useridOfUser, tokenOfUser, title="mysql", content="mysql learn")
logger.info("resp of create_blog2: %s" % respOfCreate2.json())
# 再创第三个博文
respOfCreate3 = self.create_blog(useridOfUser, tokenOfUser, title="mysql", content="mysql learn")
logger.info("resp of create_blog3: %s" % respOfCreate3.json())
# 查询用户博文，获取articleIds，需要参数：userid、token
respOfGetBlogsOfUser = self.get_blogs_of_user(useridOfUser, tokenOfUser)
logger.info("respOfGetBlogsOfUser: %s" % respOfGetBlogsOfUser.json())
logger.info("respOfGetBlogsOfUser.text: %s" % respOfGetBlogsOfUser.text)
# 正则表达式获取响应结果中所有的articleId，拼成字符串，如"1,2,3"
reFindArticleIdsRes = re.findall(r'"articleId": (\d+)', respOfGetBlogsOfUser.text)
logger.info("reFindArticleIdsRes: %s" % reFindArticleIdsRes)
articleIdsListStr = [int(articleId) for articleId in reFindArticleIdsRes]
# 删除博文
respOfDeleteBlogs = self.delete_blog(useridOfUser, tokenOfUser, articleIdsListStr)
logger.info("respOfDeleteBlogs: %s" % respOfDeleteBlogs.json())
self.assertEqual(200, respOfDeleteBlogs.status_code)
self.assertEqual("00", respOfDeleteBlogs.json()['code'])
def initializeTables():
# 尝试三次创建表，如果不成功则提示失败
for i in range(3):
logger.info("Try to initialize tables attempt times: %s" % int(i + 1))
try:
# 创建表，提交db会话
db.create_all()
time.sleep(0.1)
db.session.commit()
# 查询User表，如果报错说明查不到，则到except分支创建表
logger.info("Try to find table User: %s" % User.query.first())
logger.info("Try to find table UserBlog: %s" %
UserBlog.query.first())
logger.info("User and UserBlog table existed ！")
# 表存在，则退出循环
break
except Exception as e:
logger.info(
"Error occurs when searching the tables : '%s', now trying to create again ... "
% e)
# 3次都没有执行break，说明没成功，则在这里提示表创建失败
else:
logger.info("Create tables failed")
def test_register_user_not_existed(self):
logger.info("############test_register_user_not_existed############")
# 先注册，记录username和password（md5)
passwordToRegister = "wulaoshi2019"
logger.info("passwordToRegister")
# 若已经存在，重试1次
for i in range(2):
logger.info("try times: %s" % int(i + 1))
try:
username = '******' % random.randrange(1000)
logger.info("username: %s" % username)
resp = self.register_user(username, passwordToRegister, '*****@*****.**')
logger.info("resp of test_register_user_not_existed: %s" % resp.json())
self.assertEqual(200, resp.status_code)
self.assertEqual("00", resp.json()['code'])
break
except Exception as e:
logger.info("error in test_register_user_not_existed: %s" % e)
def paramsNumResult(neededParams, requestParams):
for param in requestParams:
if param not in neededParams:
logger.info("param not in needed params: %s" % param)
return False
return True
# 查询用户博文，获取articleIds，需要参数：userid、token
respOfGetBlogsOfUser = self.get_blogs_of_user(useridOfUser, tokenOfUser)
logger.info("respOfGetBlogsOfUser: %s" % respOfGetBlogsOfUser.json())
logger.info("respOfGetBlogsOfUser.text: %s" % respOfGetBlogsOfUser.text)
# 正则表达式获取响应结果中所有的articleId，拼成字符串，如"1,2,3"
reFindArticleIdsRes = re.findall(r'"articleId": (\d+)', respOfGetBlogsOfUser.text)
logger.info("reFindArticleIdsRes: %s" % reFindArticleIdsRes)
articleIdsListStr = [int(articleId) for articleId in reFindArticleIdsRes]
# 删除博文
respOfDeleteBlogs = self.delete_blog(useridOfUser, tokenOfUser, articleIdsListStr)
logger.info("respOfDeleteBlogs: %s" % respOfDeleteBlogs.json())
self.assertEqual(200, respOfDeleteBlogs.status_code)
self.assertEqual("00", respOfDeleteBlogs.json()['code'])
if __name__ == '__main__':
logger.info("reportPath: %s" % reportPath)
# 根据给定的测试类，获取其中的所有以“test”开头的测试方法，并返回一个测试套件
suite1 = unittest.TestLoader().loadTestsFromTestCase(TestApiServer)
# 将测试类加载到测试套件中
suite = unittest.TestSuite([suite1])
# 以二进制方式打开文件，准备写
fp = open(reportPath, 'wb')
# 使用HTMLTestRunner配置参数，输出报告路径、报告标题、描述，均可以配
runner = HTMLTestRunner.HTMLTestRunner(stream=fp, title='Unittest Report', description='Report Description')
# 运行测试集合
runner.run(suite)
def validateMd5Password(passwordFromPost, usernameFromPost):
try:
logger.info("passwordFromPost: %s" % passwordFromPost)
logger.info("usernameFromPost: %s" % usernameFromPost)
userInDb = User.query.filter(User.username == usernameFromPost).first()
logger.info("userInDb: %s" % userInDb)
if userInDb:
passwordInDb = userInDb.password
logger.info("passwordInDb: %s" % passwordInDb)
passwordInDbMd5 = md5Hash(passwordInDb)
logger.info("passwordInDbMd5: %s" % passwordInDbMd5)
else:
passwordInDbMd5 = None
logger.info("passwordInDbMd5: %s" % passwordInDbMd5)
if passwordFromPost == passwordInDbMd5:
return True
else:
return False
except Exception as e:
logger.info("validateMd5Password Error: %s " % e)
def update_blog(self, userid, token, articleId, title, content):
url = "%s/update/" % (self.host)
data = json.dumps({"userid": userid, "token": token, "articleId":articleId, "title": title, "content": content})
logger.info("request data of update_blog: %s" % data)
return self.api_client.put(url, data = data)
def test_get_blog_content(self):
logger.info("############test_get_blog_content############")
# 先注册用户
username = '******' % random.randrange(1000)
logger.info("username: %s" % username)
passwordToRegister = "wulaoshi2019"
logger.info("passwordToRegister: %s" % passwordToRegister)
respOfRegister = self.register_user(username, passwordToRegister, '*****@*****.**')
logger.info("respOfRegister: %s" % respOfRegister.json())
# 记录password的md5加密串
passwordOfUser = md5Hash(passwordToRegister)
logger.info("passwordToLogin: %s" % passwordOfUser)
# 然后登录，获取token和userid
respOfLogin = self.login_user(username, passwordOfUser)
logger.info("respOfLogin: %s" % respOfLogin.json())
# 获取登录返回的userid
useridOfUser = respOfLogin.json()['userid']
logger.info("useridOfUser: %s" % useridOfUser)
# 获取登录返回token
tokenOfUser = respOfLogin.json()['token']
logger.info("tokenOfUser: %s" % tokenOfUser)
# 创建博文
respOfCreate = self.create_blog(useridOfUser, tokenOfUser, title="mysql", content="mysql learn")
logger.info("resp of create_blog: %s" % respOfCreate.json())
# 查询用户博文，获取articleId，需要参数：userid、token
respOfGetBlogsOfUser = self.get_blogs_of_user(useridOfUser, tokenOfUser)
logger.info("respOfGetBlogsOfUser: %s" % respOfGetBlogsOfUser.json())
articleId = respOfGetBlogsOfUser.json()['data'][0]['articleId']
logger.info("articleId: %s" % articleId)
# 查询博文内容参数：articleId
respOfGetBlogContent = self.get_blog_content(articleId)
logger.info("respOfGetBlogContent: %s" % respOfGetBlogContent)
self.assertEqual(200, respOfGetBlogContent.status_code)
self.assertEqual("00", respOfGetBlogContent.json()['code'])
def test_create_blog(self):
logger.info("############test_create_blog############")
username = '******' % random.randrange(1000)
logger.info("username: %s" % username)
passwordToRegister = "wulaoshi2019"
logger.info("passwordToRegister")
# 注册新用户，记录password(md5)
respOfRegister = self.register_user(username, passwordToRegister, '*****@*****.**')
logger.info("respOfRegister: %s" % respOfRegister.json())
passwordToLogin = md5Hash(passwordToRegister)
logger.info("passwordToLogin: %s" % passwordToLogin)
# 登录用户，记录userid和token
respOfLogin = self.login_user(username, passwordToLogin)
logger.info("respOfLogin: %s" % respOfLogin.json())
useridOfRegister = respOfLogin.json()['userid']
logger.info("useridOfRegister: %s" % useridOfRegister)
tokenOfLogin = respOfLogin.json()['token']
logger.info("tokenOfLogin: %s" % tokenOfLogin)
# 创建博文并断言
respOfCreate = self.create_blog(useridOfRegister, tokenOfLogin, title = "mysql", content = "mysql learn")
logger.info("resp of test_create_blog: %s" % respOfCreate.json())
self.assertEqual(200, respOfCreate.status_code)
self.assertEqual("00", respOfCreate.json()['code'])
def put(self):
try:
logger.info(
"########################[Update]########################")
logger.info("self.args.keys(): %s" % self.args.keys())
json_data = request.get_json(force=True)
logger.info("json_data: %s" % json_data)
userid = json_data['userid'] if ('userid'
in json_data.keys()) else ""
logger.info("userid: %s" % userid)
userToken = json_data['token'] if ('token'
in json_data.keys()) else ""
logger.info("userToken: %s" % userToken)
articleId = json_data['articleId'] if ('articleId'
in json_data.keys()) else ""
logger.info("articleId: %s" % articleId)
blogTitle = json_data['title'] if ('title'
in json_data.keys()) else ""
logger.info("blogTitle: %s" % blogTitle)
blogContent = json_data['content'] if ('content'
in json_data.keys()) else ""
logger.info("blogContent: %s" % blogContent)
neededParams = self.args.keys(
) # 记录self.reqparse.add_argument中添加的参数列表
logger.info("neededParams: %s" % neededParams)
requestParams = request.json.keys() # 记录发送请求中携带的参数列表
logger.info("requestParams: %s" % requestParams)
requestTimestamp = time.time()
# 校验是否参数都有传过来，不多不少
if userid and userToken and blogTitle and blogContent and articleId and util.paramsNumResult(
neededParams, requestParams):
getUserInDB = User.query.filter(User.id == userid).first()
logger.info("getUserInDB: %s" % getUserInDB)
# 如果用户存在，判断表中是否有登录时间和token
if getUserInDB:
userLoginTimeInDB = getUserInDB.loginTime #取出用户的登录时间
logger.info("userLoginTimeInDB: %s" % userLoginTimeInDB)
# 获取用户在DB中的token
userTokenInDB = getUserInDB.token
logger.info("userTokenInDB: %s" % userTokenInDB)
# 如果有登录时间和token，则继续校验token是否过期
if userLoginTimeInDB and userTokenInDB:
# 校验登录时间是否超过1小时
if util.calculateTimeDiff(userLoginTimeInDB,
requestTimestamp) >= 1:
return {
"code": "02",
"message": u"参数值不合法，token已过期，请重新登录"
}
# 登录时间没超过1小时,继续校验token是否和useid是否相匹配
else:
# 判断token和userid是否相匹配，匹配则继续检验articleId是否存在
if userToken == userTokenInDB:
# 判断artileId是否在DB中存在
getBlogInDB = UserBlog.query.filter(
UserBlog.articleId == articleId).first()
logger.info("getBlogInDB: %s" % getBlogInDB)
# 如果用articleId能查到博文，存表（update_time，title， content），并返回
if getBlogInDB:
# 先获取到更新博文的时间
updateBlogTimeString = time.strftime(
"%Y-%m-%d %H:%M:%S",
time.localtime(requestTimestamp))
logger.info("updateBlogTimeString: %s" %
updateBlogTimeString)
# 存表: blogTitle、blogContent、updateTime
updateBlog = UserBlog.query.filter(
UserBlog.articleId ==
articleId).first()
updateBlog.updateTime = updateBlogTimeString
updateBlog.blogTitle = blogTitle
updateBlog.blogContent = blogContent
db.session.commit()
# 返回成功
return {
"articleId": articleId,
"update_time": updateBlogTimeString,
"code": "00",
"userid": userid
}
# 如果用articleId查不到博文，则提示参数值不合法，articleId不存在
else:
return {
"code": "02",
"message": u"参数值不合法，articleId不存在"
}
# token和userid不匹配，说明token不正确，返回参数值不合法，token不正确
else:
return {
"code": "02",
"message": u"参数值不合法，token不正确"
}
# 如果没有登录时间和token，则提示token不正确，请登录并获取token
else:
return {
"code": "02",
"message": u"参数值不合法，token不正确，请登录并获取token"
}
# 如果用户不存在，提示参数值不合法，用户不存在
else:
return {"code": "02", "message": u"参数值不合法，用户不存在"}
# 参数没传全，或参数写错了，或参数多了
else:
return {
"code": "03",
"message": u"参数错误，可能原因：参数少传了、多传了、写错了、值为空"
}
except Exception as e:
logger.error("error of update: %s" % e)
return {"code": "999", "message": u"未知错误"}
def delete(self):
try:
logger.info(
"########################[delete]########################")
logger.info("self.args.keys(): %s" % self.args.keys())
json_data = request.get_json(force=True)
userid = json_data['userid'] if ('userid'
in json_data.keys()) else ""
logger.info("userid: %s" % userid)
userToken = json_data['token'] if ('token'
in json_data.keys()) else ""
logger.info("userToken: %s" % userToken)
articleIdList = json_data['articleId'] if (
'articleId' in json_data.keys()) else ""
logger.info("articleIdList: %s" % articleIdList)
neededParams = self.args.keys(
) # 记录self.reqparse.add_argument中添加的参数列表
logger.info("neededParams: %s" % neededParams)
requestParams = request.json.keys() # 记录发送请求中携带的参数列表
logger.info("requestParams: %s" % requestParams)
requestTimestamp = time.time()
# 校验是否参数都有传过来，不多不少
if userid and userToken and articleIdList and util.paramsNumResult(
neededParams, requestParams):
getUserInDB = User.query.filter(User.id == userid).first()
logger.info("getUserInDB: %s" % getUserInDB)
# 如果用户存在，继续判断是否有登陆时间和token
if getUserInDB:
userLoginTimeInDB = getUserInDB.loginTime #取出用户的登录时间
logger.info("userLoginTimeInDB: %s" % userLoginTimeInDB)
# 获取用户在DB中的token
userTokenInDB = getUserInDB.token
logger.info("userTokenInDB: %s" % userTokenInDB)
# 如果表中有登录时间和token，则继续判断token是否过期
if userLoginTimeInDB and userTokenInDB:
# 校验登录时间是否超过1小时
if util.calculateTimeDiff(userLoginTimeInDB,
requestTimestamp) >= 1:
return {
"code": "02",
"message": u"参数值不合法，token已过期，请重新登录"
}
# 登录时间没超过1小时,继续校验token是否和useid是否相匹配
else:
# 判断token和userid是否相匹配，匹配则处理articleIdList列表
if userToken == userTokenInDB:
# 判断articleIdList的值是否为列表，是的话，则遍历列表继续处理
if type(articleIdList) == list:
logger.info("articleIdList: %s" %
articleIdList)
# 遍历articleId列表
for id in articleIdList:
# 用id去找blog
blog = UserBlog.query.filter(
UserBlog.articleId == id).first()
# 能找到，说明id存在，进行删除动作
if blog:
# 先从db session中删掉，最后一起commit
db.session.delete(blog)
# 没找到，说明id不存在，提示参数值不合法
else:
return {
"code":
"02",
"message":
u"参数值不合法，articleId：%s 不存在" % id
}
# 遍历完articleIdList，id都存在，且都做了删除，则提交commit
db.session.commit()
# 数据库提交删除后，返回结果
return {
"articleId": articleIdList,
"code": "00",
"userid": userid
}
# articleId的值不是列表，提示articleId传的不是列表
else:
return {
"code": "02",
"message": u"参数值不合法，articleId传的不是列表"
}
# token和userid不匹配，说明token不正确，返回参数值不合法，token不正确
else:
return {
"code": "02",
"message": u"参数值不合法，token不正确"
}
# 表中没有登录时间和token，提示token不正确，请登录并获取token
else:
return {
"code": "02",
"message": u"参数值不合法，token不正确，请登录并获取token"
}
# 如果用户不存在，提示参数值不合法，用户不存在
else:
return {"code": "02", "message": u"参数值不合法，用户不存在"}
# 参数没传全，或参数写错了，或参数多了
else:
return {
"code": "03",
"message": u"参数错误，可能原因：参数少传了、多传了、写错了、参数值为空"
}
except Exception as e:
logger.error("error of delete: %s" % e)
return {"code": "999", "message": u"未知错误"}
def generateUUID():
try:
uuidStr = uuid.uuid4().hex
return uuidStr
except Exception as e:
logger.info("uuidGenerate Error :%s" % e)
