def post(self):
session = db.get_session()
if not request.json:
abort(400, 'Malformed Request')
userInfo = authorize(request)
if not userInfo:
abort(403, 'Invalid Auth Token')
(request_title, request_content) = unpack(request.json,
'request_title',
'request_content')
request_time = getLocalTime()
new_request = db.Request(user_name=userInfo.username,
user_id=userInfo.id,
avatar=userInfo.avatar,
request_title=request_title,
request_content=request_content,
request_time=request_time)
session.add(new_request)
session.commit()
session.close()
return {'message': 'success'}
def post(self):
session = db.get_session()
if not request.json or not request.args:
abort(400, 'Missing Arguments')
userInfo = authorize(request)
if not userInfo:
abort(403, 'Invalid Auth Token')
request_id = request.args.get('req_id')
[comment_content] = unpack(request.json, 'comment_content')
req_info = session.query(db.Request).filter_by(id=request_id).first()
if not req_info:
abort(405, 'Invalid Request Id')
new_comment = db.Comment(request_id=request_id,
commenter_id=userInfo.id,
commenter_name=userInfo.username,
commenter_avatar=userInfo.avatar,
comment_content=comment_content,
comment_time=getLocalTime())
session.add(new_comment)
session.commit()
session.close()
return {'message': 'success'}
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'
}
def post(self):
session = db.get_session()
if not request.json:
abort(400, 'Malformed Request')
(username, password, email, phone, avatar) = unpack(request.json, 'username', 'password', 'email', 'phone', 'avatar')
if username == '' or password == '' or email == '' or phone == '':
abort(400, 'Malformed Request')
check_username = session.query(db.User).filter_by(username=username).first()
check_email = session.query(db.User).filter_by(email=email).first()
if check_username != None:
abort(409, 'Username Taken')
if check_email != None:
abort(410, 'Email Taken')
key = os.urandom(24)
password_bytes = password.encode()
hash_password = hashlib.sha256(key + password_bytes).hexdigest()
new_user = db.User(username=username,
password=hash_password,
email=email,
phone=phone,
avatar=base_img_url+avatar,
token='',
key=key)
session.add(new_user)
from run import app
send_register_email(app, username, email)
session.commit()
session.close()
return { 'message': 'success' }
def post(self):
session = db.get_session()
userInfo = authorize(request)
if not request.json:
abort(400, 'Malformed Request')
if not userInfo:
abort(403, 'Invalid Auth Token')
(property_id, review_content) = unpack(request.json, 'property_id', 'review_content')
review_date = getLocalTime()
new_review = db.Review(property_id=property_id,
reviewer_id=userInfo.id,
reviewer_name=userInfo.username,
review_date=review_date,
review_content=review_content,
head_picture=userInfo.avatar)
order_info = session.query(db.Order).filter_by(user_id=userInfo.id,property_id=property_id).first()
if order_info:
order_info.comment_status = False
session.add(new_review)
session.commit()
session.close()
return {'message': 'success'}
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}
def get(self):
session = db.get_session()
user = authorize(request)
user_id = request.args.get('user_id', None)
if (user_id is not None):
user = session.query(db.User).filter_by(id=user_id).first()
pro_host = session.query(db.Host).filter_by(host_id=user.id).all()
res = []
for host_obj in pro_host:
property_id = host_obj.property_id
pro_obj = session.query(db.Property).filter_by(property_id=property_id).first()
img_obj = session.query(db.Image).filter_by(property_id=property_id).first()
add_obj = session.query(db.Address).filter_by(property_id=property_id).first()
ord_obj = session.query(db.Order).filter_by(property_id=property_id).first()
if not ord_obj:
ord_obj = 0
res.append(getAllProOfHost(ord_obj,pro_obj, img_obj, add_obj))
session.close()
return {
"id": user.id,
'username': user.username,
'email': user.email,
'phone': user.phone,
'avatar': user.avatar,
'properties': res
}
def delete(self):
session = db.get_session()
if not request.args:
abort(400, 'Missing Arguments')
userInfo = authorize(request)
if not userInfo:
abort(403, 'Invalid Auth Token')
property_id = request.args.get('property_id')
host_obj = session.query(db.Host).filter_by(
property_id=property_id, host_id=userInfo.id).first()
if not host_obj:
abort(405, 'Invalid property_id')
else:
pro_obj = session.query(
db.Property).filter_by(property_id=property_id).first()
add_obj = session.query(
db.Address).filter_by(property_id=property_id).first()
session.delete(pro_obj)
session.delete(add_obj)
session.delete(host_obj)
session.commit()
session.close()
return {'message': 'success'}
def get(self):
course_id = int(request.args.get('course_id', None))
session = db.get_session()
course = session.query(db.Course).filter_by(id=course_id).first()
session.close()
return {
'courseInfo': getCourseInfo(course)
}
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)
def generatePropertyId():
while True:
pro_id = random.randint(10000, 100000)
session = db.get_session()
pro_info = session.query(
db.Property).filter_by(property_id=pro_id).first()
if not pro_info:
break
return pro_id
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)
def get(self):
session = db.get_session()
courses = session.query(db.Course)
session.close()
if (courses is None):
return None
courseList = []
for course in courses:
courseList.append(getCourseInfo(course))
return courseList
def authorize(request):
res = request.headers.get('Authorization', None)
if not res:
abort(403, 'Unsupplied Authorization Token')
session = db.get_session()
user = session.query(db.User).filter_by(token=res).first()
session.close()
if not user:
abort(403, 'Invalid Authorization Token')
return user
def getMessageInfo(raw):
session = db.get_session()
user = session.query(db.User).filter_by(id=raw.user_id).first()
session.close()
return {
"id": raw.id,
'user_id': raw.user_id,
'user_name': user.name,
'message': raw.message
}
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'
}
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)
}
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'
}
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'
}
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
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
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)
}
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'
}
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'
}
def get(self):
course_id = int(request.args.get('course_id', None))
session = db.get_session()
staffs = session.query(db.Teaching).filter_by(course_id=course_id).all()
session.close()
if (staffs is None):
return None
satffList = []
for satff in staffs:
satffList.append(getStaffInfo(satff))
return satffList
def get(self):
course_id = int(request.args.get('course_id', None))
session = db.get_session()
resources = session.query(db.Resource).filter_by(course_id=course_id).all()
session.close()
if (resources is None):
return None
resourceList = []
for resource in resources:
resourceList.append(getResourceInfo(resource))
return resourceList
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
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
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
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
