def modify_resource(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
try:
resource_id = int(parameter_dict['resource_id'])
resource = Resource.objects.get(resource_id=resource_id)
except (KeyError, TypeError, Resource.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
# 核对resource提交人
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if resource.user.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'你不是发布者'}))
# 修改resource
try:
resource_key = parameter_dict['resource_key']
description = parameter_dict['description']
content_type = parameter_dict['content_type']
content = parameter_dict['content']
except (KeyError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
resource.resource_key = resource_key
resource.description = description
resource.content_type = content_type
resource.content = content
err_msg = resource.validate()
if err_msg:
return HttpResponseBadRequest(json.dumps({'message': err_msg}))
resource.save()
return HttpResponse(json.dumps({'message': u'修改成功'}))
def accept_mate_invitation(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
invitation_id = decode_mate_invitation_id_from_code(
parameter_dict['invitation_code'])
if invitation_id == -1:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
invitation = MateInvitation.objects.get(invitation_id=invitation_id)
course = invitation.course
CourseJoin.objects.get(course=course, user=user)
except (KeyError, TypeError, MateInvitation.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
except CourseJoin.DoesNotExist:
return HttpResponseForbidden(json.dumps({'message': u'你还未加入课程'}))
if invitation.requester.user_id == user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'你不能接受自己的邀请'}))
try:
Mate.objects.get(Q(course=course),
Q(requester=user) | Q(acceptor=user))
return HttpResponseBadRequest(json.dumps({'message': u'你已经建立了课友关系'}))
except Mate.DoesNotExist:
try:
MateInvitation.objects.get(course=course, requester=user).delete()
except MateInvitation.DoesNotExist:
pass
invitation.delete()
Mate(course=course,
requester=invitation.requester,
acceptor=user,
establish_time=datetime.datetime.now()).save()
return HttpResponse(json.dumps({'message': u'接受邀请成功'}))
def query_my_mates(request):
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
mates = Mate.objects.filter(Q(requester=user) | Q(acceptor=user))
mate_list = []
for mate in mates:
mate_list.append(to_mate_dict(mate, user))
return HttpResponse(json.dumps({'mates': mate_list}))
def new_assignment(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
# 检查参数
try:
mate_id = int(parameter_dict['mate_id'])
mate = Mate.objects.get(mate_id=mate_id)
content = parameter_dict['content']
assignment_date = datetime.strptime(parameter_dict['assignment_date'],
DATE_FORMAT).date()
except (KeyError, ValueError, TypeError, Mate.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if datetime.today().date() > assignment_date:
return HttpResponseForbidden(json.dumps({'message': u'打卡日期已过期'}))
# 核对 mate
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if mate.requester.user_id != user.user_id and mate.acceptor.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'无权创建打卡计划'}))
# 新建日程
assignment = MateAssignment(mate=mate,
content=content,
assignment_date=assignment_date)
assignment.save()
return HttpResponse(
json.dumps({
'message': u'新建打卡成功',
'assignment_id': assignment.assignment_id
}))
def release_resource(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
course_id = int(parameter_dict['course_id'])
resource_key = parameter_dict['resource_key']
description = parameter_dict['description']
content_type = int(parameter_dict['content_type'])
content = parameter_dict['content']
course = Course.objects.get(course_id=course_id)
CourseJoin.objects.get(course=course, user=user)
except (KeyError, TypeError, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
except CourseJoin.DoesNotExist:
return HttpResponseBadRequest(json.dumps({'message': u'你还未加入课程'}))
resource = Resource(course=course,
user=user,
resource_key=resource_key,
description=description,
content_type=content_type,
content=content)
err_msg = resource.validate()
if err_msg:
return HttpResponseBadRequest(json.dumps({'message': err_msg}))
resource.save()
return HttpResponse(
json.dumps({
'message': u'发布成功',
'resource_id': resource.resource_id
}))
def query_open_courses(request):
parameter_dict = fetch_parameter_dict(request, 'GET')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
name = parameter_dict['name']
category = int(parameter_dict['category'])
order_by = parameter_dict['order_by']
page_size = int(parameter_dict['page_size'])
page_num = int(parameter_dict['page_num'])
except (KeyError, TypeError):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
# 查询数据库
start = (page_num - 1) * page_size
end = start + page_size
courses = Course.objects.filter(name__contains=name,
category=category,
status=1)[start:end]
count = Course.objects.filter(name__contains=name,
category=category,
status=1).count()
course_list = []
for course in courses:
course_list.append(to_course_dict(course, user))
# 返回成功
return HttpResponse(json.dumps({'count': count, 'courses': course_list}))
def modify_assignment(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
# 检查参数
try:
assignment_id = int(parameter_dict['assignment_id'])
assignment = MateAssignment.objects.get(assignment_id=assignment_id)
content = parameter_dict['content']
assignment_date = datetime.strptime(parameter_dict['assignment_date'],
DATE_FORMAT).date()
except (KeyError, ValueError, TypeError, MateAssignment.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if datetime.today().date() > assignment_date:
return HttpResponseForbidden(json.dumps({'message': u'打卡日期已过期'}))
# 核对schedule mate
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if assignment.status != 0:
return HttpResponseForbidden(json.dumps({'message': u'打卡进行中，无法修改'}))
if assignment.mate.requester.user_id != user.user_id and assignment.mate.acceptor.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'无权修改'}))
# 修改schedule
assignment.assignment_date = assignment_date
assignment.content = content
assignment.save()
return HttpResponse(json.dumps({'message': u'修改打卡计划成功'}))
def query_certain_course(request):
parameter_dict = fetch_parameter_dict(request, 'GET')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
course = Course.objects.get(course_id=int(parameter_dict['course_id']))
except (KeyError, TypeError, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
return HttpResponse(json.dumps({'course': to_course_dict(course, user)}))
def wrapper(request):
try:
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if not user:
return HttpResponse(content='登录状态已过期', status=401)
except KeyError:
return HttpResponse(content='登录状态已过期', status=401)
return func(request)
def unbind_mate(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
mate = Mate.objects.get(mate_id=int(parameter_dict['mate_id']))
except (KeyError, TypeError, Mate.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if mate.requester != user and mate.acceptor != user:
return HttpResponseForbidden(json.dumps({'message': u'无权操作'}))
mate.delete()
return HttpResponse(json.dumps({'message': u'课友关系解除成功'}))
def query_favored_resource(request):
parameter_dict = fetch_parameter_dict(request, 'GET')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
course = Course.objects.get(course_id=int(parameter_dict['course_id']))
except (KeyError, TypeError, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
favors = ResourceFav.objects.filter(resource__course=course, user=user)
resources_list = []
for favor in favors:
resources_list.append(to_resource_dict(favor.resource, user))
return HttpResponse(json.dumps({'resources': resources_list}))
def cancel_mate_invitation(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
invitation_id = int(parameter_dict['invitation_id'])
invitation = MateInvitation.objects.get(invitation_id=invitation_id)
except (KeyError, TypeError, MateInvitation.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if invitation.requester != user:
return HttpResponseForbidden(json.dumps({'message': u'无权操作'}))
invitation.delete()
return HttpResponse(json.dumps({'message': u'取消邀请成功'}))
def change_user_info(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
try:
username = parameter_dict['username']
workspace = parameter_dict['workspace']
email = parameter_dict['email']
except KeyError:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
user.username = username
user.workspace = workspace
user.email = email
user.save()
return HttpResponse(json.dumps({'message': u'修改成功'}))
def cancel_resource_fav(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
resource = Resource.objects.get(
resource_id=int(parameter_dict['resource_id']))
favor = ResourceFav.objects.get(resource=resource, user=user)
except (KeyError, TypeError, Resource.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
except ResourceFav.DoesNotExist:
return HttpResponseBadRequest(json.dumps({'message': u'你尚未收藏该帖'}))
favor.delete()
resource.favors -= 1
resource.save()
return HttpResponse(json.dumps({'message': u'取消收藏成功'}))
def resource_prefer(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
resource = Resource.objects.get(
resource_id=int(parameter_dict['resource_id']))
except (KeyError, TypeError, Resource.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
prefers = ResourcePrefer.objects.filter(resource=resource, user=user)
if prefers.exists():
return HttpResponseBadRequest(json.dumps({'message': u'你已点赞过该帖'}))
else:
prefer = ResourcePrefer(resource=resource, user=user)
prefer.save()
resource.prefers += 1
resource.save()
return HttpResponse(json.dumps({'message': u'点赞成功'}))
def delete_resource(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
# 检查resource_id
try:
resource_id = int(parameter_dict['resource_id'])
resource = Resource.objects.get(resource_id=resource_id)
except (KeyError, TypeError, Resource.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
# 核对resource提交人
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if resource.user.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'你不是发布者'}))
# 删除resource
resource.delete()
return HttpResponse(json.dumps({'message': u'删除成功'}))
def delete_assignment(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
# 检查参数
try:
assignment_id = int(parameter_dict['assignment_id'])
assignment = MateAssignment.objects.get(assignment_id=assignment_id)
except (KeyError, TypeError, MateAssignment.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
# 核对assignment mate
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if assignment.mate.requester.user_id != user.user_id and assignment.mate.acceptor.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'无权删除'}))
# 删除assignment
assignment.delete()
return HttpResponse(json.dumps({'message': u'删除日程成功'}))
def publish(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
try:
course = Course.objects.get(course_id=int(parameter_dict['course_id']))
except (KeyError, TypeError, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
# 是否为创建者
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if course.author.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'对不起，你不是课程的创建者'}))
# 课程是否已经公开
if course.status == 1:
return HttpResponseForbidden(json.dumps({'message': u'该课程已公开'}))
else:
course.status = 1
course.save()
return HttpResponse(json.dumps({'message': u'公开课程成功'}))
def query_my_mate_by_course(request):
parameter_dict = fetch_parameter_dict(request, 'GET')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
course = Course.objects.get(course_id=int(parameter_dict['course_id']))
print(course.to_dict())
CourseJoin.objects.get(course=course, user=user)
except (KeyError, TypeError, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
except CourseJoin.DoesNotExist:
return HttpResponseBadRequest(json.dumps({'message': u'你还未加入课程'}))
try:
mate = Mate.objects.get(Q(course=course),
Q(requester=user) | Q(acceptor=user))
return HttpResponse(json.dumps({'mate': to_mate_dict(mate, user)}))
except Mate.DoesNotExist:
return HttpResponseBadRequest(json.dumps({'message': u'你还没有课友'}))
def query_resource_by_course(request):
parameter_dict = fetch_parameter_dict(request, 'GET')
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
course = Course.objects.get(course_id=int(parameter_dict['course_id']))
content_type = int(parameter_dict['content_type'])
except (KeyError, TypeError, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if content_type == -1:
resources = course.resource_set.all()
else:
resources = course.resource_set.filter(content_type=content_type)
resources_list = []
for resource in resources:
resources_list.append(to_resource_dict(resource, user))
return HttpResponse(json.dumps({'resources': resources_list}))
def invite_mate(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
print(parameter_dict)
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
try:
course_id = int(parameter_dict['course_id'])
print('cid: ' + str(course_id))
description = parameter_dict['description']
print('cid: ' + str(course_id) + ' des:' + description)
course = Course.objects.get(course_id=course_id)
CourseJoin.objects.get(course=course, user=user)
except (KeyError, TypeError, User.DoesNotExist, Course.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
except CourseJoin.DoesNotExist:
return HttpResponseForbidden(json.dumps({'message': u'你还未加入课程'}))
try:
Mate.objects.get(Q(course=course),
Q(requester=user) | Q(acceptor=user))
return HttpResponseForbidden(json.dumps({'message': u'你已经建立了课友关系'}))
except Mate.DoesNotExist:
try:
MateInvitation.objects.get(course=course, requester=user)
return HttpResponseForbidden(json.dumps({'message':
u'你已经发布了课友邀请'}))
except MateInvitation.DoesNotExist:
mate_invitation = MateInvitation(
course=course,
requester=user,
invitation_code='#',
request_time=datetime.datetime.now(),
description=description)
mate_invitation.save()
mate_invitation.invitation_code = generate_mate_invitation_code(
mate_invitation.invitation_id)
mate_invitation.save()
return HttpResponse(
json.dumps({
'message': u'发布邀请成功',
'invitation_id': mate_invitation.invitation_id,
'invitation_code': mate_invitation.invitation_code
}))
def upload_course(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
try:
name = parameter_dict['name']
short_name = parameter_dict['short_name']
description = parameter_dict['description']
category = parameter_dict['category']
except KeyError:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
valid, short_name_language = _validate_short_name(short_name)
if not valid:
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
course = Course(author=user,
status=0,
name=name,
short_name=short_name,
description=description,
level=0,
heat=0,
category=category,
invitation_code='#')
course.save()
course.invitation_code = generate_course_invitation_code(course.course_id)
course.save()
CourseJoin(user=user, course=course).save()
background_color, font_color = fetch_color_schema(course.course_id)
generate_icon(
short_name, short_name_language, background_color, font_color,
PROJECT_ROOT + '/inscourse_backend/assets/images/short_name_icon_' +
str(course.course_id) + '.png')
return HttpResponse(
json.dumps({
'message': u'新建成功',
'course_id': course.course_id
}))
def check_assignment(request):
parameter_dict = fetch_parameter_dict(request, 'POST')
# 检查参数
try:
assignment_id = int(parameter_dict['assignment_id'])
assignment = MateAssignment.objects.get(assignment_id=assignment_id)
except (KeyError, TypeError, MateAssignment.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
if datetime.today().date() > assignment.assignment_date:
return HttpResponseForbidden(json.dumps({'message': u'任务已过期'}))
# 核对assignment mate
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if assignment.mate.requester.user_id != user.user_id and assignment.mate.acceptor.user_id != user.user_id:
return HttpResponseForbidden(json.dumps({'message': u'无权打卡'}))
if assignment.check_status(user) != 0:
assignment.save()
return HttpResponse(json.dumps({'message': u'打卡成功'}))
else:
return HttpResponseForbidden(json.dumps({'message': u'你已完成打卡'}))
def query_my_assignments_by_mate(request):
parameter_dict = fetch_parameter_dict(request, 'GET')
try:
mate_id = int(parameter_dict['mate_id'])
mate = Mate.objects.get(mate_id=mate_id)
except (KeyError, TypeError, Mate.DoesNotExist):
return HttpResponseBadRequest(EM_INVALID_OR_MISSING_PARAMETERS)
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
if mate.requester != user and mate.acceptor != user:
return HttpResponseBadRequest(json.dumps({'message': u'无权查看'}))
# assignments = mate.mate.assignment_set.all()
assignment_list = []
assignments = MateAssignment.objects.filter(Q(
mate=mate) & ~Q(status=3)).order_by('assignment_date')
for assignment in assignments:
assignment_list.append(assignment.to_detail_dict(user))
assignments = MateAssignment.objects.filter(Q(mate=mate) & Q(
status=3)).order_by('done_date')
for assignment in assignments:
assignment_list.append(assignment.to_detail_dict(user))
return HttpResponse(json.dumps({'assignments': assignment_list}))
def get_my_info(request):
user = fetch_user_by_token(request.META[TOKEN_HEADER_KEY])
return HttpResponse(json.dumps({'user': user.to_dict()}))
