def moment_reply(user, moment_id, ref_id, content):
"""
圈子动态评论
"""
moment = MomentBase.objects.filter(pk=moment_id, is_del=FALSE_INT).first()
if not moment:
raise BusinessException(MOMENT_NOT_EXIST)
premomentreply = None
if ref_id:
premomentreply = MomentReply.objects.filter(pk=int(ref_id)).first()
if not premomentreply:
raise BusinessException(MOMENT_WRONG_REPLYID)
# 不允许回复自己的评论
if premomentreply.account.id == user.id and premomentreply.user_type == user.type and premomentreply.user_school.id == user.school.id:
raise BusinessException(MOMENT_CANNOT_REPLYSELF)
momentreply = MomentReply.objects.create(moment=moment, account=user, user_type=user.type,
user_school=user.school, ref=premomentreply, content=content, is_del=FALSE_INT)
MomentBase.objects.filter(pk=moment_id, is_del=FALSE_INT).update(reply_count=F('reply_count') + 1)
# 发消息（该功能暂时关闭）
# send_reply_msg(user, content, momentreply, premomentreply)
return get_onereply(momentreply)
def check_get_voice(voice_id):
if not voice_id:
raise BusinessException(VOICE_NOT_EXIST)
voice_obj = SysVoice.objects.filter(id=int(voice_id)).first()
if not voice_obj:
raise BusinessException(VOICE_NOT_EXIST)
return voice_obj
def check_get_file(file_id):
if not file_id:
raise BusinessException(FILE_NOT_EXIST)
file_obj = SysFile.objects.filter(id=int(file_id)).first()
if not file_obj:
raise BusinessException(FILE_NOT_EXIST)
return file_obj
def check_get_class(class_id):
if not class_id:
raise BusinessException(CLASS_NOT_EXIST)
clazz = Class.objects.filter(id=int(class_id), del_flag=FALSE_INT).first()
if not clazz:
raise BusinessException(CLASS_NOT_EXIST)
return clazz
def check_get_group(group_id):
if not group_id:
raise BusinessException(GROUP_NOT_EXIST)
group = Group.objects.filter(id=int(group_id), is_del=FALSE_INT).first()
if not group:
raise BusinessException(GROUP_NOT_EXIST)
return group
def moment_delete(user, moment_id):
"""
删除动态
"""
moment = MomentBase.objects.filter(pk=moment_id, is_del=FALSE_INT).first()
if not moment:
raise BusinessException(MOMENT_NOT_EXIST)
# 仅可删除自己发的动态
if not (moment.account == user and moment.user_type == user.type and moment.user_school == user.school):
raise BusinessException(MOMENT_NO_PRIVELEGE)
# 删除动态所有的相关信息: 视频,音频,图片,投票,评价,请假等
MomentAttachVoice.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentAttachImage.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentAttachVideo.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentAttachFile.objects.filter(moment=moment).update(is_del=TRUE_INT)
momentvote = MomentVote.objects.filter(moment=moment).first()
if momentvote:
momentvoteitems = MomentVoteItem.objects.filter(vote=momentvote)
momentvoteitems.update(is_del=TRUE_INT)
MomentVoteUser.objects.filter(vote_item__in=momentvoteitems).update(is_del=TRUE_INT)
momentvote.is_del = TRUE_INT
momentvote.save()
MomentEvaluateStudent.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentEvaluate.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentDayoff.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentLike.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentRead.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentReply.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentCircleSchool.objects.filter(moment=moment).update(is_del=TRUE_INT)
MomentCircleClass.objects.filter(moment=moment).update(is_del=TRUE_INT)
moment.is_del = TRUE_INT
moment.save()
def publish_vote(user, content, vote_title, vote_deadline, branches, is_to_school, class_ids):
if not (content or vote_title):
raise BusinessException(MOMENT_PUBLISH_NOCONTENT)
# 投票主题不允许为空
if not vote_title:
raise BusinessException(MOMENT_VOTE_TITLE_NULL)
# 投票截止时间不允许为空
if not vote_deadline:
raise BusinessException(MOMENT_VOTE_DEADLINE_NULL)
# 检查传入的是时间戳还是时间，如果是时间戳则自动转换为时间
if vote_deadline.find(':') < 0:
if len(vote_deadline) == 13:
vote_deadline = datetime.fromtimestamp(float(vote_deadline) / 1000)
else:
vote_deadline = datetime.fromtimestamp(float(vote_deadline))
moment = MomentBase.objects.create(
account=user, user_type=user.type, user_school=user.school, user_name=user.full_name,
content=content, moment_type=MOMENT_TYPE_VOTE,
has_voice=FALSE_INT, has_image=FALSE_INT, has_video=FALSE_INT, has_file=FALSE_INT)
new_vote = MomentVote.objects.create(moment=moment, vote_title=vote_title, vote_deadline=vote_deadline)
try:
branch_list = json.loads(branches)
except:
raise BusinessException(MOMENT_VOTE_BRANCH_FORMAT_ERR)
for branche_each in branch_list:
MomentVoteItem.objects.create(vote=new_vote, branch = branche_each['branch'], sort = branche_each['sort'])
circle_share(moment, is_to_school, class_ids)
return get_onemoment(moment, user, MOMENT_FROM_LIST)
def check_get_school(school_id):
if not school_id:
raise BusinessException(SCHOOl_NOT_EXIST)
school = School.objects.filter(id=int(school_id),
del_flag=FALSE_INT).first()
if not school:
raise BusinessException(SCHOOl_NOT_EXIST)
return school
def check_get_teacher(teacher_id):
if not teacher_id:
raise BusinessException(TEACHER_NOT_EXIST)
teacher = Teacher.objects.filter(id=int(teacher_id),
del_flag=FALSE_INT).first()
if not teacher:
raise BusinessException(TEACHER_NOT_EXIST)
return teacher
def check_get_parent(parent_id):
if not parent_id:
raise BusinessException(PARENT_NOT_EXIST)
parent = Parent.objects.filter(id=int(parent_id),
del_flag=FALSE_INT).first()
if not parent:
raise BusinessException(PARENT_NOT_EXIST)
return parent
def check_get_student(student_id):
if not student_id:
raise BusinessException(STUDENT_NOT_EXIST)
student = Student.objects.filter(id=int(student_id),
del_flag=FALSE_INT).first()
if not student:
raise BusinessException(STUDENT_NOT_EXIST)
return student
def check_get_account(account_id):
if not account_id:
raise BusinessException(USER_NOT_EXIST)
account = Account.objects.filter(id=int(account_id),
del_flag=FALSE_INT).first()
if not account:
raise BusinessException(USER_NOT_EXIST)
return account
def update_mobile(type, latest_version, latest_pkg, version_info):
mobile = MobileDef.objects.filter(is_del=FALSE_INT, type=int(type)).first()
if not mobile:
raise BusinessException(CLIENT_NOT_EXIST)
checksum = ''
if int(type) == MOBILE_TYPE_ANDROID_PHONE:
if not latest_pkg:
raise BusinessException(NO_APK_ERROR)
relative_path = file_storage.gen_path(
os.path.join(settings.MEDIA_PATH_PUBLIC, 'packages'),
latest_pkg.name)
if MobileHistory.objects.filter(url=relative_path).exists():
raise BusinessException(APK_NAME_ERROR)
if settings.USE_S3:
checksum = s3_storage.get_operator().upload_file_obj(
latest_pkg, relative_path)
else:
checksum = file_storage.save_file(
latest_pkg, os.path.join(settings.BASE_DIR, relative_path))
returned_url = urljoin(get_current_sys_domain(),
mobile.latest_version_url)
elif int(type) == MOBILE_TYPE_APPLE_PHONE:
if latest_pkg:
raise BusinessException(IOS_HAS_APK_ERROR)
relative_path = settings.IOS_DOWNLOAD
returned_url = relative_path
else:
raise BusinessException(UNSUPPORT_TYPE_UPGRADE)
# 更新当前版本数据库
mobile.latest_version = latest_version
mobile.latest_version_url = relative_path
mobile.latest_version_checksum = checksum
mobile.version_info = version_info
mobile.save()
# 更新历史版本数据库
MobileHistory.objects.create(type=int(type),
version=latest_version,
version_info=version_info,
url=relative_path)
return {
'latest_version': mobile.latest_version,
'latest_version_url': returned_url
}
def get_mobile_version(mobile_type):
mobile_ver = MobileDef.objects.filter(is_del=FALSE_INT,
type=int(mobile_type)).first()
if not mobile_ver:
raise BusinessException(CLIENT_NOT_EXIST)
version_url = mobile_ver.latest_version_url
if (not version_url.startswith('http://')) and (
not version_url.startswith('https://')):
version_url = urljoin(get_current_sys_domain(),
mobile_ver.latest_version_url)
# 安卓手机下载更新包走统计接口
if int(mobile_type) == MOBILE_TYPE_ANDROID_PHONE:
apk_name = mobile_ver.latest_version_url[mobile_ver.latest_version_url.
rfind('/') + 1:]
(shortname, extension) = os.path.splitext(apk_name)
apk_name = '%s_%s%s' % (shortname, str(random.randint(
1, 10000000)), extension)
version_url = urljoin(get_current_sys_domain(),
settings.ANDROID_APK_DOWNLOAD_UPGRADE + apk_name)
checksum = mobile_ver.latest_version_checksum if mobile_ver.latest_version_checksum else ''
ret_value = {
'latest_version': str(mobile_ver.latest_version),
'latest_version_url': version_url,
'latest_version_checksum': checksum,
'support_version': str(mobile_ver.support_version),
'version_info': mobile_ver.version_info
}
return ret_value
def publish_dayoff(user, content, image_ids, voice_ids, is_visible_for_teacher, class_ids):
if not (content or image_ids or voice_ids):
raise BusinessException(MOMENT_PUBLISH_NOCONTENT)
is_contains_image = TRUE_INT if image_ids else FALSE_INT
is_contains_voice = TRUE_INT if voice_ids else FALSE_INT
base = MomentBase.objects.create(
account=user, user_type=USER_TYPE_PARENT, user_school=user.school,
user_name=user.full_name, content=content, moment_type=MOMENT_TYPE_DAYOFF,
has_image=is_contains_image, has_voice=is_contains_voice)
if voice_ids:
voice_id_list = voice_ids.split(',')
for voice_each in voice_id_list:
voice_upload = SysVoice.objects.filter(pk=int(voice_each)).first()
if voice_upload:
MomentAttachVoice.objects.create(moment=base, voice=voice_upload)
if image_ids:
image_id_list = image_ids.split(',')
for image_each in image_id_list:
image_upload = SysImage.objects.filter(pk=int(image_each)).first()
if image_upload:
MomentAttachImage.objects.create(moment=base, image=image_upload)
circle_share(base, None, class_ids)
MomentDayoff.objects.create(moment=base, is_visible_for_teacher=int(is_visible_for_teacher))
return get_onemoment(base, user, MOMENT_FROM_LIST)
def moment_publish_dayoff(request):
if getattr(request, 'limited', False):
return net_helper.response_ratelimit()
try:
content = get_parameter(request.POST.get('content'), allow_null=True, para_intro='文字内容', default='')
image_ids = get_parameter(request.POST.get('image_ids'), allow_null=True, para_intro='临时图片ID列表')
voice_ids = get_parameter(request.POST.get('voice_ids'), allow_null=True, para_intro='临时语音ID列表')
is_visible_for_teacher = get_parameter(request.POST.get('is_visible_for_teacher'),
allow_null=True, para_intro='仅教师可见', default=TRUE_STR)
class_ids = get_parameter(request.POST.get('class_ids'), allow_null=False, para_intro='发布到的班级ID列表')
except InvalidHttpParaException as ipe:
logger.exception(ipe)
return response_parameter_error(ipe)
try:
# 只有家长可以发请假互动
if not isinstance(get_type_current_user(request.user), Parent):
raise BusinessException(MOMENT_DAYOFF_ONLY_AVAI_FOR_PARENT)
data = services.publish_dayoff(
request.user, content, image_ids, voice_ids, is_visible_for_teacher, class_ids)
except BusinessException as e:
dict_resp = {"c": e.code, "m": e.msg}
return response200(dict_resp)
except InvalidHttpParaException as ipe:
logger.exception(ipe)
dict_resp = {"c": REQUEST_PARAM_ERROR[0], "m": REQUEST_PARAM_ERROR[1], "d": str(ipe)}
return response400(dict_resp)
return response200({"c": SUCCESS[0], "m": SUCCESS[1], "d": data})
def moment_publish_evaluate(request):
if getattr(request, 'limited', False):
return net_helper.response_ratelimit()
try:
content = get_parameter(request.POST.get('content'), allow_null=True, para_intro=u'文字内容', default='')
image_ids = get_parameter(request.POST.get('image_ids'), allow_null=True, para_intro=u'临时图片ID列表')
voice_ids = get_parameter(request.POST.get('voice_ids'), allow_null=True, para_intro=u'临时语音ID列表')
evaluate_type = get_parameter(request.POST.get('evaluate_type'), allow_null=True, para_intro=u'评价类型', default=str(MOMENT_EVALUATE_ZAN))
evaluate_user_triples = get_parameter(request.POST.get('evaluate_user_triples'), allow_null=False, para_intro=u'评价的用户三元组（分号分隔）')
evaluate_group_ids = get_parameter(request.POST.get('evaluate_group_ids'), allow_null=True, para_intro=u'评价的群组ID列表（逗号分隔）')
evaluate_class_ids = get_parameter(request.POST.get('evaluate_class_ids'), allow_null=True, para_intro=u'评价的班级ID列表（逗号分隔）')
is_visible_for_parent_related = get_parameter(request.POST.get('is_visible_for_parent_related'),
allow_null=True, para_intro=u'仅相关家长可见', default=TRUE_STR)
class_ids = get_parameter(request.POST.get('class_ids'), allow_null=True, default='', para_intro=u'发布到的班级ID列表')
except InvalidHttpParaException as ipe:
logger.exception(ipe)
return response_parameter_error(ipe)
try:
# 只有教师能发布评价互动
if not isinstance(get_type_current_user(request.user), Teacher):
raise BusinessException(MOMENT_EVALUATE_ONLY_AVAI_FOR_TEACHER)
data = services.publish_evaluate(
request.user, content, image_ids, voice_ids, evaluate_type, evaluate_user_triples,
evaluate_group_ids, evaluate_class_ids, is_visible_for_parent_related, class_ids)
except BusinessException as e:
dict_resp = {"c": e.code, "m": e.msg}
return response200(dict_resp)
except InvalidHttpParaException as ipe:
logger.exception(ipe)
dict_resp = {"c": REQUEST_PARAM_ERROR[0], "m": REQUEST_PARAM_ERROR[1], "d": str(ipe)}
return response400(dict_resp)
return response200({"c": SUCCESS[0], "m": SUCCESS[1], "d": data})
def moment_publish_basic(request):
# 发送3个基本类型: 图片、视频、附件互动
if getattr(request, 'limited', False):
return net_helper.response_ratelimit()
try:
content = get_parameter(request.POST.get('content'), allow_null=True, para_intro=u'文字内容', default='')
moment_type = get_parameter(request.POST.get('moment_type'), allow_null=False, para_intro=u'互动类型')
image_ids = get_parameter(request.POST.get('image_ids'), allow_null=True, para_intro=u'图片ID列表')
file_ids = get_parameter(request.POST.get('file_ids'), allow_null=True, para_intro=u'文件ID列表')
voice_ids = get_parameter(request.POST.get('voice_ids'), allow_null=True, para_intro=u'语音ID列表')
video_ids = get_parameter(request.POST.get('video_ids'), allow_null=True, para_intro=u'视频ID列表')
is_to_school = get_parameter(request.POST.get('is_publish_to_school'), allow_null=True, para_intro=u'是否发学校圈')
class_ids = get_parameter(request.POST.get('class_ids'), allow_null=True, para_intro=u'发班级ID列表')
except InvalidHttpParaException as ipe:
logger.exception(ipe)
return response_parameter_error(ipe)
try:
moment_type = int(moment_type)
if moment_type != MOMENT_TYPE_IMAGE and moment_type != MOMENT_TYPE_VIDEO and moment_type != MOMENT_TYPE_FILE:
raise BusinessException(REQUEST_PARAM_ERROR)
data = services.publish_basic(
request.user, content, moment_type, image_ids, file_ids, voice_ids, video_ids, is_to_school, class_ids)
except BusinessException as e:
dict_resp = {"c": e.code, "m": e.msg}
return response200(dict_resp)
except InvalidHttpParaException as ipe:
logger.exception(ipe)
dict_resp = {"c": REQUEST_PARAM_ERROR[0], "m": REQUEST_PARAM_ERROR[1], "d": str(ipe)}
return response400(dict_resp)
return response200({"c": SUCCESS[0], "m": SUCCESS[1], "d": data})
def compose_hour_minute(hour, minutes):
try:
if int(hour) > 24 or int(hour) < 0 or int(minutes) > 60 or int(
minutes) < 0:
raise Exception()
except Exception as e:
raise BusinessException(TIME_ERROR_FORMAT)
return '%02d:%02d' % (int(hour), int(minutes))
def password_retrieve(mobile, smscode):
smscheck_verify(mobile, smscode)
mod = imp.load_source('utils.utils_crypto', 'utils/utils_crypto.py')
passwd_encryped = get_password(mobile)
if not passwd_encryped:
raise BusinessException(PASSWORD_NOT_EXIST)
return mod.encode_AES(
mod.xor_crypt_string(data=passwd_encryped, decode=True))
def smscheck_verify(mobile, smscode):
'''
校验短信验证码
'''
import time
code_saved = SmsCode.objects.filter(
is_del=FALSE_INT, mobile=mobile).exclude(code=None).first()
if not code_saved:
raise BusinessException(SMSCODE_NOT_EXIST)
if code_saved.timestamp:
timestamp_saved = int(code_saved.timestamp)
current_time = int(time.time())
if timestamp_saved + settings.SMSCODE_EXPIRE_TIME < current_time:
raise BusinessException(SMSCODE_EXPIRED)
if code_saved.code != smscode:
raise BusinessException(SMSCODE_NOT_MATCH)
def password_forget(mobile, smscode, new_passwd):
smscheck_verify(mobile, smscode)
account = Account.objects.filter(del_flag=FALSE_INT, mobile=mobile).first()
if not account:
raise BusinessException(USER_NOT_EXIST)
payload = {'account_id': str(account.id), 'new_password': str(new_passwd)}
destiny = get_usercenter_address()
logger.info('send reset password request to usercenter: %s' % destiny)
return remote_request(destiny, '/open/reset/password', payload)
def moment_vote(user, vote_item_id):
"""
圈子动态投票，一次只能投一票，暂不支持多选。
"""
momentvoteitem = MomentVoteItem.objects.filter(pk=vote_item_id).first()
if not momentvoteitem:
raise BusinessException(MOMENT_WRONG_VOTEID)
# 检查是否到期
momentvote = momentvoteitem.vote
if datetime.now() > momentvote.vote_deadline:
raise BusinessException(MOMENT_VOTE_DEAD)
momentvoteuser, created = MomentVoteUser.objects.get_or_create(
account=user, user_type=user.type, user_school=user.school, vote_item=momentvoteitem, is_del=FALSE_INT)
if created:
MomentVoteItem.objects.filter(pk=vote_item_id).update(count=F('count') + 1)
MomentVote.objects.filter(pk=momentvote.id).update(vote_statistics=F('vote_statistics') + 1)
else:
raise BusinessException(MOMENT_VOTE_REPEAT)
def get_classes_by_account(user, verbose=True):
"""
获取我所在的所有班级:
老师：获取所有任课班级
学生：获取就读的班级（唯一一个）
家长：获取各个孩子所在的班级（可能多个）
"""
role = tools.get_type_current_user(user)
if not role:
raise BusinessException(USER_NOT_EXIST)
return get_classes_by_role(role, verbose=verbose)
def fetch(user, media_id, token=None):
# 从微信服务器下载
access_token = token or get_access_token(user.school.id)
payload = {
'access_token': access_token,
'media_id': str(media_id),
}
response = requests.get('http://api.weixin.qq.com/cgi-bin/media/get',
stream=True,
params=payload)
logger.info(
'fetch media %s from weixin, response_code: %s, response_head: %s' %
(media_id, response.status_code, response.headers))
if response.status_code != 200:
raise BusinessException(WX_FETCH_VOICE_FAIL)
elif 'errcode' in response.content:
logger.error('fetch media %s fail, reason: %s' %
(media_id, response.content))
raise BusinessException(WX_FETCH_VOICE_FAIL)
else:
return response
def moment_read(user, moment_id):
"""
圈子动态阅读
"""
moment = MomentBase.objects.filter(pk=moment_id, is_del=FALSE_INT).first()
if not moment:
raise BusinessException(MOMENT_NOT_EXIST)
momentread, created = MomentRead.objects.get_or_create(
moment=moment, account=user, user_type=user.type, user_school=user.school,
defaults={'is_del': FALSE_INT})
if created:
MomentBase.objects.filter(pk=moment_id, is_del=FALSE_INT).update(read_count=F('read_count') + 1)
def delete_teach_relation(teacher, classes):
class_id_list = [each.id for each in classes if teacher.cls != each]
param_dict = {
'class_id_list': json.dumps(class_id_list, ensure_ascii=False),
}
logger.info('delete teacher_class relation to user_center ...')
logger.info(param_dict)
remote_rslt = call_api_with_para(teacher.account.id,
'api_delete_teacher_class', param_dict)
logger.info(remote_rslt)
result_code = json.loads(remote_rslt)['c']
if result_code != 0:
raise BusinessException(DEL_TEACHCLASS_UC_FAIL)
def get_access_token(school_id):
from applications.common.services import domain_uc
#从用户中心获取微信access_token，用户中心保证token不过期
uc_url = os.path.join(get_uc_internal_domain_list()[0], 'get/access_token')
logger.info('visit user_center %s to get access_token' % uc_url)
response = requests.get(uc_url,
stream=True,
params={'sid': str(school_id)})
response_dict = json.loads(response.text, cls=RoundTripDecoder)
if response.status_code != 200 or 'c' not in response_dict or response_dict[
'c'] != 0:
raise BusinessException(WX_GET_ACCESS_TOKEN_FAIL)
return response_dict['d']
def publish_evaluate(user, content, image_ids, voice_ids, evaluate_type,
user_triples, group_ids, clazz_ids, is_visible_for_parent_related, class_ids):
if not (content or image_ids or voice_ids):
raise BusinessException(MOMENT_PUBLISH_NOCONTENT)
is_contains_image = TRUE_INT if image_ids else FALSE_INT
is_contains_voice = TRUE_INT if voice_ids else FALSE_INT
base = MomentBase.objects.create(
account=user, user_type=USER_TYPE_TEACHER, user_school=user.school,
content=content, user_name=user.full_name, moment_type=MOMENT_TYPE_EVALUATE,
has_image=is_contains_image, has_voice=is_contains_voice)
if voice_ids:
voice_id_list = voice_ids.split(',')
for voice_each in voice_id_list:
voice_upload = SysVoice.objects.filter(pk=int(voice_each)).first()
if voice_upload:
MomentAttachVoice.objects.create(moment=base, voice=voice_upload)
if image_ids:
image_id_list = image_ids.split(',')
for image_each in image_id_list:
image_upload = SysImage.objects.filter(pk=int(image_each)).first()
if image_upload:
MomentAttachImage.objects.create(moment=base, image=image_upload)
circle_share(base, None, class_ids)
evaluate = MomentEvaluate.objects.create(
moment=base, type=int(evaluate_type), is_visible_for_parent_related=int(is_visible_for_parent_related))
evaluate_stus = collect_stu(user_triples, group_ids, clazz_ids)
if len(evaluate_stus) <= 0:
raise BusinessException(MOMENT_EVALUATE_NON_AIM)
for each_stu in evaluate_stus:
MomentEvaluateStudent.objects.create(moment=base, moment_evaluate=evaluate, student=each_stu)
return get_onemoment(base, user, MOMENT_FROM_LIST)
def get_moment_list(request):
"""
功能说明: 获取圈子动态列表
"""
try:
circle_type = get_parameter(request.GET.get('circle_type'), allow_null=False, default='0', para_intro=u'圈子类型')
moment_types = get_parameter(request.GET.get('moment_type'), allow_null=True, default='', para_intro=u'动态类型')
# new added
keyword = get_parameter(request.GET.get('keyword'), allow_null=True, default='', para_intro=u'搜索关键字')
time_scope = get_parameter(request.GET.get('time_scope'), allow_null=True, default='0', para_intro=u'时间范围')
account_id = get_parameter(request.GET.get('account_id'), allow_null=True, default='', para_intro=u'用户ID')
user_type = get_parameter(request.GET.get('user_type'), allow_null=True, default='', para_intro=u'用户类型')
school_id = get_parameter(request.GET.get('school_id'), allow_null=True, default='', para_intro=u'学校ID')
class_id = get_parameter(request.GET.get('class_id'), allow_null=True, default='', para_intro=u'班级ID')
last_moment_id = get_parameter(request.GET.get('last_id'), allow_null=True, para_intro=u'最后一个动态ID')
page = get_parameter(request.GET.get('page'), allow_null=True, default='1', para_intro=u'页码')
size = get_parameter(request.GET.get('size'), allow_null=True, default='', para_intro=u'每页数量')
rows = get_parameter(request.GET.get('rows'), allow_null=True, default='', para_intro=u'每页数量') # 同size，保持旧版本兼容
size = size or rows
except InvalidHttpParaException as ipe:
logger.exception(ipe)
return response_parameter_error(ipe)
# if last_moment_id and page:
# dict_resp = {"c": REQUEST_PARAM_ERROR[0], "m": REQUEST_PARAM_ERROR[1], "d": u"最后一个动态ID与页码不允许同时存在"}
# return response400(dict_resp)
if circle_type == MOMENT_CLASS and not class_id:
dict_resp = {"c": REQUEST_PARAM_ERROR[0], "m": REQUEST_PARAM_ERROR[1], "d": u"查询班级圈时，班级ID必传"}
return response400(dict_resp)
function_map = {
MOMENT_NEW: {'function': qs_new, 'parameter': (request.user, )},
MOMENT_SCHOOL: {'function': qs_school, 'parameter': (request.user, )},
MOMENT_CLASS: {'function': qs_class, 'parameter': (request.user, class_id, )},
MOMENT_MY: {'function': qs_person, 'parameter': (request.user, account_id, user_type, school_id, )},
}
try:
if circle_type not in function_map:
raise BusinessException(REQUEST_PARAM_ERROR)
function = function_map[circle_type]['function']
parameter = function_map[circle_type]['parameter']
qs = function(*parameter)
data = get_moments(qs, request.user, last_moment_id, page, size, moment_types, keyword, time_scope)
except BusinessException as e:
dict_resp = {"c": e.code, "m": e.msg}
return response200(dict_resp)
return response200({"c": SUCCESS[0], "m": SUCCESS[1], "d": data})