def bank_detail(request, bank_id):
try:
bank = BankInfo.objects.get(bank_id=bank_id)
except BankInfo.DoesNotExist:
return json_response(*SetError.BankInfoNotFound)
return json_response(200, 'OK', {'bank_info': bank.data})
def reset_password(request):
email = request.POST.get('email', '')
new_password = request.POST.get('new_password', '')
new_password_again = request.POST.get('new_password_again', '')
is_biz = request.POST.get('is_biz', 0)
if new_password != new_password_again:
return json_response(*UserError.PasswordError)
try:
User.objects.get(email=email)
except User.DoesNotExist:
return json_response(*UserError.UserNotFound)
if not get_has_sentemail(email):
sign = str(uuid.uuid1())
set_passwd(sign, new_password)
set_has_sentemail(email)
title = '[Quizz.cn密码重置邮件]'
sender = settings.EMAIL_HOST_USER
url = settings.DOMAIN + '/auth/reset_notify?email=' + email + '&sign=' + sign + '&is_biz=' + str(
is_biz)
msg = '您好，Quizz.cn管理员想邀请您确认是否重置密码？{}'.format(url)
ret = send_mail(title, msg, sender, [email], fail_silently=True)
if not ret:
return json_response(*UserError.UserSendEmailFailed)
return json_response(200, 'OK', {})
else:
return json_response(*UserError.UserHasSentEmail)
def register(request):
"""
用户注册模块
"""
body = json.loads(request.body) # 获取请求内容
account = body.get('account', '') # 获取用户名
password = body.get('password', '') # 获取密码
city = body.get('city', '') # 获取城市
introduction = body.get('introduction', '') # 获取用户简介
cert_type = body.get('cert_type', 0) # 证件类型
cert_number = body.get('cert_number', '') # 证件号
phone = body.get('telephone', 0) # 电话号码
name = body.get('nick_name', '') # 姓名
try:
p = Profile.objects.get(account=account)
except Profile.DoesNotExist: # 用户信息不存在
with transaction.atomic():
Profile.objects.create( # 创建新用户信息并写入数据库
account=account,
password=password,
city=city,
introduction=introduction,
cert_type=cert_type,
cert_number=cert_number,
phone=phone,
user_name=name,
user_type=1,
user_level=0,
)
return json_response(200, 'OK', { # 返回用户uid
'uid': Profile.objects.values().get(account=account).get('uid')
})
else:
return json_response(300003, 'User Has Existed', {'error': True})
def signup(request):
email = request.POST.get('email', '') # 邮箱
password = request.POST.get('password', '') # 密码
password_again = request.POST.get('password_again', '') # 确认密码
vcode = request.POST.get('vcode', '') # 注册验证码
sign = request.POST.get('sign') # 注册验证码检验位
if password != password_again: # 两次密码不一样，返回错误码300002
return json_response(*UserError.PasswordError)
result = get_vcode(sign) # 校验vcode，逻辑和登录视图相同
if not (result and (result.decode('utf-8') == vcode.lower())):
return json_response(*UserError.VeriCodeError)
if User.objects.filter(email__exact=email).exists(): # 检查数据库是否存在该用户
return json_response(*UserError.UserHasExists) # 返回错误码300004
username = email.split('@')[0] # 生成一个默认的用户名
if User.objects.filter(username__exact=username).exists():
username = email # 默认用户名已存在，使用邮箱作为用户名
User.objects.create_user( # 创建用户，并设置为不可登录
is_active=False,
is_staff=False,
username=username,
email=email,
password=password,
)
Profile.objects.create( # 创建用户信息
name=username, email=email)
sign = str(uuid.uuid1()) # 生成邮箱校验码
set_signcode(sign, email) # 在redis设置30min时限的验证周期
return json_response(
200,
'OK',
{ # 返回JSON数据
'email': email,
'sign': sign
})
def normal_login(request):
"""
普通视图登录
:param request: 请求对象
:return: 返回json数据：user_info：用户信息；has_login：用户是否已登录
"""
email = request.POST.get('email', '')
password = request.POST.get('password', '')
sign = request.POST.get('sign', '')
vcode = request.POST.get('vcode', '')
result = get_vcode(sign)
if not (result and (result.decode('utf-8') == vcode.lower())):
return json_response(*UserError.VeriCodeError)
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
return json_response(*UserError.UserNotFound)
user = authenticate(request, username=user.username, password=password)
if user is not None:
login(request, user)
profile, created = Profile.objects.select_for_update().get_or_create(email=user.email)
if profile.user_src != Profile.COMPANY_USER:
profile.name = user.username
profile.user_src = Profile.NORMAL_USER
profile.save()
request.session['uid'] = profile.uid
request.session['username'] = profile.name
set_profile(profile.data)
else:
return json_response(*UserError.PasswordError)
return json_response(200, 'OK', {
'user_info': profile.data,
'has_login': bool(profile)
})
def pickup(order_id):
"""
Update the status to reflect the laundryman picked the laundry from the request person.
---
tags:
- Laundry_orders
parameters:
- name: Authorization
in: header
required: true
type: string
- name: order_id
in: path
type: string
required: true
responses:
200:
description: Laundry order with the status updated.
schema:
$ref: '#/definitions/OrderInformationResponse'
"""
user = user_from_authorization_headers(request)
order = OrderInformation(id=order_id)
if order.user_accepted.user != user.id:
return json_response({'message': 'Unauthorized'}, 400)
order.order_is_pickup()
return json_response({
'message': 'pickup',
'order': OrderInformationSchema().dump(order)[0]
})
def wrapper(request, *args, **kwargs):
kind_id = request.GET.get('kind_id', '') or request.POST.get(
'kind_id', '')
try:
kind_info = CompetitionKindInfo.objects.get(kind_id=kind_id)
except CompetitionKindInfo.DoesNotExist:
if request.path.startswith('/bs'):
return render(request, 'err.html', CompetitionNotFound)
if request.path.startswith('/api'):
return json_response(*CompetitionError.CompetitionNotFound)
if kind_info.cop_finishat < datetime.datetime.now(
tz=datetime.timezone.utc):
if request.path.startswith('/bs'):
return render(request, 'err.html', CompetitionHasEnded)
if request.path.startswith('/api'):
return json_response(*CompetitionError.CompetitionHasEnded)
if kind_info.cop_startat > datetime.datetime.now(
tz=datetime.timezone.utc):
if request.path.startswith('/bs'):
return render(request, 'err.html', CompetitionNotStarted)
if request.path.startswith('/api'):
return json_response(*CompetitionError.CompetitionNotStarted)
return func(request, *args, **kwargs)
def banks(request, s):
if s == '999':
banks = BankInfo.objects.values_list(
'bank_name', 'bank_id', 'kind_num', 'choice_num',
'fillinblank_num').order_by('-kind_num')
return json_response(
200, 'OK', {
'banks': [{
'bank_name': b[0],
'bank_id': b[1],
'kind_num': b[2],
'total_question_num': b[3] + b[4]
} for b in banks]
})
bank_types = [t[0] for t in BankInfo.BANK_TYPES]
if int(s) in bank_types:
banks = BankInfo.objects.filter(bank_type=s).values_list(
'bank_name', 'bank_id', 'kind_num', 'choice_num',
'fillinblank_num')
return json_response(
200, 'OK', {
'banks': [{
'bank_name': b[0],
'bank_id': b[1],
'kind_num': b[2],
'total_question_num': b[3] + b[4]
} for b in banks]
})
return json_response(*SetError.BankTypeError)
def registry_biz(request):
email = request.POST.get('email', '')
name = request.POST.get('name', '')
username = request.POST.get('username', '')
phone = request.POST.get('phone', '')
ctype = request.POST.get('type', BusinessAccountInfo.INTERNET)
flag = int(request.POST.get('flag', 2))
uname = email.split('@')[0]
if not User.objects.filter(username__exact=name).exists():
final_name = username
elif not User.objects.filter(username__exact=uname).exists():
final_name = uname
else:
final_name = email
if flag == 2:
user = User.objects.create_user(username=final_name,
email=email,
password=settings.INIT_PASSWORD,
is_active=False,
is_staff=False)
if flag == 1:
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
return json_response(*UserError.UserNotFound)
pvalues = {
'phone': phone,
'name': final_name,
'user_src': Profile.COMPANY_USER,
}
profile, _ = Profile.objects.select_for_update().get_or_create(email=email)
for k, v in pvalues.items():
setattr(profile, k, v)
profile.save()
bizvalues = {
'company_name': name,
'company_username': username,
'company_phone': phone,
'company_type': ctype,
}
biz, _ = BusinessAccountInfo.objects.select_for_update().get_or_create(
email=email, defaults=bizvalues)
return json_response(200, 'OK', {
'name': final_name,
'email': email,
'flag': flag
})
def update_profile(request):
phone = request.POST.get('phone', '')
classname = request.POST.get('classname', '')
trainee_code = request.POST.get('trainee_code', '')
try: # 校验成功，获得返回用户信息
Profile.objects.filter(name=phone).update(classname=classname,
trainee_code=trainee_code)
return json_response(200, 'OK', {})
except User.DoesNotExist:
return json_response(*UserError.ProfileNotFound)
def delete_p4table_rule(table_id):
if request.content_type != JSON_MIME_TYPE:
error = json.dumps({'error': 'Invalid Content Type'})
return json_response(error, 400)
data = request.json
response, message = core.delete_rule(table_id, data)
if response:
return json_response(message, status=201)
else:
error = json.dumps({'error': message})
return json_response(error, 400)
def get_questions(request):
"""
获取题目信息接口
:param request: 请求对象
:return: 返回json数据: user_info: 用户信息;kind_info: 比赛信息;qa_id: 比赛答题记录;questions: 比赛随机后的题目;
"""
kind_id = request.GET.get('kind_id', '') # 获取kind_id
uid = request.GET.get('uid', '') # 获取uid
try: # 获取比赛信息
kind_info = CompetitionKindInfo.objects.select_for_update().get(
kind_id=kind_id)
except CompetitionKindInfo.DoesNotExist: # 未获取到，返回错误码100001
return json_response(*CompetitionError.CompetitionNotFound)
try: # 获取题库信息
bank_info = BankInfo.objects.get(bank_id=kind_info.bank_id)
except BankInfo.DoesNotExist: # 未获取到，返回错误码100004
return json_response(*CompetitionError.BankInfoNotFound)
try: # 获取用户信息
profile = Profile.objects.get(uid=uid)
except Profile.DoesNotExist: # 未获取到，返回错误码200001
return json_response(*ProfileError.ProfileNotFound)
qc = ChoiceInfo.objects.filter(bank_id=kind_info.bank_id) # 选择题
qf = FillInBlankInfo.objects.filter(bank_id=kind_info.bank_id) # 填空题
questions = [] # 将两种题型放到同一个列表中
for i in qc.iterator():
questions.append(i.data)
for i in qf.iterator():
questions.append(i.data)
question_num = kind_info.question_num # 出题数
q_count = bank_info.total_question_num # 总题数
if q_count < question_num: # 出题数大于总题数，返回错误码100005
return json_response(CompetitionError.QuestionNotSufficient)
qs = random.sample(questions, question_num) # 随机分配题目
qa_info = CompetitionQAInfo.objects.select_for_update(
).create( # 创建答题log数据
kind_id=kind_id,
uid=uid,
qsrecord=[q['question'] for q in qs],
asrecord=[q['answer'] for q in qs],
total_num=question_num,
started_stamp=tc.utc_timestamp(ms=True, milli=True), # 设置开始时间戳
started=True)
for i in qs: # 剔除答案信息
i.pop('answer')
return json_response(
200,
'OK',
{ # 返回JSON数据，包括题目信息，答题log信息等
'kind_info': kind_info.data,
'user_info': profile.data,
'qa_id': qa_info.qa_id,
'questions': qs
})
def registry_biz(request):
email = request.POST.get('email', '') # 获取填写的邮箱
name = request.POST.get('name', '') # 获取填写的机构名
username = request.POST.get('username', '') # 获取填写的机构联系人
phone = request.POST.get('phone', '') # 获取填写的手机号
ctype = request.POST.get('type', BusinessAccountInfo.INTERNET) # 获取机构类型
flag = int(request.POST.get('flag', 2)) # 获取一个标记位，代表用户是创建新用户还是使用绑定老用户的方式
uname = email.split('@')[0] # 和之前的注册逻辑没什么区别，创建一个账户名
if not User.objects.filter(username__exact=name).exists():
final_name = username
elif not User.objects.filter(username__exact=uname).exists():
final_name = uname
else:
final_name = email
if flag == 2: # 如果标记位是2，那么将为他创建新用户
user = User.objects.create_user(username=final_name,
email=email,
password=settings.INIT_PASSWORD,
is_active=False,
is_staff=False)
if flag == 1: # 如果标记位是1，那么为他绑定老用户
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
return json_response(*UserError.UserNotFound)
pvalues = {
'phone': phone,
'name': final_name,
'user_src': Profile.COMPANY_USER,
}
profile, _ = Profile.objects.select_for_update().get_or_create(
email=email) # 获取或创建用户信息
for k, v in pvalues.items():
setattr(profile, k, v)
profile.save()
bizvalues = {
'company_name': name,
'company_username': username,
'company_phone': phone,
'company_type': ctype,
}
biz, _ = BusinessAccountInfo.objects.select_for_update(
).get_or_create( # 获取或创建机构账户信息
email=email, defaults=bizvalues)
return json_response(
200,
'OK',
{ # 响应JSON格式数据，这个标记位在发送验证邮件的时候还有用
'name': final_name,
'email': email,
'flag': flag
})
def login():
"""
Login the user to get session key.
---
tags:
- Users
parameters:
- name: body
in: body
required: true
schema:
$ref: '#/definitions/UserCredentials'
definitions:
UserCredentials:
type: object
properties:
email:
type: string
format: email
password:
type: string
format: password
JwtToken:
type: object
properties:
token:
type: string
responses:
200:
description: JWT session key.
schema:
$ref: '#/definitions/JwtToken'
500:
description: Invalid form.
400:
description: Wrong user.
"""
user_form, errors = RegisterSchema(only=['email', 'password']).load(request.json)
if errors:
return json_response({'error': errors}, 500)
try:
user = User.objects.get(email=user_form.email)
except:
return json_response({'error': 'Wrong User'}, 400)
if user.password != user_form.password:
return json_response({'error': 'Wrong User'}, 400)
encoded = jwt.encode({'some': 'payload', 'email': user.email}, JWT_SECRET, algorithm='HS256').decode('utf-8')
return jsonify({'token': encoded})
def reset_password(request):
resetUserId = request.POST.get('resetUserId', '')
resetUsername = request.POST.get('resetUsername', '')
try:
user = User.objects.get(username=resetUsername) # 获取用户
except User.DoesNotExist:
user = None
if user is not None: # 校验成功，获得返回用户信息
user.set_password("123456")
user.save()
return json_response(200, 'OK', {})
else:
return json_response(*UserError.PasswordError)
def normal_login(request):
"""
普通登录视图
:param request: 请求对象
:return: 返回json数据: user_info: 用户信息;has_login: 用户是否已登录
"""
phone = request.POST.get('phone', '') # 获取phone
password = request.POST.get('password', '') # 获取password
sign = request.POST.get('sign', '') # 获取登录验证码的sign
vcode = request.POST.get('vcode', '') # 获取用户输入的验证码
result = get_vcode(sign) # 从redis中校验sign和vcode
if not (result and (result.decode('utf-8') == vcode.lower())):
return json_response(*UserError.VeriCodeError) # 校验失败返回错误码300003
try:
user = User.objects.get(username=phone) # 使用phone获取Django用户
except User.DoesNotExist:
return json_response(*UserError.UserNotFound) # 获取失败返回错误码300001
# print(user.username)
# print(password)
user = authenticate(request, username=user.username,
password=password) # 授权校验
if user is not None: # 校验成功，获得返回用户信息
login(request, user) # 登录用户，设置登录session
profile, created = Profile.objects.select_for_update(
).get_or_create( # 获取或创建Profile数据
name=user.username, )
if profile.user_src != Profile.COMPANY_USER:
profile.name = user.username
profile.user_src = Profile.NORMAL_USER
profile.save()
request.session.get("usertype") #让session创建usertyp这个值
request.session['uid'] = profile.uid # 设置Profile uid的session
request.session['username'] = profile.name # 设置用户名的session
request.session['displayname'] = profile.displayname # 设置用户名的session
request.session[
'usertype'] = profile.user_src # 设置用户类型session，普通用户，管理员
# print("---------------profile.user_src")
# print(profile.user_src)
# print(request.session.get("usertype"))
set_profile(profile.data) # 将用户信息保存到redis，查用户信息从redis中查询
else:
return json_response(*UserError.PasswordError) # 校验失败，返回错误码300002
recode = 200
if 33 == profile.user_src:
recode = 300
return json_response(recode, 'OK', { # 返回JSON格式数据
'user_info': profile.data,
'has_login': bool(profile),
})
def game_list_data(request):
kindData = []
kinds = CompetitionKindInfo.objects.all().order_by('-created_at')
for kind in kinds:
copStartat = kind.cop_startat.strftime("%Y/%m/%d")
copFinishat = kind.cop_finishat.strftime("%Y/%m/%d")
copFinishatValue = kind.cop_finishat.strftime("%Y-%m-%d")
isOpen = "否"
if kind.is_open:
isOpen = "是"
bank_info = BankInfo.objects.get(bank_id=kind.bank_id)
kindData.append({
'sponsor_name': kind.get_sponsor_name_display(),
'kind_name': kind.kind_name,
'kind_id': kind.kind_id,
'bank_name': bank_info.bank_name,
'kind_type': kind.get_kind_type_display(),
'total_score': kind.total_score,
'question_num': kind.question_num,
'A1_choice_num': kind.A1_choice_num,
'A2_choice_num': kind.A2_choice_num,
'A3_choice_num': kind.A3_choice_num,
'B_choice_num': kind.B_choice_num,
'cop_startat': copStartat,
'period': kind.period_time,
'cop_finishat': copFinishat,
'copFinishatValue': copFinishatValue,
'is_open': isOpen,
'is_open_value': kind.is_open,
'total_partin_num': kind.total_partin_num,
})
return json_response(200, 'OK', {
'data': kindData,
})
def get(order_id):
"""
Show a single laundry order.
---
tags:
- Laundry_orders
parameters:
- name: Authorization
in: header
required: true
type: string
- name: order_id
in: path
required: true
type: string
responses:
200:
description: Single order details.
schema:
$ref: '#/definitions/OrderInformationResponse'
404:
description: Not found.
"""
order = OrderInformation(id=order_id)
return json_response({
'message': 'Order',
'order': OrderInformationSchema().dump(order)[0]
})
def slave_create(request):
"""
接令者申请召集令
"""
body = json.loads(request.body)
tid = body.get('order_id', '')
pid = body.get('slave_id', '')
desc = body.get('request_msg', '')
try:
task = Task.objects.get(uid=tid)
req = Profile.objects.get(uid=pid)
name = req.user_name
if(task.cur_people<task.max_people):
Request.objects.create(
task=task,
requester=req,
description=desc,
requester_name=name
)
else:
return HttpResponseBadRequest({"msg":"召集人数已满"})
except Exception as e:
# return json_response(400003, 'Create Request Error', {'error': str(e)})
return HttpResponseServerError
else:
data = Request.objects.values().get(
task=tid, requester=pid)
return json_response(200, 'OK', data)
def master_query(request):
"""
查询请求信息
"""
# body = json.loads(request.body)
body = request.GET
task = body.get('order_id', '')
# req = list(Request.objects.values().filter(task__exact=task))
req = Request.objects.filter(task__exact=task)
# slave = list(i.requester for i in req)
response_body = [{
"task_name": each.task.task_name,
"task_id": each.task.uid,
"requester_id": each.requester.uid,
"requester_name": each.requester.user_name,
"request_status": each.request_status,
"uid": each.uid,
"description": each.description
} for each in req]
# slave = list
# for i in req:
# slave.append(Profile.objects.values().get(uid=i['uid']))
if req.exists() == False:
return HttpResponseBadRequest("没有该任务的申请")
else:
return json_response(200, 'OK', response_body)
def comment_create(request):
article_id = int(request.POST["article_id"])
content = request.POST["content"].strip()
to_comment_id = int(request.POST["to_comment_id"])
# print article_id, content, to_comment_id
article = Article.objects.get(id=article_id)
# print article
comment = Comment(block=article.block, article=article,
owner=request.user, content=content,
to_comment_id=to_comment_id
)
comment.save()
if to_comment_id == 0:
owner=article.owner
content=u"有人评论了您的文章 %s" % article.title
else:
owner=comment.to_comment.owner
content=u"有人评论了您的评论 %s" % comment.to_comment.content[:30]
new_message = UserMessage(owner=owner,
content=content,
link=reverse("detail_message", args=[int(article_id), int(comment.id)])
)
new_message.save()
return json_response({})
def create_comment(request):
article_id = int(request.POST["article_id"])
to_comment_id = int(request.POST["to_comment_id"])
content = request.POST["content"].strip()
article = Article.objects.get(id=article_id)
comment = Comment(block=article.block,
article=article,
owner=request.user,
to_comment_id=to_comment_id,
content=content)
comment.save()
if to_comment_id == 0:
new_msg = UserMessage(owner=article.owner,
content=u"有人评论了您的文章《%s》" % article.title,
link=reverse("article_detail",
args=[article.id]))
new_msg.save()
else:
to_comment = Comment.objects.get(id=to_comment_id)
new_msg = UserMessage(
owner=to_comment.owner,
content=u"有人回复了你的评论'%s'" % to_comment.content[:30],
link=reverse("article_detail", args=[article.id]))
new_msg.save()
return json_response({})
def comment_create(request):
article_id = int(request.POST["article_id"])
content = request.POST["content"].strip()
to_comment_id = int(request.POST["to_comment_id"])
# print article_id, content, to_comment_id
article = Article.objects.get(id=article_id)
# print article
comment = Comment(block=article.block,
article=article,
owner=request.user,
content=content,
to_comment_id=to_comment_id)
comment.save()
if to_comment_id == 0:
owner = article.owner
content = u"有人评论了您的文章 %s" % article.title
else:
owner = comment.to_comment.owner
content = u"有人评论了您的评论 %s" % comment.to_comment.content[:30]
new_message = UserMessage(owner=owner,
content=content,
link=reverse(
"detail_message",
args=[int(article_id),
int(comment.id)]))
new_message.save()
return json_response({})
def login(request):
"""
用户登录模块
"""
body = json.loads(request.body)
account = body.get('account', '')
password = body.get('password', '')
try:
p = Profile.objects.values().get(account=account)
except Profile.DoesNotExist:
return HttpResponseBadRequest("没有该用户")
else:
if p.get('password') != password:
return HttpResponseBadRequest("密码错误")
else:
return json_response(200, "OK", {
'uid': p.get('uid'),
'nick_name': p.get('user_name'),
'account': p.get('account'),
'introduction': p.get('introduction'),
'telephone': p.get('phone'),
'cert_type': p.get('cert_type'),
'cert_number': p.get('cert_number')
})
def comment_create(request):
article_id = int(request.POST["article_id"])
to_comment_id = int(request.POST["to_comment_id"])
content = request.POST["content"]
page_nums = request.POST["page_nums"]
article = Article.objects.get(id=article_id)
block = article.block
owner = request.user
comment = Comment(block=block, article=article, owner=owner, to_comment_id=to_comment_id, content=content)
comment.save()
if to_comment_id == 0:
msg = UserMessage(
owner=article.author,
content=u"有人评论了你的文章：《%s》" % article.title,
link=reverse("article_display", args=[article.id]) + "?comment_no=" + page_nums,
)
msg.save()
else:
to_comment = Comment.objects.get(id=to_comment_id)
msg = UserMessage(
owner=to_comment.owner,
content=u"有人评论了你的评论：'%s'" % to_comment.content[:20],
link=reverse("article_display", args=[article.id]) + "?comment_no=" + page_nums,
)
msg.save()
return response.json_response({})
def test(request):
some_data_to_dump = {
'some_var_1': 'foo',
'some_var_2': 'bar',
}
return json_response(some_data_to_dump)
def games(request, s):
"""
获取所有比赛接口
:param request: 请求对象
:param s: 请求关键字
:return: 返回该请求关键字对应的所有比赛类别
"""
if s == 'hot':
# 筛选条件: 完成时间大于当前时间;根据参与人数降序排序;根据创建时间降序排序;筛选10个
kinds = CompetitionKindInfo.objects.filter(
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc),
).order_by('-total_partin_num').order_by('-created_at')[:10]
elif s == 'tech':
kinds = CompetitionKindInfo.objects.filter(
sponsor_name=CompetitionKindInfo.INFECTION,
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc)
).order_by('-total_partin_num').order_by('-created_at')
elif s == 'edu':
kinds = CompetitionKindInfo.objects.filter(
sponsor_name=CompetitionKindInfo.EDUCATION,
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc)
).order_by('-total_partin_num').order_by('-created_at')
elif s == 'culture':
kinds = CompetitionKindInfo.objects.filter(
sponsor_name=CompetitionKindInfo.CULTURE,
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc)
).order_by('-total_partin_num').order_by('-created_at')
elif s == 'sport':
kinds = CompetitionKindInfo.objects.filter(
sponsor_name=CompetitionKindInfo.SPORT,
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc)
).order_by('-total_partin_num').order_by('-created_at')
elif s == 'general':
kinds = CompetitionKindInfo.objects.filter(
sponsor_name=CompetitionKindInfo.GENERAL,
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc)
).order_by('-total_partin_num').order_by('-created_at')
elif s == 'interview':
kinds = CompetitionKindInfo.objects.filter(
sponsor_name=CompetitionKindInfo.INTERVIEW,
cop_finishat__gt=datetime.datetime.now(tz=datetime.timezone.utc)
).order_by('-total_partin_num').order_by('-created_at')
else:
kinds = None
uid = request.session.get('uid', '')
return json_response(200, 'OK', {
'kinds': [i.data for i in kinds],
'uid': uid
})
def sendmail(request):
to_email = request.GET.get('email', '') # 在url中获取的注册邮箱地址
sign = request.GET.get('sign', '') # 在url中获取的sign标识
if not get_has_sentregemail(to_email): # 检查用户是否在同一时间多次点击发送邮件
title = '[Quizz.cn用户激活邮件]' # 定义邮件标题
sender = settings.EMAIL_HOST_USER # 获取发送邮件的邮箱地址
url = settings.DOMAIN + '/auth/email_notify?email=' + to_email + '&sign=' + sign # 回调函数
msg = '您好，Quizz.cn管理员想邀请您激活您的用户，点击链接激活。{}'.format(url) # 邮件内容
ret = send_mail(title, msg, sender, [to_email],
fail_silently=True) # 发送邮件并获取发送结果
if not ret:
return json_response(
*UserError.UserSendEmailFailed) # 发送出错，返回错误码300006
set_has_sentregemail(to_email) # 正常发送，设置3分钟的继续发送限制
return json_response(200, 'OK', {}) # 返回空JSON数据
else:
return json_response(
*UserError.UserHasSentEmail) # 如果用户同一时间多次点击发送，返回错误码300005
def signup(request):
phone = request.POST.get('phone', '') # 电话
displayname = request.POST.get('displayname', '') # 显示姓名
password = request.POST.get('password', '') # 密码
password_again = request.POST.get('password_again', '') # 确认密码
vcode = request.POST.get('vcode', '') # 注册验证码
classname = request.POST.get('classname', '') # 班级名称
trainee_type = request.POST.get('trainee_type', '') # 班级名称
trainee_code = request.POST.get('trainee_code', '') # 班级名称
sign = request.POST.get('sign') # 注册验证码检验位
if password != password_again: # 两次密码不一样，返回错误码300002
return json_response(*UserError.PasswordError)
result = get_vcode(sign) # 校验vcode，逻辑和登录视图相同
if not (result and (result.decode('utf-8') == vcode.lower())):
return json_response(*UserError.VeriCodeError)
if User.objects.filter(username=phone).exists(): # 检查数据库是否存在该用户
return json_response(*UserError.UserHasExists) # 返回错误码300004
username = phone # 生成一个默认的用户名
if User.objects.filter(username__exact=username).exists():
username = phone # 默认用户名已存在，使用邮箱作为用户名
User.objects.create_user( # 创建用户，并设置为不可登录
is_active=False,
is_staff=False,
username=username,
password=password,
)
Profile.objects.create( # 创建用户信息
name=username,
phone=phone,
displayname=displayname,
classname=classname,
trainee_type=trainee_type,
trainee_code=trainee_code,
)
sign = str(uuid.uuid1()) # 生成邮箱校验码
set_signcode(sign, phone) # 在redis设置30min时限的验证周期
return json_response(
200,
'OK',
{ # 返回JSON数据
'phone': phone,
'sign': sign
})
def sendmail(request):
to_email = request.GET.get('email', '')
sign = request.GET.get('sign', '')
if not get_has_sentregemail(to_email):
title = '[Quizz.cn用户激活邮件]'
sender = settings.EMAIL_HOST_USER
url = settings.DOMAIN + '/auth/email_notify?email=' + to_email + '&sign=' + sign
msg = '您好，Quizz.cn管理员想邀请您激活您的用户，点击链接激活。{}'.format(url)
ret = send_mail(title, msg, sender, [to_email], fail_silently=True)
if not ret:
return json_response(*UserError.UserSendEmailFailed)
set_has_sentregemail(to_email)
return json_response(200, 'OK', {})
else:
return json_response(*UserError.UserHasSentEmail)
def check_biz(request):
email = request.GET.get('email', '') # 获取邮箱
try: # 检查数据库中是否由该邮箱注册过的数据
biz = BusinessAccountInfo.objects.get(email=email)
except BusinessAccountInfo.DoesNotExist:
biz = None
return json_response(200, 'OK', { # 返回是否已经被注册过和是否已经有此用户
'userexists': User.objects.filter(email=email).exists(),
'bizaccountexists': bool(biz)
})
def wrapper(request, *args, **kwargs):
uid = request.session.get('uid', '')
if not uid:
if request.path.startswith('/bs'):
return render(request, 'err.html', ProfileNotFound)
elif request.path.startswith('/api'):
return json_response(*ProfileError.ProfileNotFound)
return func(request, *args, **kwargs)
def get_my_rank(request):
uid = request.GET.get('uid', '')
kind_id = request.GET.get('kind_id', '')
try:
profile = Profile.objects.get(uid=uid)
except Profile.DoesNotExist:
return json_response(*UserError.UserNotFound)
try:
kind_info = CompetitionKindInfo.objects.get(kind_id=kind_id)
except CompetitionKindInfo.DoesNotExist:
return json_response(*CompetitionError.CompetitionNotFound)
return json_response(200, 'OK', {
'time': get_user_rank(kind_id, uid).get('time', 0),
'score': get_user_rank(kind_id, uid).get('score', 0),
'rank': get_rank(kind_id, uid)
})
def create_comment(request):
article_id = int(request.POST["article_id"])
to_comment_id = int(request.POST["to_comment_id"])
content = request.POST["content"].strip()
article = Article.objects.get(id=article_id)
comment = Comment(block=article.block, article=article, owner=request.user, to_comment_id=to_comment_id, content=content)
comment.save()
if to_comment_id == 0:
new_msg = UserMessage(owner=article.owner, content = u"有人评论您的文章 (%s)" % article.title, link = reverse("article_detail", args = [article.id]))
new_msg.save()
else:
to_comment = Comment.objects.get(id=to_comment_id)
new_msg=UserMessage(owner = to_comment.owner,content=u"有人回复了您的评论 '%s' "%to_comment.content[:30], link=reverse("article_detail", args=[article.id]))
new_msg.save()
return json_response({})
def comment_create(request):
article_id = int(request.POST['article_id'])
to_comment_id = int(request.POST['to_comment_id'])
content = request.POST['content'].strip()
article = Article.objects.get(id=article_id)
comment = Comment(block=article.block, article=article, owner=request.user, to_comment_id=to_comment_id,
content=content)
comment.save()
if to_comment_id == 0:
new_msg = UserMessage(owner=article.owner,
content=u'有人评论了您的文章《%s》' % article.title,
link=reverse("article_detail", args=[article.id]))
new_msg.save()
else:
to_comment = Comment.objects.get(id=to_comment_id)
new_msg = UserMessage(owner=to_comment.owner,
content=u'有人评论了您的评论"%s"' % to_comment.content[:30],
link=reverse("article_detail", args=[article.id]))
new_msg.save()
return json_response({})
def create_comment(request):
article_id = int(request.POST['article_id'])
current_href = request.POST['current_href'].strip()
to_comment_id = int(request.POST['to_comment_id'])
content = request.POST['content'].strip()
article = Article.objects.get(id=article_id)
comment = Comment(block=article.block,article=article,owner=request.user,to_comment_id=to_comment_id,content=content)
comment.save()
if to_comment_id == 0:
new_msg = UserMessage(owner=article.owner,
content=u'有人评论了您的文章(%s)' % article.title,
link=reverse('ariticle_detail',args=[article.id]))
new_msg.save()
else:
to_comment = Comment.objects.get(id=to_comment_id)
new_msg = UserMessage(owner=to_comment.owner,
content=u'有人评论了您的评论(%s)' % to_comment.content[:30],
# link=reverse('ariticle_detail',args=[article.id]))
# link=reverse('ariticle_detail',
# kwargs={'article.id':article.id,'comment_page_no':ariticle_detail(article_id).pagination_data.page_no}))
# link=reverse('ariticle_detail',args=[article.id])+'?comment_page_no='+ current_href
link=current_href)
new_msg.save()
return json_response({})
def _error(self, message):
data = {
'error': True,
'message': message
}
return json_response(data)
def _success(self):
data = {
'error': False,
'success': True
}
return json_response(data)
