def like(self, request, data, act_id):
try:
act = Activity.objects.get(id=act_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="activity not found"))
if act.liked_by.filter(id=request.user.id).exists():
likes = act.liked_by.all()[0:2]
length = likes.count()
if length > 0 and act.recent_like_user_id == request.user.id:
if length > 1:
act.recent_like_user = likes[1]
else:
act.recent_like_user = None
act.liked_by.remove(request.user)
act.like_num -= 1
act.save()
return JsonResponse(dict(success=True, data=dict(liked=False, like_num=act.liked_by.count())))
else:
act.like_num += 1
act.liked_by.add(request.user)
act.recent_like_user = request.user
act.save()
if act.user != request.user:
send_notification.send(
sender=Activity,
target=act.user,
display_mode="minimal",
extra_info="like",
related_act=act,
related_user=request.user
)
return JsonResponse(dict(success=True, data=dict(liked=True, like_num=act.liked_by.count())))
def post_new_status(request, data):
form = StatusCreationForm(data, request.FILES)
if form.is_valid():
status = form.save()
if 'inform_of' in data:
ats = get_user_model().objects.filter(id__in=data['json_data'])
for at in ats:
# send_notification.send(sender=get_user_model(),
# message_type="status_inform",
# target=at,
# message_body="",
# related_status=status)
send_notification.send(
sender=Status,
target=at,
display_mode="with_cover",
extra_info="at",
related_user=request.user,
related_status=status
)
return JsonResponse(dict(success=True, data=status.dict_description()))
else:
response_dict = dict(success=False)
response_dict.update(form.errors)
logger.debug(u"Fail to post new status, the error info is %s" % response_dict)
return JsonResponse(response_dict)
def invite(self, request, data, act_id):
appliers = data.get('target_user')
appliers = json.loads(appliers)
try:
act = Activity.objects.get(id=act_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=True, message="Activity Not Found"))
users = User.objects.filter(~Q(id=request.user.id), id__in=appliers)
if len(users) != len(appliers):
return JsonResponse(dict(success=False, message="user id list is not valid"))
for user in users:
# send_notification.send(
# sender=ActivityJoin,
# target=user,
# related_user=request.user,
# related_act=act,
# message_type="act_invited",
# message_body=""
# )
send_notification.send(
sender=ActivityJoin,
target=user,
display_mode="interact",
extra_info="invited",
related_act=act,
related_user=request.user
)
return JsonResponse(dict(success=True))
def club_apply(request, club_id):
try:
club = Club.objects.get(pk=club_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="club not found"))
if ClubJoining.objects.filter(user=request.user, club=club).exists():
return JsonResponse(dict(success=False, message="already join"))
if Notification.objects.filter(
target=club.host,
related_user=request.user,
related_club=club,
sender_class_name=ClubJoining.__name__,
extra_info="apply",
checked=False,
).exists():
return JsonResponse(dict(success=False, message="already applied"))
# send_notification.send(
# sender=Club,
# target=club.host,
# related_user=request.user,
# related_club=club,
# message_type="club_apply",
# message_body=""
# )
send_notification.send(
sender=ClubJoining,
target=club.host,
display_mode="interact",
extra_info="apply",
related_club=club,
related_user=request.user
)
return JsonResponse(dict(success=True))
def activity_apply(request, act_id):
""" 报名活动
"""
try:
act = Activity.objects.get(id=act_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, code="7001", message="Activity with id %s not found" % act_id))
# permission check
if act.authed_user_only and not request.user.identified:
return JsonResponse(dict(success=False, message="no permission"))
# club = act.allowed_club
# if club is not None:
# if not ClubJoining.objects.filter(club=club, user=request.user).exists():
# logger.debug(u'有个用户试图加入一个他并未加入的俱乐部的活动,权限问题。用户为{phone}, 活动为{act_id}'.format(
# phone=request.user.username, act_id=act_id
# ))
# return JsonResponse(dict(success=False, message='Not Allowed'))
# 检查是否已经报满了
current_join_count = ActivityJoin.objects.filter(activity=act, approved=True).count()
if current_join_count >= act.max_attend:
return JsonResponse(dict(success=False, message="full"))
join, created = ActivityJoin.objects.get_or_create(user=request.user, activity=act)
if not created:
logger.debug(u'对活动{act_id}出现了重复报名, 用户为{phone}'.format(act_id=act_id, phone=request.user.username))
return JsonResponse(dict(success=False, message="denied"))
else:
# send a notification to the host of the activity
# send_notification.send(sender=Activity,
# target=act.user,
# related_user=request.user,
# message_type="act_applied",
# related_act=act,
# message_body="")
send_notification.send(
sender=ActivityJoin,
target=act.user,
display_mode="with_cover",
extra_info="apply",
related_user=request.user,
related_act=act
)
return JsonResponse(dict(success=True, join=True))
def invite_agree(self, request, data, act_id):
inviter_id = data.get('target_user')
try:
notif = Notification.objects.select_related("related_act").get(
extra_info="invited",
sender_class_name=ActivityJoin.__name__,
target=request.user,
related_act_id=act_id,
related_user_id=inviter_id,
checked=False
)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="Not Invited"))
# 检查是否已经报满了
act = notif.related_act
cur_join_num = ActivityJoin.objects.filter(activity=act, approved=True).count()
if cur_join_num >= act.max_attend:
return JsonResponse(dict(success=False, message="full"))
notif.flag = True
notif.checked = True
notif.save()
# send_notification.send(
# sender=Activity,
# target=notif.related_user,
# related_user=request.user,
# related_act=notif.related_act,
# message_type="act_invitation_agreed",
# message_body=""
# )
send_notification.send(
sender=ActivityJoin,
target=notif.related_user,
display_mode="minimal",
extra_info="invite_agreed",
related_user=request.user,
related_act=notif.related_act
)
join, created = ActivityJoin.objects.get_or_create(
user=request.user, activity=act
)
if not created:
join.approved = True
join.save()
return JsonResponse(dict(success=True))
def invite_deny(self, request, data, act_id):
applier = data.get('target_user')
try:
notif = Notification.objects.select_related("related_act", "related_user").get(
extra_info="invited",
sender_class_name=ActivityJoin.__name__,
target=request.user,
related_user_id=applier,
related_act_id=act_id,
checked=False
)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="Not invited"))
notif.flag = False
notif.checked = True
notif.save()
#
# send_notification.send(
# sender=Activity,
# target=notif.related_user,
# related_act=notif.related_act,
# related_user=request.user,
# message_type="act_invitation_denied",
# message_body=""
# )
send_notification.send(
sender=ActivityJoin,
target=notif.related_user,
display_mode="minimal",
extra_info="invite_denied",
related_user=request.user,
related_act=notif.related_act
)
join, created = ActivityJoin.objects.get_or_create(
user=request.user, activity=notif.related_act
)
if created and join.approved:
join.approved = False
join.save()
return JsonResponse(dict(success=True))
def save_model(self, request, obj, form, change):
old_obj = SportCarIdentificationRequestRecord.objects.get(id=obj.id)
if not old_obj.checked and obj.checked:
own = obj.ownership
own.identified = obj.approved
own.identified_at = timezone.now()
user = own.user
if own.identified and user.avatar_car is None:
user.avatar_car = own
user.save()
own.save()
send_notification.send(
sender=SportCarIdentificationRequestRecord,
target=user,
display_mode="minimal",
extra_info="agree" if obj.approved else "deny",
related_user=user,
related_own=own
)
super(SportCarIdentificationRequestRecordAdmin, self)\
.save_model(request, obj, form, change)
def follow(self, request, data, user_id):
try:
target_user = User.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="User Not Found"))
obj, created = UserRelation.objects.get_or_create(source_user=request.user, target_user=target_user)
if not created:
obj.delete()
return JsonResponse(dict(success=True, followed=False))
else:
# send_notification.send(sender=User,
# target=target_user,
# message_type="relation_follow",
# related_user=request.user,
# message_body="")
send_notification.send(
sender=User,
target=target_user,
display_mode="minimal",
extra_info="like",
related_user=request.user
)
return JsonResponse(dict(success=True, followed=True))
def kick_out(self, request, data, act_id):
# TODO: 去掉活动申请加入的审核,直接加进来就可以了
applier = data.get("target_user")
try:
join = ActivityJoin.objects.select_related("user", "activity").get(user_id=applier, activity_id=act_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="Application not found"))
# send_notification.send(
# sender=ActivityJoin,
# target=join.user,
# related_act=join.activity,
# message_type="kickout",
# message_body=""
# )
join.delete()
send_notification.send(
sender=ActivityJoin,
target=join.user,
display_mode="with_cover",
extra_info="kick_out",
related_act=join.activity,
related_user=request.user
)
return JsonResponse(dict(success=True))
def post_activity_comment(request, data, act_id):
""" 对活动发布评论
返回分配给这个活动的id
"""
try:
activity = Activity.objects.get(id=act_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="Activity not found", code='7000'))
if 'response_to' in data:
try:
response_to = ActivityComment.objects.get(id=data['response_to'])
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, code='7001', message='Activity comment not found.'))
else:
response_to = None
try:
comment = ActivityComment.objects.create(
user=request.user, image=request.FILES.get('image', None),
content=data.get('content', None), response_to=response_to, activity=activity
)
except ValidationError:
return JsonResponse(dict(success=False, code='7002', message='No valid content found for the comment'))
if 'inform_of' in data:
inform_users = get_user_model().objects.filter(id__in=data['json_data'])
comment.inform_of.add(*inform_users)
for at in inform_users:
send_notification.send(
sender=ActivityComment,
target=at,
display_mode="with_cover",
extra_info="at",
related_user=request.user,
related_act=activity,
related_act_comment=comment
)
if response_to is not None:
send_notification.send(
sender=ActivityComment,
target=response_to.user,
display_mode="with_cover",
extra_info="response",
related_user=request.user,
related_act=activity,
related_act_comment=comment
)
if request.user != activity.user:
send_notification.send(
sender=ActivityComment,
target=activity.user,
display_mode="with_cover",
extra_info="response",
related_user=request.user,
related_act=activity,
related_act_comment=comment
)
return JsonResponse(
dict(success=True,
data=dict(id=comment.id, comment_num=ActivityComment.objects.filter(activity=activity).count()))
)
def activity_create(request, data):
""" 创建活动
需要上传的参数为:
- name
- description
- inform_of 提醒的用户的列表
- max_attend
- start_at
- end_at
- club_limit
- poster
- location
|- lat
|- lon
|- description
|- city
"""
if not SportCarOwnership.objects.filter(user=request.user, identified=True).exists():
return JsonResponse(dict(success=False, message="no permission"))
if 'inform_of' in data:
inform_of = json.loads(data['inform_of'])
users = get_user_model().objects.filter(id__in=inform_of)
else:
users = None
location = json.loads(data['location'])
# if 'club_limit' in data:
# try:
# club_limit = Club.objects.get(id=data['club_limit'])
# except ObjectDoesNotExist:
# club_limit = None
# else:
# club_limit = None
loc = Location.objects.create(
location=Point(location['lon'], location['lat']),
description=location['description'],
city=location.get("city") or ""
)
act = Activity.objects.create(
name=data['name'],
description=data['description'],
max_attend=data['max_attend'],
start_at=datetime.datetime.strptime(data['start_at'], '%Y-%m-%d %H:%M:%S.%f %Z'),
end_at=datetime.datetime.strptime(data['end_at'], '%Y-%m-%d %H:%M:%S.%f %Z'),
location=loc,
allowed_club=None,
poster=request.FILES['poster'],
user=request.user,
authed_user_only=(data["authed_user_only"])
)
# ActivityJoin.objects.create(user=request.user, activity=act)
if users is not None:
act.inform_of.add(*users)
for user in users:
# send_notification.send(
# sender=Activity,
# target=user,
# related_act=act,
# related_user=request.user,
# message_type="act_invited",
# message_body=""
# )
send_notification.send(
sender=ActivityJoin,
target=user,
display_mode="interact",
extra_info="invited",
related_act=act,
related_user=request.user
)
return JsonResponse(dict(success=True, id=act.id))
def status_operation(request, data, status_id):
if 'op_type' not in data:
logger.warn(u'动态操作错误')
return JsonResponse(dict(success=False, code='4300', message='No valid operation type param found.'))
op_type = data['op_type']
try:
status = Status.objects.get(id=status_id, deleted=False)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, code='4002', message='Status not found.'))
if op_type == 'like':
# 点赞
obj, created = StatusLikeThrough.objects.get_or_create(user=request.user,
status=status)
if not created:
likes = StatusLikeThrough.objects.select_related("user").filter(status=status).order_by("-like_at")[0: 2]
length = likes.count()
if length > 0 and obj.id == likes[0].id:
if length > 1:
status.recent_like_user = likes[1].user
else:
status.recent_like_user = None
status.save()
obj.delete()
elif status.user != request.user:
status.recent_like_user = request.user
status.save()
send_notification.send(
sender=Status,
target=status.user,
display_mode="with_cover",
extra_info="like",
related_user=request.user,
related_status=status
)
result = dict(
like_state=created,
like_num=StatusLikeThrough.objects.filter(status=status).count()
)
return JsonResponse(dict(success=True, like_info=result))
elif op_type == "delete":
# 删除
if status.user != request.user:
# no permission
logger.warning(u'动态删除权限问题, 参与用户id:{user_id}, 涉及动态为{status_id}'.format(
user_id=request.user.id,
status_id=status.id
))
return JsonResponse(dict(success=False, code="code", message="no permission"))
status.deleted = True
status.save()
return JsonResponse(dict(success=True))
elif op_type == "report":
StatusReport.objects.get_or_create(
user=request.user,
status=status,
reason=data["reason"]
)
return JsonResponse(dict(success=True))
else:
logger.warning(u"非法操作, 涉及用户为%s" % request.user.id)
return JsonResponse(dict(success=False, code='4004', message='Operation not defined'))
def status_post_comment(request, data, status_id):
""" 发布评论
post上来的data的结构为
:keyword response_to 回复的目标评论，可以不存在
:keyword inform_of 要@的人的id列表
:keyword content 评论的文字内容
:keyword image 评论的图片，从request.FILES中取得
"""
try:
status = Status.objects.get(id=status_id)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, code='4002', message='Status not found.'))
if 'response_to' in data:
try:
response_to = StatusComment.objects.get(id=data['response_to'])
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, code='4002', message='Comments not found.'))
else:
response_to = None
try:
# Caution: image属性即将废除
comment = StatusComment.objects.create(user=request.user,
image=request.FILES.get('image', None),
content=data.get('content', None),
response_to=response_to,
status=status)
except ValidationError:
logger.debug(u'发表动态评论的时候失败,缺少必要数据。目前提交的内容为%s' % data.get('content', None))
return JsonResponse(dict(success=False, code='4003', message=u'No valid content found for the comment'))
if 'inform_of' in data:
ats = get_user_model().objects.filter(id__in=data['json_data'])
comment.inform_of.add(*ats)
for at in ats:
# send_notification.send(sender=get_user_model(),
# message_type="status_inform",
# target=at,
# message_body="",
# related_status=status)
send_notification.send(
sender=StatusComment,
target=at,
display_mode="with_cover",
extra_info="at",
related_user=request.user,
related_status=status,
related_status_comment=comment
)
# if the comment replies to another comment, send a notification to the sender of that comment as well.
if 'response_to' in data:
# send_notification.send(sender=StatusComment,
# message_type="status_comment_replied",
# target=response_to.user,
# message_body=comment.content,
# related_status_comment=comment,
# related_status=status,
# related_user=comment.user)
send_notification.send(
sender=StatusComment,
target=response_to.user,
display_mode="with_cover",
extra_info="response",
related_user=comment.user,
related_status=comment.status,
related_status_comment=comment
)
if response_to.user == status.user:
# avoid duplicated notifications about the same comment
return JsonResponse(dict(success=True, id=comment.id))
# send a notification message to the sender of the status
if status.user != request.user:
# send_notification.send(sender=Status,
# message_type="status_comment",
# target=status.user,
# message_body=comment.content,
# related_status_comment=comment,
# related_status=status,
# related_user=comment.user)
send_notification.send(
sender=StatusComment,
target=status.user,
display_mode="with_cover",
extra_info="response",
related_user=comment.user,
related_status=comment.status,
related_status_comment=comment
)
return JsonResponse(dict(success=True, id=comment.id))
def club_operation(request, data, club_id):
op_type = data.get("op_type")
if op_type == "club_apply_agree":
applier = data.get("target_user")
try:
notif = Notification.objects\
.select_related("related_club", "related_user", "target")\
.get(
extra_info="apply",
sender_class_name=ClubJoining.__name__,
related_user_id=applier,
target=request.user,
related_club_id=club_id,
)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="Applicant not found"))
notif.checked = True
notif.flag = True
notif.save()
# send_notification.send(
# sender=Club,
# target=notif.related_user,
# related_user=notif.target,
# related_club=notif.related_club,
# message_type="club_apply_agreed",
# message_body=""
# )
send_notification.send(
sender=ClubJoining,
target=notif.related_user,
display_mode="with_cover",
extra_info="agree",
related_user=notif.target,
related_club=notif.related_club
)
ClubJoining.objects.get_or_create(
user=notif.related_user,
club=notif.related_club
)
# create the related chat entity
entity, created = ChatEntity.objects.get_or_create(
host=notif.related_user,
club=notif.related_club
)
if created:
message = entity.dict_description()
message = json.dumps({"target_user": entity.host.id, "payload": message})
send_string_message(message)
return JsonResponse(dict(success=True))
elif op_type == "club_apply_denied":
applier = data.get("target_user")
try:
notif = Notification.objects \
.select_related("related_club", "related_user", "target") \
.get(
extra_info="apply",
sender_class_name=ClubJoining.__name__,
related_user_id=applier,
target=request.user,
related_club_id=club_id,
)
except ObjectDoesNotExist:
return JsonResponse(dict(success=False, message="Applicant not found"))
notif.checked = True
notif.flag = False
notif.save()
# send_notification.send(
# sender=Club,
# target=notif.related_user,
# related_user=notif.target,
# related_club=notif.related_club,
# message_type="club_apply_denied",
# message_body=""
# )
send_notification.send(
sender=ClubJoining,
target=notif.related_user,
display_mode="with_cover",
extra_info="deny",
related_user=notif.target,
related_club=notif.related_club
)
return JsonResponse(dict(success=True))
else:
return JsonResponse(dict(success=False, message="Undefined Operation Type"))
