def login(request, *args, **kwargs):
put = QueryDict(request.body)
username = put["username"]
password = put["password"]
if not username:
return return_error(u"用户名不能为空")
if not password:
return return_error(u"密码不能为空")
user = authenticate(username=username, password=password)
if user is None:
return return_error(u"验证失败")
auth.login(request, user)
user = UserWrapper(username=user.username,
email=user.email,
avatar=get_avatar_url(user))
data = UserWrapperSerializer(user).data
response = create_response(CODE_OK, u"登录成功", data,
UserWrapperResponseSerializer)
context = {}
context.update(csrf(request))
response.set_cookie("csrftoken", context['csrf_token'])
return response
def init_chat_room(request):
for user in User.objects.all():
try:
create_chat_room(user)
except Exception as e:
print e.message
return_error(u"failed")
return return_message(u"ok")
def follow_anchor(request, *arg, **kwargs):
put = QueryDict(request.body)
if ANCHOR_ID not in put:
return return_error(u"缺少anchor id")
if request.method == "PUT":
return put_follow(request)
elif request.method == "DELETE":
return delete_follow(request)
else:
return return_error(u"不支持请求")
def watch_program(request, room_id, *args, **kwargs):
try:
if request.method == 'DELETE':
return do_delete_watch_program(request, room_id, args, kwargs)
elif request.method == 'PUT':
return do_put_watch_program(request, room_id, args, kwargs)
else:
return return_error(u'仅支持delete和post')
except Exception as e:
return return_error(u'服务端异常')
def has_live_permission(request, *arg, **kwargs):
user = request.user
anchor = Anchor.objects.get(user=user)
if anchor is None:
return return_error(u"你还不是主播，请申请后再开播")
return return_message(u"Ok")
def do_put_watch_program(request, room_id, *args, **kwargs):
id = int(room_id)
room = RoomModel.objects.get(id=id)
room.count += 1
room.save()
owner = room.ownerId.user
try:
jid = query_chat_room(owner)
if not jid:
return return_error(u"连接弹幕服务器失败")
program = Program(chat_room=jid, title=room.title, count=room.count, owner_id=room.ownerId.id,
owner_name=room.ownerId.user.username)
return create_response(CODE_OK, u"OK", ProgramSerializer(program).data, ProgramResponseSerializer)
except Exception as e:
print e.message
return return_error(u"连接弹幕服务器失败")
def put_follow(request):
put = QueryDict(request.body)
anchor_id = put[ANCHOR_ID]
try:
anchor = Anchor.objects.get(id=anchor_id)
try:
UserToAnchorRelationship.objects.get(audience=request.user,
anchor=anchor)
return return_error(u"已经关注过了")
except:
pass
relationship = UserToAnchorRelationship(audience=request.user,
anchor=anchor)
relationship.save()
return return_message(u"关注成功")
except Exception as e:
log_info(put_follow.__name__, e.message)
return return_error(u"未知错误")
def register_anchor(request, *arg, **kwargs):
user = request.user
try:
Anchor.objects.get(user=user)
return return_error(u"你已经是主播了")
except Exception as e:
log_info(register_anchor.__name__, e.message)
anchor = Anchor(user=user)
anchor.save()
return return_message(u"注册成功")
def delete_follow(request):
put = QueryDict(request.body)
anchor_id = put[ANCHOR_ID]
try:
anchor = Anchor.objects.get(id=anchor_id)
relationship = UserToAnchorRelationship.objects.get(
audience=request.user, anchor=anchor)
relationship.delete()
return return_message(u"取关成功")
except Exception as e:
log_info(delete_follow.__name__, e.message)
return return_error(u"还未关注过")
def close_broadcast(request, *arg, **kwargs):
user = request.user
anchor = Anchor.objects.get(user=user)
if anchor is None:
return return_error(u"你还不是主播，请申请后再开播")
try:
room = RoomModel.objects.get(ownerId=anchor)
room.delete()
return return_message(u'关播成功')
except Exception as e:
log_error(close_broadcast, e.message)
return return_message(u"你还没有开播")
def register(request, *args, **kwargs):
username = request.POST["username"]
password = request.POST["password"]
email = request.POST["email"]
if not username:
return return_error(u"用户名不能为空")
if not password:
return return_error(u"密码不能为空")
if not email:
return return_error(u"邮箱不能为空")
try:
user = User.objects.create_user(username, email, password)
user.save()
except Exception as e:
return return_error(u"%s已经被注册" % username)
return return_message(u"注册成功")
def fetch_rooms(request, category):
if not category or not CATEGORY_MAP[int(category)]:
return return_error(u"类别有误")
name = CATEGORY_MAP[int(category)]
category = CategoryModel.objects.get(name=name)
index = 0
if 'page' in request.GET:
index = int(request.GET['page'])
rooms = RoomModel.objects.filter(categoryId=category.id)[(index - 1) * 10: index * 10]
response = []
for room in rooms:
user = room.ownerId.user
roomResponse = Room(room.id, room.title, room_snapshot(category.name, user.username),
room.ownerId.user.last_name, room.count, room_live_url(user), room.ownerId.user.id)
response.append(RoomSerializer(roomResponse).data)
return create_response(CODE_OK, u'Ok', response, RoomResponseSerializer)
def open_broadcast(request, *arg, **kwargs):
user = request.user
anchor = Anchor.objects.get(user=user)
if anchor is None:
return return_error(u"你还不是主播，请申请后再开播")
try:
RoomModel.objects.get(ownerId=anchor)
return return_error(u'你已经开播了')
except Exception as e:
pass
put = QueryDict(request.body)
if KEY_CATEGORY not in put:
return return_error(u"类别有误")
category = put[KEY_CATEGORY]
if not category or not CATEGORY_MAP[int(category)]:
return return_error(u"类别有误")
title = put[KEY_TITLE]
if not title:
return return_error(u"标题不能为空")
category_name = CATEGORY_MAP[int(category)]
try:
category = CategoryModel.objects.get(name=category_name)
except Exception as e:
print e.message
return return_error(u"类别有误")
open_broadcast_impl(user, anchor, category, title)
live_url = "rtmp://%s:%s/chan_live/%s" % (IP, RTMP_PORT, user.username)
chat_url = create_chat_room(user)
broadcast = Broadcast(title=title, live_url=live_url, chat_url=chat_url)
return create_response(CODE_OK, "OK",
BroadcastSerializer(broadcast).data,
BroadcastResponseSerializer)
def logout(request, *args, **kwargs):
user = request.user
if not user and not user.is_authenticated():
return return_error(u"当前用户并没有登录", code=CODE_NO_AUTHENTICATION)
auth.logout(request)
return return_message(u"登出成功")