def test_toDict(self):
category = Category(name='testCategory',
image='http://testImage',
about='testAbout')
db.session.add(category)
db.session.commit()
course = Course(name="testCourseName",
image='http://testImage',
about='testAbout',
category_id=category.id)
db.session.add(course)
chapter = Chapter(course.id, 1, "testChapter1", "http://testVideoUrl",
"testContent")
db.session.add(chapter)
db.session.commit()
ret = Chapter.query.filter_by(id=chapter.id).first()
ret = toDict(ret)
self.assertTrue("created_at" in ret)
self.assertEqual(ret["id"], chapter.id)
self.assertEqual(ret["order"], 1)
self.assertEqual(ret["name"], "testChapter1")
self.assertEqual(ret["video_url"], "http://testVideoUrl")
self.assertEqual(ret["content"], "testContent")
self.assertEqual(ret["course_id"], chapter.course_id)
def get(self):
if not current_user.admin:
abort(403, message="Admin only")
args = self.getArgs("getUser")
users, page = get_items_by_page(args['page'], User)
return dict(users=[toDict(i) for i in users], page=page.toDict())
def post(self):
args = self.getArgs('postUser')
name = args['name']
email = args['email']
password = args['password']
valRegexDict = User._regexMapDict
valDict = {'email': args['email'], 'password': args['password']}
valList = [i for i in valDict if i in valRegexDict]
for i in valList:
reCmp = re.compile(valRegexDict[i])
if not reCmp.match(valDict[i]):
abortValueError(i)
user = User.query.filter_by(email=email).first()
if user:
abort(400, message="Email is already in use.")
user = User(
name=name,
email=email,
image='http://www.gravatar.com/avatar/{0}?d=mm&s=120'.format(
hashlib.md5(email).hexdigest()))
db.session.add(user)
localAuth = LocalAuth(user_id=user.id, password=password)
db.session.add(localAuth)
db.session.commit()
login_user(user)
user = User.query.filter_by(id=user.id).first()
return toDict(user)
def get(self, id):
if (not current_user.admin) and (current_user.id != id):
abort(403, message="Admin or self only")
user = User.query.filter_by(id=id).first()
if user is None:
abort(404, message="User {0} do not exist".format(id))
return toDict(user)
def get(self):
args = self.getArgs('getCourse')
_page, _format = args['page'], args['format']
courses, page = get_items_by_page(_page, Course)
return dict(courses=[toDict(i) for i in courses],
page=page.toDict())
def get(self):
args = self.getArgs('getCategory')
_page, _format = args['page'], args['format']
categories, page = get_items_by_page(_page, Category)
return dict(categories=[toDict(i) for i in categories],
page=page.toDict())
def test_toDict(self):
user = User("testUser", "*****@*****.**", "http://testImage.com")
db.session.add(user)
db.session.commit()
ret = User.query.filter_by(id=user.id).first()
ret = toDict(ret)
self.assertTrue("created_at" in ret)
self.assertEqual(ret["name"], user.name)
def delete(self, id):
if not current_user.admin:
abort(403, message="No Permission!")
blog = Blog.query.filter_by(id=id).first()
if blog is None:
abort(404, message="Blog {0} do not exist.".format(id))
db.session.delete(blog)
db.session.commit()
return toDict(blog)
def delete(self, id):
if not current_user.admin:
abort(403, message="No Permission!")
comment = Comment.query.filter_by(id=id).first()
if comment is None:
abort(404, message="Comment {0} do not exist.".format(id))
db.session.delete(comment)
db.session.commit()
return toDict(comment)
def get(self):
args = self.getArgs('getBlog')
_page, _format = args['page'], args['format']
blogs, page = get_items_by_page(_page, Blog)
if _format == 'html':
for blog in blogs:
blog.content = markdown2.markdown(blog.content)
return dict(blogs=[toDict(i) for i in blogs], page=page.toDict())
def test_toDict(self):
category = Category(name='testCategory',
image='http://testImage',
about='testAbout')
db.session.add(category)
db.session.commit()
ret = category.query.filter_by(id=category.id).first()
ret = toDict(ret)
self.assertTrue("created_at" in ret)
self.assertEqual(ret["id"], category.id)
self.assertEqual(ret["name"], "testCategory")
def post(self, id):
if not current_user.admin:
abort(403, message="No Permission!")
args = self.getArgs('postCourse')
self.abortIfArgsEmpty(args, [ArgCourseName, ArgCourseImage, ArgCourseAbout])
kwargs = {i.name:args[i.name] for i in [ArgCourseName, ArgCourseImage, ArgCourseAbout]}
Course.query.filter_by(id=id).update(kwargs)
db.session.commit()
course = Course.query.filter_by(id=id).first()
return toDict(course)
def test_toDict(self):
user = User("testUser", "*****@*****.**", "http://testImage.com")
db.session.add(user)
blog = Blog(user.id, "testName", "testSummary", "testContent")
db.session.add(blog)
db.session.commit()
ret = Blog.query.filter_by(id=blog.id).first()
ret = toDict(ret)
self.assertTrue("created_at" in ret)
self.assertEqual(ret["id"], blog.id)
self.assertTrue("id" not in ret["user"])
self.assertEqual(ret["user"]["name"], user.name)
def post(self):
args = self.getArgs('postAuth')
remember = args['remember'] == 'true'
user = User.query.filter_by(email=args['email']).first()
if not user:
abort(401, message="Invalid email.")
localAuth = LocalAuth.query.filter_by(user_id=user.id).first()
if args['password'] != localAuth.password:
abort(401, message="Invalid password.")
login.login_user(user, remember=remember)
return toDict(user)
def post(self):
if not current_user.admin:
abort(403, message="No Permission!")
args = self.getArgs('postCategory')
self.abortIfArgsEmpty(args, [ArgCategoryName, ArgCategoryImage,
ArgCategoryAbout])
category = Category(*(args[i.name] for i in [ArgCategoryName,
ArgCategoryImage, ArgCategoryAbout]))
db.session.add(category)
db.session.commit()
ret = Category.query.filter_by(id=category.id).first()
return toDict(ret)
def post(self, id):
args = self.getArgs('postComment')
blog = Blog.query.filter_by(id=id).first()
if not blog:
abort(404, message="Blog {0} do not exist.".format(id))
content = args['content']
if not content:
abort(400, message="content can not be empty!")
comment = Comment(user_id=current_user.id, blog_id=id, content=content)
db.session.add(comment)
db.session.commit()
comment = Comment.query.filter_by(id=comment.id).first()
return toDict(comment)
def post(self):
if not current_user.admin:
abort(403, message="No Permission!")
args = self.getArgs('postCourse')
self.abortIfArgsEmpty(args, [ArgCourseName, ArgCourseImage,
ArgCourseAbout, ArgCourseCourseId])
course = Course(*(args[i.name] for i in
[ArgCourseName, ArgCourseImage, ArgCourseAbout,
ArgCourseCourseId]))
db.session.add(course)
db.session.commit()
ret = Course.query.filter_by(id=course.id).first()
return toDict(ret)
def test_toDict(self):
class TestClass(FieldMixin):
def __init__(self):
self.fieldA = 3
self.fieldB = datetime.datetime.now()
self.fieldC = datetime.datetime.now()
_jsonMapDict = FieldMixin._jsonMapDict.copy()
_jsonMapDict['fieldB'] = toJsonTime
_jsonMapDict['notExist'] = str
ret = toDict(TestClass())
self.assertTrue("fieldA" in ret)
self.assertTrue("fieldB" in ret)
self.assertFalse("fieldC" in ret)
self.assertFalse("notExist" in ret)
def post(self):
if not current_user.admin:
abort(403, message="No Permission!")
args = self.getArgs('postBlog')
if not args['name']:
abort(400, message="name can not be empty!")
if not args['summary']:
abort(400, message="summary can not be empty!")
if not args['content']:
abort(400, message="content can not be empty!")
blog = Blog(current_user.id, args['name'], args['summary'],
args['content'])
db.session.add(blog)
db.session.commit()
ret = Blog.query.filter_by(id=blog.id).first()
return toDict(ret)
def post(self, id):
if not current_user.admin:
abort(403, message="No Permission!")
args = self.getArgs('postChapter')
self.abortIfArgsEmpty(args, [ArgChapterName])
checkPostChapter(id, args[ArgChapterOrder.name])
kwargs = {i.name:args[i.name] for i in [ArgChapterOrder,
ArgChapterName,
ArgChapterVideoUrl,
ArgChapterContent]}
chapter = Chapter(course_id=id, **kwargs)
db.session.add(chapter)
db.session.commit()
chapter = Chapter.query.filter_by(id=chapter.id).first()
return toDict(chapter)
def post(self, id):
if not current_user.admin:
abort(403, message="No Permission!")
args = self.getArgs('postChapter')
chapter = Chapter.query.filter_by(id=id).first()
if not chapter:
abort(404, message="Chapter {0} do not exist.".format(id))
self.abortIfArgsEmpty(args, [ArgChapterCourseId, ArgChapterName])
checkPostChapter(args[ArgChapterCourseId.name],
args[ArgChapterOrder.name], id)
kwargs = {i.name:args[i.name] for i in [ArgChapterCourseId,
ArgChapterOrder,
ArgChapterName,
ArgChapterVideoUrl,
ArgChapterContent]}
Chapter.query.filter_by(id=id).update(kwargs)
db.session.commit()
chapter = Chapter.query.filter_by(id=id).first()
return toDict(chapter)
def get(self, id):
blog = Blog.query.filter_by(id=id).first()
if blog is None:
abort(404, message="Blog {0} do not exist.".format(id))
return toDict(blog)
def get(self, id):
chapters = Chapter.query.filter_by(course_id=id).all()
return dict(chapters=[toDict(i) for i in chapters])
def get(self, id):
comment = Comment.query.filter_by(id=id).first()
if comment is None:
abort(404, message="Comment {0} do not exist.".format(id))
return toDict(comment)
def test_toDictNone(self):
ret = toDict(None)
self.assertEqual(ret, {})
def get(self, id):
category = Category.query.filter_by(id=id).first()
if category is None:
abort(404, message="Category {0} do not exist.".format(id))
return toDict(category)
def get(self, id):
course = Course.query.filter_by(id=id).first()
if course is None:
abort(404, message="Course {0} do not exist.".format(id))
return toDict(course)
def get(self, id):
chapter = Chapter.query.filter_by(id=id).first()
if chapter is None:
abort(404, message="Chapter {0} do not exist.".format(id))
return toDict(chapter)
