def get_context(self, request, *args, **kwargs):
meeting = models.Meeting.objects.filter(
pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if meeting.user_id != request.user.pk and (
not meeting.room.create_user_manager
or request.user.pk != meeting.room.create_user_id):
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
data = dict()
update_fields = list()
if meeting.name != request.params.name:
data['name'] = {'from': meeting.name, 'to': request.params.name}
update_fields.append('name')
meeting.name = request.params.name
if meeting.description != request.params.description:
data['description'] = {
'from': meeting.description,
'to': request.params.description
}
update_fields.append('description')
meeting.name = request.params.name
if update_fields:
with transaction.atomic():
meeting.save(force_update=True, update_fields=update_fields)
models.MeetingTrace.objects.create(
meeting_id=meeting.pk,
user_id=request.user.pk,
owner=request.user.pk == meeting.user_id,
type=constants.MEETING_TRACE_TYPE_CODE.EDIT.code,
data=json.dumps(data, ensure_ascii=False))
return serializer.MeetingDetailSerializer(meeting,
request=request).data
def get_corp_agent_info(cls, request):
corp_agent_id = cache.CorpAgentCache.get(
"%s|||%s" % (request.params.app_id, request.params.corp_id))
if corp_agent_id is not None:
corp_agent = models.CorpAgent.get_obj_by_pk_from_cache(
corp_agent_id)
if corp_agent is not None and corp_agent.delete_status == core_constants.DELETE_CODE.NORMAL.code:
return corp_agent
cache.CorpAgentCache.delete(
"%s|||%s" % (request.params.app_id, request.params.corp_id))
agent = models.Agent.get_obj_by_unique_key_from_cache(
appid=request.params.app_id)
if agent is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
suite = agent.suite
corp = models.Corp.objects.filter(corpid=request.params.corp_id,
suite_id=suite.suite_key).first()
if corp is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
corp_agent = models.CorpAgent.objects.filter(agent_id=agent.appid,
corp_id=corp.pk).first()
if corp_agent is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
cache.CorpAgentCache.set(
"%s|||%s" % (request.params.app_id, request.params.corp_id),
corp_agent.pk)
return corp_agent
def get_context(self, request, *args, **kwargs):
if request.params.start_time >= request.params.end_time:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if not self.time_ok(request.params.start_time) or not self.time_ok(request.params.end_time):
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
now = datetime.datetime.now()
if request.params.date == now.date() and request.params.start_time < now.time():
raise CustomError(ErrCode.ERR_MEETING_ROOM_TIMEOVER)
with transaction.atomic():
if models.Meeting.objects.filter(room_id=request.params.room_id, date=request.params.date).filter(
(Q(start_time__lte=request.params.start_time) & Q(end_time__gt=request.params.start_time))
| (Q(start_time__lt=request.params.end_time) & Q(end_time__gte=request.params.end_time))
| (Q(start_time__lte=request.params.start_time) & Q(start_time__gt=request.params.end_time))
| (Q(end_time__lt=request.params.start_time) & Q(end_time__gte=request.params.end_time))
).select_for_update().exists():
raise CustomError(ErrCode.ERR_MEETING_ROOM_INUSE)
meeting = models.Meeting.objects.create(
user_id=request.user.pk,
room_id=request.params.room_id,
name=request.params.name,
description=request.params.description,
date=request.params.date,
start_time=request.params.start_time,
end_time=request.params.end_time,
)
models.MeetingAttendee.objects.create(
user_id=request.user.pk,
meeting_id=meeting.pk
)
self.get_room_follow(request.params.room_id, request.user.pk)
return serializer.MeetingDetailSerializer(meeting, request=request).data
def get_context(self, request, *args, **kwargs):
room = models.Room.objects.filter(pk=request.params.room_id).first()
if room is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if room.create_user_id != request.user.pk:
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
room.delete()
return {}
def check_api_permissions(self, request, *args, **kwargs):
if not isinstance(request.user, auth_models.AbstractUser):
raise CustomError(ErrCode.ERR_AUTH_NOLOGIN)
if not request.user.is_active or not request.user.is_staff:
raise CustomError(ErrCode.ERR_AUTH_PERMISSION)
if self.need_superuser:
if not request.user.is_superuser:
raise CustomError(ErrCode.ERR_AUTH_PERMISSION)
def get_context(self, request, *args, **kwargs):
meeting = models.Meeting.objects.filter(
pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if meeting.user_id != request.user.pk:
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
meeting.delete()
return {}
def check_api_permissions(self, request, *args, **kwargs):
super(RoomBase, self).check_api_permissions(request, *args, **kwargs)
room = models.Room.objects.filter(pk=request.params.room_id).first()
if room is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
setattr(self, 'room', room)
if self.check_manager:
if room.create_user_id != request.user.pk:
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
def send(self):
if self.get_send_expiration() > 0:
raise CustomError(ErrCode.ERR_VCODE_WAIT, **self.data())
if self.count() > config.VERIFY_CODE_MOBILE_COUNT:
raise CustomError(ErrCode.ERR_VCODE_MOBILE_COUNT)
if not self._send_sms():
raise CustomError(ErrCode.ERR_VCODE_SEND_FAIL)
VerifyCodeCount.incr(self.mobile)
self.refresh_send_expiration_time()
self.save()
def get_context(self, request, *args, **kwargs):
room = models.Room.objects.filter(pk=request.params.room_id).first()
if room is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if room.create_user_id != request.user.pk:
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
room.name = request.params.name
room.description = request.params.description
room.save(force_update=True, update_fields=['name', 'description'])
return serializer.RoomSerializer(room, request=request).data
def check_api_permissions(self, request, *args, **kwargs):
super(MeetingBase, self).check_api_permissions(request, *args, **kwargs)
meeting = models.Meeting.objects.filter(pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
setattr(self, 'meeting', meeting)
if self.check_manager:
if meeting.user_id != request.user.pk and (
not meeting.room.create_user_manager or request.user.pk != meeting.room.create_user_id
):
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
def get_context(self, request, *args, **kwargs):
meeting = models.Meeting.objects.filter(
pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
attendee = models.MeetingAttendee.objects.filter(
meeting_id=request.params.meeting_id, user_id=request.user.pk)
if attendee is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
attendee.delete()
return serializer.MeetingDetailSerializer(meeting,
request=request).data
def get_context(self, request, *args, **kwargs):
meeting = models.Meeting.objects.filter(
pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if meeting.user_id != request.user.pk:
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
meeting.name = request.params.name
meeting.description = request.params.description
meeting.save(force_update=True, update_fields=['name', 'description'])
return serializer.MeetingDetailSerializer(meeting,
request=request).data
def get_context(self, request, *args, **kwargs):
url = request.META.get('HTTP_REFERER', None)
if not url:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM,
message='cannot found referer')
corp_agent = self.get_corp_agent_info(request)
client = corp_agent.get_client()
if client is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
ret = client.get_jsapi_params(url)
ret['agentId'] = corp_agent.agentid
return ret
def get_context(self, request, *args, **kwargs):
follow = models.UserFollowRoom.objects.filter(
room_id=request.params.room_id, user_id=request.user.pk).first()
if follow is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
follow.delete()
return {}
def get_page_context(self, request, queryset, serializer_cls):
page_size = request.params.page_size
if page_size <= 0 or page_size > self.PAGE_SIZE_MAX:
raise CustomError(ErrCode.ERR_PAGE_SIZE_ERROR)
total_data = queryset.count()
total_page = (total_data + page_size - 1) // page_size
page = request.params.page
if page < 1:
page = 1
elif page > total_page:
page = total_page
start = (page - 1) * page_size
data = []
if total_data > 0:
data = serializer_cls(queryset[start:start + page_size],
request=request,
many=True).data
return {
'page_size': page_size,
'list': data,
'page': page,
'total_page': total_page,
'total_data': total_data
}
def get_context(self, request, *args, **kwargs):
meeting = models.Meeting.objects.filter(
pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
if meeting.user_id != request.user.pk and (
not meeting.room.create_user_manager
or request.user.pk != meeting.room.create_user_id):
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
with transaction.atomic():
meeting.delete()
models.MeetingTrace.objects.create(
meeting_id=meeting.pk,
user_id=request.user.pk,
owner=request.user.pk == meeting.user_id,
type=constants.MEETING_TRACE_TYPE_CODE.DELETE.code)
return {}
def get_context(self, request, *args, **kwargs):
session = biz.wechat.wxa.code_to_session(request.params.js_code)
wxa_user, new = models.User.objects.get_or_create(openid=session['openid'])
wxa_user.set_info(session)
login_user = authenticate(request, openid=wxa_user.openid)
if login_user is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
login(request, login_user)
return serializer.UserSerializer(wxa_user, request=request).data
def get_context(self, request, *args, **kwargs):
if request.params.encrypted_data or request.params.iv:
try:
data = biz.decrypt_message(request.user.session_key, request.params.iv, request.params.encrypted_data)
except Exception:
utility.reportExceptionByMail("decrypt_message")
raise CustomError(ErrCode.ERR_SYS_ERROR)
request.user.set_info(data)
return serializer.UserSerializer(request.user, request=request).data
def verify(self, code):
if not code:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
pass_flag = self.mobile in config.VERIFY_CODE_WHITE_LIST_MOBILES.split(
',')
if settings.DEBUG:
pass_flag = True
if pass_flag and code == config.VERIFY_CODE_WHITE_LIST_CODE:
self.delete()
return True
if self.send_expiration_time <= 0:
raise CustomError(ErrCode.ERR_VCODE_EXPIRE)
if self.get_verify_times() > config.VERIFY_CODE_MAX_TIMES:
raise CustomError(ErrCode.ERR_USER_VCODE_MAX_TIMES)
if not self._verify(code):
raise CustomError(ErrCode.ERR_USER_VCODE_INVALID)
self.delete()
return True
def get_context(self, request, *args, **kwargs):
meeting = models.Meeting.objects.filter(
pk=request.params.meeting_id).first()
if meeting is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
attendee, _ = models.MeetingAttendee.default_manager.get_or_create(
meeting_id=request.params.meeting_id, user_id=request.user.pk)
attendee.un_delete()
self.get_room_follow(meeting.room_id, request.user.pk)
return serializer.MeetingDetailSerializer(meeting,
request=request).data
def get_context(self, request, *args, **kwargs):
if len(request.params.room_ids) > 10:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
d = datetime.date.today()
if request.params.date is not None:
d = request.params.date
rooms = list(sorted(models.Room.objects.filter(
id__in=request.params.room_ids), key=lambda x: request.params.room_ids.index(x.id)
))
meetings = models.Meeting.objects.filter(room_id__in=request.params.room_ids, date=d).order_by('start_time')
ret = self.get_date_time_settings()
ret.update({
'rooms': serializer.RoomSerializer(rooms, request=request, many=True).data,
'meetings': serializer.MeetingSerializer(meetings, request=request, many=True).data
})
return ret
def get_context(self, request, *args, **kwargs):
if len(request.params.room_id) > 50:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
for room_id in request.params.room_id:
self.get_room_follow(room_id, request.user.pk).un_delete()
return {}
def get_context(self, request, *args, **kwargs):
room = models.Room.objects.filter(pk=request.params.room_id).first()
if room is None:
raise CustomError(ErrCode.ERR_COMMON_BAD_PARAM)
return serializer.RoomDetailSerializer(room, request=request).data
def check_api_permissions(self, request, *args, **kwargs):
if not isinstance(request.user, models.CorpUser):
raise CustomError(ErrCode.ERR_AUTH_NOLOGIN)
def check_api_permissions(self, request, *args, **kwargs):
super(UserBaseView,
self).check_api_permissions(request, *args, **kwargs)
if not isinstance(request.user, models.User):
raise CustomError(ErrCode.ERR_WECHAT_LOGIN)
def get_channel_client(self):
if self.status != constants.CORP_STSTUS_CODE.ACTIVE.code or not self.ch_permanent_code:
raise CustomError(ErrCode.ERR_COMMON_PERMISSION)
return self.suite.get_suite_client().get_channel_client(self.corpid)
