class Thread(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), thread_details(api))
@api.doc(description='''
User can start a new thread
''')
def post(self):
user = authorize(request)
(course_id, title, content) = unpack(request.json, 'course_id', 'title', 'content')
session = db.get_session()
thread = db.Thread(course_id=course_id, title=title, content=content, publisher_id = user.id, up_vote = 0)
session.add(thread)
session.commit()
session.close()
return {
'message': 'success'
}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('thread_id', 'the id of the thread which the user want to fetch')
@api.doc(description='''Get a thread''')
def get(self):
user = authorize(request)
thread_id = int(request.args.get('thread_id', None))
session = db.get_session()
thread = session.query(db.Thread).filter_by(id=thread_id).first()
if (thread is None):
return None
session.close()
return getThreadInfo(thread)
class GroupMember(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('group_id', 'the id of the group which the user want to join')
@api.param('skill', 'the skill which the user has<br>skill must be either "backend" or "frontend"')
@api.doc(description='''
User can join an existing group
''')
def post(self):
user = authorize(request)
group_id = int(request.args.get('group_id', None))
skill = request.args.get('skill', None)
if (skill != 'backend' and skill != 'frontend'):
abort(400, "Wrong skill input")
session = db.get_session()
group = session.query(db.Group).filter_by(id=group_id).first()
if (group is None):
abort(400, "Group is not exist")
group.num_member += 1
if (skill == 'backend'):
group.num_backend += 1
else:
group.num_frontend += 1
#group.members += "|"
#group.members += str(user.id)
new_member = db.GroupMember(group_id=group.id, student_id=user.id, role=skill)
session.add(new_member)
session.commit()
session.close()
return {
'message': 'success'
}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('group_id', 'the id of the group which the user want to check')
@api.doc(description='''Get all group member info''')
def get(self):
authorize(request)
group_id = int(request.args.get('group_id', None))
session = db.get_session()
members = session.query(db.GroupMember).filter_by(group_id=group_id).all()
session.close()
if (members is None):
return None
memberList = []
for member in members:
memberList.append(getGroupMebmerInfo(member))
return memberList
class Resources(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), resource_details(api))
@api.doc(description='''
Post a new Resource.
''')
def post(self):
authorize(request)
(course_id, title, group, content) = unpack(request.json, 'course_id', 'title', 'group', 'content')
session = db.get_session()
new_resource = db.Resource(course_id=course_id, title=title, content=content, group=group)
session.add(new_resource)
session.commit()
session.close()
return {
'message': 'success'
}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.param('resource_id', 'the id of the resource which the user want to fetch')
@api.doc(description='''
Get the resource
''')
def get(self):
resource_id = int(request.args.get('resource_id', None))
session = db.get_session()
resource = session.query(db.Resource).filter_by(id=resource_id).first()
session.close()
if (resource is None):
return None
return getResourceInfo(resource)
class LeaveGroup(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('group_id', 'the id of the group which the user want to leave')
@api.doc(description='''The user can leave the current group''')
def get(self):
user = authorize(request)
group_id = int(request.args.get('group_id', None))
session = db.get_session()
group = session.query(db.Group).filter_by(id=group_id).first()
groupMember = session.query(db.GroupMember).filter_by(group_id=group.id, student_id=user.id).first()
if (groupMember is None):
abort(400, "The user is not in that group.")
group.num_member -= 1
if (groupMember.role == 'backend'):
group.num_backend -= 1
else:
group.num_frontend -= 1
session.delete(groupMember)
session.commit()
session.close()
return {
'message': 'success'
}
class Assignment(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), assignment_details(api))
@api.doc(description='''
Post a new assignment.<br>
The toptics are separated by '|'
''')
def post(self):
authorize(request)
(course_id, title, publish_date, due_date, group_size, all_topics, content) = unpack(request.json, 'course_id', 'title', 'publish_date', 'due_date', 'group_size', 'all_topics', 'content')
session = db.get_session()
new_assignment = db.Assignment(course_id=course_id, title=title, publish_date=publish_date, due_date=due_date, group_size=group_size, all_topics=all_topics, content=content)
session.add(new_assignment)
session.commit()
session.close()
return {
'message': 'success'
}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('course_id', 'the id of the course which the user want to fetch')
@api.doc(description='''
Get the assignment information of a course<br>
The toptics are separated by '|'
''')
def get(self):
authorize(request)
course_id = int(request.args.get('course_id', None))
session = db.get_session()
assignment = session.query(db.Assignment).filter_by(course_id=course_id).first()
session.close()
if (assignment is None):
return None
return {
'assignmentInfo': getAssignmentInfo(assignment)
}
class Chat(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), message_details(api))
@api.doc(description='''
User can send a new message
''')
def post(self):
user = authorize(request)
(chat_room_id, message) = unpack(request.json, 'chat_room_id',
'message')
session = db.get_session()
message = db.Message(chat_room_id=chat_room_id,
user_id=user.id,
message=message)
session.add(message)
session.commit()
session.close()
return {'message': 'success'}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('chat_room_id',
'the id of the chatroom which the user want to fetch')
@api.doc(description='''Get chat room messages''')
def get(self):
user = authorize(request)
chat_room_id = int(request.args.get('chat_room_id', None))
session = db.get_session()
messages = session.query(
db.Message).filter_by(chat_room_id=chat_room_id).all()
session.close()
messageList = []
for message in messages:
messageList.append(getMessageInfo(message))
return messageList
class Comment(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), comment_details(api))
@api.doc(description='''
User can post a new comment to a thraed
''')
def post(self):
user = authorize(request)
(thread_id, publisher_id, content) = unpack(request.json, 'thread_id', 'publisher_id', 'content')
session = db.get_session()
comment = db.Comment(thread_id=thread_id, publisher_id=publisher_id, content=content)
session.add(comment)
session.commit()
session.close()
return {
'message': 'success'
}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('thread_id', 'the id of the thread which the user want to fetch')
@api.doc(description='''Get the comments of that thread''')
def get(self):
user = authorize(request)
thread_id = int(request.args.get('thread_id', None))
session = db.get_session()
comments = session.query(db.Comment).filter_by(thread_id=thread_id).all()
session.close()
if (comments is None):
return None
commentList = []
for comment in comments:
commentList.append(getCommentInfo(comment))
return commentList
class MatchGroup(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), group_match_details(api))
@api.doc(description='''
User can match the group which is best for him
''')
def post(self):
user = authorize(request)
(assignment_id, topic, backend_skill, frontend_skill) = unpack(request.json, 'assignment_id', 'topic', 'backend_skill', 'frontend_skill')
session = db.get_session()
if (backend_skill >= frontend_skill):
skill = 'backend'
else:
skill = 'frontend'
groups = session.query(db.Group).filter_by(assignment_id=assignment_id, topic=topic).all()
assignment = session.query(db.Assignment).filter_by(id=assignment_id).first()
if (assignment is None):
abort(400, "Assignment does not exist")
group_size = assignment.group_size
found = False
for group in groups:
if (group.num_member == group_size):
continue
if (skill == 'backend'):
if (group.num_frontend >= group.num_backend):
found = True
group.num_backend += 1
break
if (skill == 'frontend'):
if (group.num_frontend <= group.num_backend):
found = True
group.num_frontend += 1
break
if (not found):
return {
'message': 'Sorry, we cannot find a group for you. You can create a new group.'
}
new_member = db.GroupMember(group_id=group.id, student_id=user.id, role=skill)
session.add(new_member)
group.num_member += 1
session.commit()
group_id = group.id
session.close()
return {
'group_id': group_id
}
class Chatroom(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('course_id',
'the id of the course which the user want to fetch')
@api.param(
'channel',
'the channel which the user want to fetch(must be either "public" or "group")'
)
@api.doc(description='''Get chat room id''')
def get(self):
user = authorize(request)
course_id = int(request.args.get('course_id', None))
channel = request.args.get('channel', None)
if (channel != "public" and channel != "group"):
abort(400, "Wrong channel request")
session = db.get_session()
if (channel == "public"):
chatroom = session.query(db.ChatRoom).filter_by(
course_id=course_id).filter_by(channel=channel).first()
session.close()
else:
assignments = session.query(db.Assignment)
for assignment in assignments:
if (assignment.course_id == course_id):
break
groupMembers = session.query(
db.GroupMember).filter_by(student_id=user.id).all()
if (groupMembers is None):
abort(400, "User is not in a group")
found = 0
for groupMember in groupMembers:
group = session.query(
db.Group).filter_by(id=groupMember.group_id).first()
if (group.assignment_id == assignment.id):
found = 1
break
session.close()
if (found == 0):
return None
return {'chat_room_id': group.group_chatroom_id}
if (chatroom is None):
return None
return {'chat_room_id': chatroom.id}
class Group(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('group_id', 'the id of the group which the user want to fetch')
@api.doc(description='''Get the group info by id''')
def get(self):
authorize(request)
group_id = int(request.args.get('group_id', None))
session = db.get_session()
curr_group = session.query(db.Group).filter_by(id=group_id).first()
session.close()
if (curr_group is None):
return None
return{
'groupInfo': getGroupInfo(curr_group)
}
class AllGroup(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('assignment_id', 'the id of the assignment which the user want to fetch')
@api.doc(description='''Get all group info by assignment''')
def get(self):
authorize(request)
assignment_id = int(request.args.get('assignment_id', None))
session = db.get_session()
groups = session.query(db.Group).filter_by(assignment_id=assignment_id).all()
session.close()
if (groups is None):
return None
groupList = []
for group in groups:
groupList.append(getGroupInfo(group))
return groupList
class Threads(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('course_id', 'the id of the course which the user want to fetch')
@api.doc(description='''Get all threads in a course''')
def get(self):
authorize(request)
course_id = int(request.args.get('course_id', None))
session = db.get_session()
threads = session.query(db.Thread).filter_by(course_id=course_id).all()
session.close()
if (threads is None):
return None
threadList = []
for thread in threads:
threadList.append(getThreadInfo(thread))
return threadList
class ChatSearch(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('chat_room_id',
'the id of the chatroom which the user want to fetch')
@api.param('key_word', 'the key word you want to search')
@api.doc(description='''Search chat room messages''')
def get(self):
user = authorize(request)
chat_room_id = int(request.args.get('chat_room_id', None))
key_word = request.args.get('key_word', None)
session = db.get_session()
messages = session.query(
db.Message).filter_by(chat_room_id=chat_room_id).all()
session.close()
messageList = []
for message in messages:
if (key_word in message.message):
messageList.append(getMessageInfo(message))
return messageList
class Notice(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), notice_details(api))
@api.doc(description='''
Post a new notice.
''')
def post(self):
authorize(request)
(course_id, title, content, publisher_id) = unpack(request.json, 'course_id', 'title', 'content', 'publisher_id')
session = db.get_session()
new_notice = db.Notice(course_id=course_id, title=title, content=content, publisher_id=publisher_id)
session.add(new_notice)
session.commit()
session.close()
return {
'message': 'success'
}
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.param('course_id', 'the id of the course which the user want to fetch')
@api.doc(description='''
Get the notice information of a course<br>
''')
def get(self):
course_id = int(request.args.get('course_id', None))
session = db.get_session()
notices = session.query(db.Notice).filter_by(course_id=course_id).all()
session.close()
if (notices is None):
return None
noticeList = []
for notice in notices:
noticeList.append(getNoticeInfo(notice))
return noticeList
class CreateGroup(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api), create_group_details(api))
@api.doc(description='''
User can create a group<br>
The skill level is indicated by an integer, 3 means advanced level and 1 means beginner level
''')
def post(self):
user = authorize(request)
(assignment_id, title, topic, backend_skill, frontend_skill) = unpack(request.json, 'assignment_id', 'title', 'topic', 'backend_skill', 'frontend_skill')
session = db.get_session()
num_backend = 0
num_frontend = 0
if (backend_skill == frontend_skill):
num_backend = 1
skill = 'backend'
elif (backend_skill > frontend_skill):
num_backend = 1
skill = 'backend'
else:
num_frontend = 1
skill = 'frontend'
curr_assignment = session.query(db.Assignment).filter_by(id=assignment_id).first()
group_chatroom = db.ChatRoom(course_id=curr_assignment.course_id, channel="group")
session.add(group_chatroom)
session.commit()
new_group = db.Group(assignment_id=assignment_id, leader_id=user.id, title=title, topic=topic, group_chatroom_id = group_chatroom.id, num_member=1, num_backend=num_backend, num_frontend=num_frontend)
session.add(new_group)
session.commit()
new_member = db.GroupMember(group_id=new_group.id, student_id=user.id, role=skill)
session.add(new_member)
session.commit()
session.close()
return {
'message': 'success'
}
class Vote(Resource):
@api.response(200, 'Success')
@api.response(400, 'Missing Arguments')
@api.response(403, 'Invalid Auth Token')
@api.expect(auth_details(api))
@api.param('thread_id', 'the id of the thread which the user want to fetch')
@api.doc(description='''
User can up vote to a thraed
''')
def post(self):
authorize(request)
thread_id = int(request.args.get('thread_id', None))
session = db.get_session()
thread = session.query(db.Thread).filter_by(id=thread_id).first()
if (thread is None):
abort(400, "Thread does not exist")
thread.up_vote += 1
curr_up_vote = thread.up_vote
session.commit()
session.close()
return {
'curr_up_vote': curr_up_vote
}
