async def init_users():
"""
初始化用户信息
:return:
"""
user = await User.find_one(dict(login_name='admin'))
if user:
await user.delete()
user = User()
user.code = common_utils.get_increase_code(KEY_INCREASE_USER)
user.name = '超级管理员'
user.email = '*****@*****.**' # 邮箱
user.mobile = '15106139173' # 手机
user.superuser = True # 是否为超管
user.login_name = 'ycf' # 用户名
user.login_password = md5('123456') # 密码
user.status = STATUS_USER_ACTIVE # 状态
user.content = '超级管理员，无所不能' # 备注
user.permission_code_list = ALL_PERMISSION_TYPE_LIST
oid = await user.save()
if oid:
print('Initialize user [', user.name, '] succeed!')
async def post(self):
r_dict = {'code': 0}
try:
args_dict = json.loads(self.request.body)
uuid = args_dict.get('uuid', None)
member_cid = args_dict.get('member_cid', None)
if member_cid:
member = await find_app_member_by_cid(member_cid)
if not member:
r_dict['code'] = 1001 # app传递用户cid不对
else:
r_dict['member_cid'] = member_cid
if member.is_register and member.is_login:
r_dict['is_login'] = 1
else:
r_dict['is_login'] = 0
r_dict['m_type'] = member.m_type if member.m_type else ''
r_dict['code'] = 1000
else:
# app端没有登陆信息
if uuid:
count = await AppMember.count(dict(uuid=uuid))
if count > 0:
member = await AppMember.find_one(
dict(uuid=uuid, is_register=0))
if member:
r_dict['member_cid'] = member.cid
r_dict['is_login'] = 0
r_dict['code'] = 1000
else:
r_dict['code'] = 1003 # 有注册用户，但是没有虚拟用户
else:
member = AppMember(
id=ObjectId(),
code=get_increase_code(KEY_INCREASE_MEMBER_CODE),
uuid=uuid,
)
await member.save()
r_dict['member_cid'] = member.cid
r_dict['is_login'] = 0
r_dict['code'] = 1000
else:
r_dict['code'] = 1002 # uuid或者device_id为空
except Exception:
logger.error(traceback.format_exc())
return r_dict
async def post(self):
res = dict(code=0)
user_name = self.get_argument('user_name')
name = self.get_argument('name')
mobile = self.get_argument('mobile')
email = self.get_argument('email')
password = self.get_argument('password')
repassword = self.get_argument('repassword')
content = self.get_argument('content')
status = int(self.get_argument('status', STATUS_USER_ACTIVE))
city = self.get_argument("city", '')
province = self.get_argument("province", "")
if user_name and name and mobile and email and password and repassword:
if password == repassword:
# 校验用户名
exist_count = await User.count(dict(login_name=user_name))
if exist_count:
res['code'] = -2
else:
user = User(name=name,
login_name=user_name.lower(),
login_password=md5(password),
status=status)
user.code = get_increase_code(KEY_INCREASE_USER)
user.mobile = mobile
user.email = email
user.content = content
user.created_id = self.current_user.oid
user.updated_id = self.current_user.oid
if city:
user.city = city
if province:
user.province = province
user_id = await user.save()
res['code'] = 1
res['manager_id'] = user_id
else:
res['code'] = -1
else:
res['code'] = -3
return res
async def post(self):
r_dict = {'code': 0}
member_cid = self.get_i_argument('member_cid', None)
mobile = self.get_i_argument('mobile', None)
v_code = self.get_i_argument('v_code', '')
if not member_cid:
r_dict['code'] = 1001
return r_dict
member = await find_app_member_by_cid(member_cid)
if not member:
r_dict['code'] = 1002
if not mobile:
r_dict['code'] = 1003
return r_dict
try:
if not msg_utils.check_digit_verify_code(mobile, v_code):
r_dict['code'] = 1004
return r_dict
phone_member = await AppMember.find_one({'mobile': mobile})
if not phone_member:
new_member = AppMember(
id=ObjectId(),
code=get_increase_code(KEY_INCREASE_MEMBER_CODE),
uuid=member.uuid,
mobile=mobile,
)
new_member.is_register = 1
new_member.is_login = 1
await new_member.save()
r_dict[
'm_type'] = new_member.m_type if new_member.m_type else ''
r_dict['member_cid'] = new_member.cid
else:
r_dict['member_cid'] = phone_member.cid
r_dict[
'm_type'] = phone_member.m_type if phone_member.m_type else ''
r_dict['code'] = 1000
except Exception:
logger.error(traceback.format_exc())
return r_dict
async def upload_scrawl(self):
"""
上传涂鸦
:return: 新文件名，原始文件名
"""
scrawl_name = ''
base64_img_data = self.get_argument(
self.ue_config.get('scrawlFieldName'))
if base64_img_data:
img_data = base64decode(base64_img_data)
if img_data:
try:
scrawl_name = '%s.png' % md5(
datetime2str(datetime.datetime.now(),
'%Y%m%d%H%M%S%f'))
img_path = os.path.join(settings.STATIC_PATH, 'files',
scrawl_name)
with open(img_path, 'wb') as img:
img.write(img_data)
except Exception:
logger.error(traceback.format_exc())
finally:
if img:
img.close()
if scrawl_name:
file_code = get_increase_code(KEY_INCREASE_UPLOAD_FILE)
uf = UploadFiles(code=file_code,
title=scrawl_name,
source_title=scrawl_name,
category=CATEGORY_CERTIFICATE_UE,
content_type='image/png')
uf.size = os.path.getsize(
os.path.join(settings.STATIC_PATH, 'files',
scrawl_name))
await uf.save()
return scrawl_name
async def save_upload_file(request_handler, field_name, category=CATEGORY_UPLOAD_FILE_OTHER, file_cid=None):
"""
保存上传的文件
:param request_handler: 请求句柄
:param field_name: 请求表单中文件域名称
:param category: 文件类别
:param file_code: 文件编码， 不为空时则更新文件
:return:
"""
if not isinstance(request_handler, RequestHandler):
raise ValueError('Parameter request_handler must be a instance of RequestHandler.')
if not isinstance(field_name, (bytes, str, list)):
raise ValueError('Parameter request_field_name must be a type of str or unicode or list.')
field_list = []
if isinstance(field_name, (bytes, str)):
field_list.append(field_name)
else:
field_list.extend(field_name)
files_request = request_handler.request.files
if files_request:
file_cid_list = []
for field_name in field_list:
if field_name:
f_metas = files_request.get(field_name)
if f_metas:
title = md5(uuid.uuid1().hex)
source_title = None
content_type = None
f_buffers = []
for f_meta in f_metas:
f_buffers.append(f_meta['body'])
source_title = f_meta['filename']
content_type = f_meta['content_type']
if f_buffers:
e_name = get_file_extension_name(source_title)
title = u'%s%s' % (title, e_name)
final_name = os.path.join(settings.UPLOAD_FILES_PATH, title)
upload_file = None
uf = None
if file_cid:
uf = await UploadFiles.find_one(dict(cid=file_cid))
if uf:
await drop_disk_file(os.path.join(settings.UPLOAD_FILES_PATH, uf.title))
try:
upload_file = open(final_name, 'wb')
with upload_file:
upload_file.write((''.encode('utf-8')).join(f_buffers))
finally:
if upload_file:
upload_file.close()
if not uf:
uf = UploadFiles()
file_code = get_increase_code(KEY_INCREASE_UPLOAD_FILE)
uf.code = file_code
uf.title = title
uf.source_title = source_title
uf.size = os.path.getsize(final_name)
uf.category = category
if request_handler.current_user:
uf.updated_id = request_handler.current_user.oid
uf.created_id = request_handler.current_user.oid
uf.content_type = content_type
await uf.save()
file_cid_list.append(uf.cid)
return file_cid_list
return []
async def post(self):
res = dict(code=0)
name = self.get_argument('name')
sex = int(self.get_argument('sex', 1))
email = self.get_argument('email')
mobile = self.get_argument('mobile')
birthday = self.get_argument('birthday')
province_code = self.get_argument('province_code') # 省份编码
city_code = self.get_argument('city_code') # 城市编码
vehicle_code = self.get_argument('vehicle_code') # 车型编号
purchase_datetime = self.get_argument('purchase_datetime') # 车辆购买时间
content = self.get_argument('content') # 备注
status = int(self.get_argument('status', STATUS_USER_ACTIVE))
if name and mobile and email:
# 校验用户名
if mobile:
exist_count = await Member.count(dict(mobile=mobile))
if exist_count:
res['code'] = -2
return res
if email:
email_valid = re.match(
r"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$", email)
exist_count = await Member.count(dict(email=email))
if exist_count:
res['code'] = -3
return res
if not email_valid:
res['code'] = -4
return res
if mobile:
member = Member()
member.mobile = mobile
member.code = get_increase_code(KEY_INCREASE_MEMBER_CODE)
if email:
member.email = email
else:
member = Member()
member.email = email
member.code = get_increase_code(KEY_INCREASE_MEMBER_CODE)
if name:
member.name = name
member.sex = sex
if birthday:
member.birthday = str2datetime(birthday, '%Y-%m-%d')
if vehicle_code:
vehicle = await Vehicle.find_one(
dict(code=vehicle_code, record_flag=1))
if vehicle:
member.needless['vehicle_title'] = vehicle.title
member.needless['vehicle_brand'] = vehicle.needless.get(
'brand')
member.needless['vehicle_category'] = vehicle.needless.get(
'category')
member.needless['vehicle_series'] = vehicle.needless.get(
'series')
member.needless['vehicle_config'] = vehicle.needless.get(
'config')
member.needless['vehicle_colour'] = vehicle.needless.get(
'colour')
member.needless['vehicle_displace'] = vehicle.needless.get(
'displace')
else:
for attr in [
'vehicle_brand', 'vehicle_category', 'vehicle_series',
'vehicle_config', 'vehicle_colour', 'vehicle_displace',
'vehicle_title'
]:
try:
member.needless.pop(attr)
except KeyError:
pass
member.content = content
member.status = status
# 冗余信息
if province_code:
province = await AdministrativeDivision.find_one(
dict(parent_code=None, code=province_code))
if province:
member.needless['province'] = province.title
city = await AdministrativeDivision.find_one(
dict(parent_code=province_code, code=city_code))
if city:
member.needless['city'] = city.title
member.province_code = province_code
member.city_code = city_code
member.source = SOURCE_TYPE_MEMBER_SYSTEM
if vehicle_code:
if vehicle_code:
vehicle = await Vehicle.find_one(
dict(code=vehicle_code, record_flag=1))
if vehicle:
member.needless['vehicle_title'] = vehicle.title
member.needless[
'vehicle_brand'] = vehicle.needless.get('brand')
member.needless[
'vehicle_category'] = vehicle.needless.get(
'category')
member.needless[
'vehicle_series'] = vehicle.needless.get('series')
member.needless[
'vehicle_config'] = vehicle.needless.get('config')
member.needless[
'vehicle_colour'] = vehicle.needless.get('colour')
member.needless[
'vehicle_displace'] = vehicle.needless.get(
'displace')
member.vehicle_code = vehicle_code
if purchase_datetime:
member.purchase_datetime = str2datetime(
purchase_datetime, '%Y-%m')
member.status = status
member_id = await member.save()
res['code'] = 1
res['member_id'] = member_id
else:
res['code'] = -1
return res
async def post(self):
r_dict = {'code': 0}
try:
args_dict = json.loads(self.request.body)
auth_code = args_dict.get('auth_code', None)
user_info = args_dict.get('userInfo', {})
if not user_info:
user_info = {}
source = args_dict.get('source', None)
if auth_code:
params_dict = {
'app_id': MINI_APP_ID,
'app_secret': MINI_APP_SECRET,
'code': auth_code
}
exchange_url = API_CODE_EXCHANGE_SESSION_URL.format(
**params_dict)
http_client = AsyncHTTPClient()
response = await http_client.fetch(exchange_url,
validate_cert=False)
if response.code == 200:
rep_dict = json.loads(response.body)
open_id = rep_dict.get('openid')
friend_open_id = args_dict.get('friend_open_id', None)
session_key = rep_dict.get('session_key')
if open_id:
member = await find_member_by_open_id(open_id)
if not member:
if source is not None:
source_type = str(source)
else:
source_type = str(SOURCE_TYPE_MEMBER_SYSTEM)
# 创建用户
member = Member(id=ObjectId(),
code=get_increase_code(
KEY_INCREASE_MEMBER_CODE),
open_id=open_id,
source=source_type,
status=STATUS_USER_ACTIVE)
wechat_info = await parse_wechat_info(user_info)
member.sex = int(
user_info.get('gender')) if user_info.get(
'gender') else SEX_NONE
member.avatar = wechat_info.get(
'avatar'
) if wechat_info.get('avatar') else '%s://%s%s' % (
SERVER_PROTOCOL, SERVER_HOST,
self.static_url('images/default/visitor.png'))
member.nick_name = wechat_info.get(
'nick_name') if wechat_info.get(
'nick_name') else '游客'
if wechat_info:
member.province_code = wechat_info.get(
'province_code')
member.city_code = wechat_info.get('city_code')
member.district_code = wechat_info.get(
'district_code')
member.needless['province'] = wechat_info.get(
'province_name')
member.needless['city'] = wechat_info.get(
'city_name')
member.needless['district'] = wechat_info.get(
'district_name')
member.wechat_info = user_info
member.register_datetime = datetime.datetime.now()
member.login_datetime = datetime.datetime.now()
member.login_times += 1
await member.save()
# 会员属性统计
await start_task_member_property_statistics(member)
r_dict['open_id'] = open_id
r_dict['session_key'] = session_key
r_dict['code'] = 1000
else:
if member.status == STATUS_USER_INACTIVE:
r_dict['code'] = 1002
else:
member.login_datetime = datetime.datetime.now()
member.login_times += 1
await member.save()
r_dict['open_id'] = open_id
r_dict['session_key'] = session_key
r_dict['code'] = 1000
if friend_open_id:
friend = await find_member_by_open_id(
friend_open_id)
if friend:
friend_member = MemberFriend(
member_cid=member.cid,
friend_cid=friend.cid)
await friend_member.save()
member_friend = MemberFriend(
member_cid=friend.cid,
friend_cid=member.cid)
await member_friend.save()
else:
r_dict['code'] = 1003
else:
r_dict['code'] = 1001
except Exception:
logger.error(traceback.format_exc())
return r_dict
async def post(self):
res = {'code': 1}
present_id = self.get_argument('present_id')
receiver_name = self.get_argument('receiver_name')
receive_address = self.get_argument('receiver_address')
receiver_mobile = self.get_argument('receiver_mobile')
receiver_area_codes = self.get_argument('receiver_area_codes')
member_id = self.current_user.oid
if present_id and member_id:
try:
present = await Present.get_by_id(present_id)
member = await Member.get_by_id(member_id)
if present and member and present.category == CATEGORY_PRESENT_REAL_GIFT:
# 校验积分
if present.ex_integral > member.integral:
res['code'] = -1
# 校验库存
elif present.inventory < 1:
res['code'] = -2
else:
# 新建订单
order = ExchangeOrder(
present_cid=present.code,
member_cid=member.cid,
code=get_increase_code(
KEY_INCREASE_EXCHANGE_ORDER_CODE),
order_datetime=datetime.now(),
receiver_name=receiver_name,
receiver_mobile=receiver_mobile)
if receiver_area_codes:
area_codes_list = receiver_area_codes.split(',')
# 省
try:
province_code = area_codes_list[0]
province = await AdministrativeDivision.find_one(
dict(code=province_code))
order.needless['province'] = province.title
order.province_code = province.code
except IndexError:
pass
try:
city_code = area_codes_list[1]
city = await AdministrativeDivision.find_one(
dict(code=city_code))
order.needless['city'] = city.title
order.city_code = city.code
except IndexError:
pass
try:
district_code = area_codes_list[2]
district = await AdministrativeDivision.find_one(
dict(code=district_code))
order.needless['district'] = district.title
order.district_code = district.code
except IndexError:
pass
order.receive_address = receive_address
order.ex_integral = present.ex_integral
order.status = STATUS_EXCHANGE_ORDER_UNSHIPPED
order.updated_id = self.current_user.oid
order.created_id = self.current_user.oid
await order.save()
# present 库存减少
present.update_dt = datetime.now()
present.updated_id = self.current_user.oid
present.inventory = present.inventory - 1
await present.save()
# 用户积分减少
member.update_dt = datetime.now()
member.updated_id = self.current_user.oid
member.integral = member.integral - present.ex_integral
await member.save()
else:
res['code'] = 0
except Exception:
logger.error(traceback.format_exc())
res['code'] = 0
else:
res['code'] = 0
return res
async def __subject_import_excel(self, excel_file_content):
result_code = 1
custom_code_list = await Subject.distinct('custom_code', {'record_flag': 1})
book = xlrd.open_workbook(file_contents=excel_file_content)
sheet = book.sheet_by_index(0)
subject_list = []
subject_option_list = []
row_list = []
k_first_dict = dict(zip(KNOWLEDGE_FIRST_LEVEL_DICT.values(), KNOWLEDGE_FIRST_LEVEL_DICT.keys()))
k_second_dict = dict(zip(KNOWLEDGE_SECOND_LEVEL_DICT.values(), KNOWLEDGE_SECOND_LEVEL_DICT.keys()))
# 维度信息
field_dict = {'record_flag': 1, 'status': STATUS_SUBJECT_DIMENSION_ACTIVE, 'parent_cid': {'$in': ['', None]}}
all_dimension_list = await SubjectDimension.find(field_dict).to_list(None)
sub_dict = dict(record_flag=1, status=STATUS_SUBJECT_DIMENSION_ACTIVE)
subject_dimension_dict = {}
for subject_dimension in all_dimension_list:
sub_dict['parent_cid'] = subject_dimension.cid
sub_dimension_list = await SubjectDimension.find(sub_dict).to_list(None)
if sub_dimension_list:
subject_dimension_dict[subject_dimension.cid] = sub_dimension_list
# 按顺序得到表头对应的维度cid（如果题目表头除维度之外有增减，3就随之改变）
cid_list = []
title_list = []
is_empty = 0
for ind, col in enumerate(sheet.row_values(0)):
if col:
title_list.append(col)
if 3 < ind < (len(all_dimension_list) + 4):
if not col:
is_empty = 1
flag = 1
for dimension in all_dimension_list:
if dimension.title == str(self.__get_replace_data(col, 2)):
flag = 2
cid_list.append(dimension.cid)
break
if flag == 1:
continue
if (ind < len(cid_list) + 8) and not col:
is_empty = 1
# 判断表头是否正确（如果题目表头除维度之外有增减，8就随之改变）
if not (len(cid_list) + 8) == len(title_list) or len(cid_list) < 1 or is_empty:
result_code = 2
return result_code
for rownum in range(1, sheet.nrows):
row_list.append([col for col in sheet.row_values(rownum)])
if row_list:
for i, row_data in enumerate(row_list):
is_exist = 0
# 题目ID
custom_code = str(self.__get_replace_data(row_data[1], 2))
if not custom_code or len(custom_code) > 20 or len(custom_code) < 5:
continue
else:
reg = re.compile(r'^[a-zA-Z0-9]*$')
if not bool(reg.match(custom_code)):
continue
if custom_code not in custom_code_list:
subject = Subject()
subject_code = str(get_increase_code(KEY_INCREASE_SUBJECT_CODE))
subject.code = subject_code
subject.custom_code = custom_code
subject.status = STATUS_SUBJECT_ACTIVE
custom_code_list.append(custom_code)
else:
subject = await Subject.find_one(dict(custom_code=custom_code))
# await SubjectOption.delete_many({'subject_cid': subject.cid})
subject.updated_dt = datetime.datetime.now()
is_exist = 1
# 一级知识点
subject.knowledge_first = self.__get_replace_data(row_data[2], 1, data_dict=k_first_dict)
# 二级知识点
subject.knowledge_second = self.__get_replace_data(row_data[3], 1, data_dict=k_second_dict)
# 知识维度
dimension_dict = {}
is_wrong = 0
end_dimension_len = 4 + len(cid_list)
for index in range(4, end_dimension_len):
c_code = self.__get_replace_data(row_data[index], 2)
cid = cid_list[index - 4]
if cid and c_code:
sub_list = subject_dimension_dict.get(cid)
if sub_list:
is_wrong = 0
for sub_dimension in sub_list:
if sub_dimension.code == c_code:
is_wrong = 1
dimension_dict[cid] = sub_dimension.cid
break
if not is_wrong:
result_code = 3
is_wrong = 0
break
if dimension_dict and is_wrong:
subject.dimension_dict = dimension_dict
else:
continue
# 答案解析
resolving = self.__get_replace_data(row_data[end_dimension_len], 2)
if not resolving:
continue
else:
subject.resolving = resolving
# 题目
title = self.__get_replace_data(row_data[end_dimension_len + 1], 2)
if not title:
continue
else:
subject.title = title
# 答案
count = 0
if not row_data[end_dimension_len + 2]:
continue
else:
if not row_data[end_dimension_len + 2].strip().isalpha() or len(
row_data[end_dimension_len + 2].strip()) > 1:
continue
count = ord(row_data[end_dimension_len + 2].strip().upper()) - 64
if (count + end_dimension_len + 2) > len(row_data):
continue
else:
if not row_data[count + end_dimension_len + 2]:
continue
# 选项
num = 0
tmp_option_list = await SubjectOption.find({'subject_cid': subject.cid}).sort([('sort', ASC)]).to_list(
None)
for index in range(end_dimension_len + 3, len(row_data)):
if row_data[index]:
option_title = self.__get_replace_data(row_data[index], 2)
if not option_title:
continue
else:
sort = index - (end_dimension_len + 2)
a_index = sort - 1
update, subject_option = False, None
if tmp_option_list:
if len(tmp_option_list) > a_index:
subject_option = tmp_option_list[a_index]
update = True
if subject_option is None:
subject_option = SubjectOption(
code=str(get_increase_code(KEY_INCREASE_SUBJECT_OPTION_CODE)))
if isinstance(option_title, (float, int)):
option_title = str(option_title)
subject_option.title = option_title
subject_option.sort = sort
if sort == count:
subject_option.correct = True
else:
subject_option.correct = False
subject_option.subject_code = subject.code
subject_option.subject_cid = subject.cid
if update:
subject_option.updated_dt = datetime.datetime.now()
subject_option.updated_id = self.current_user.oid
subject_option.needless = {}
await subject_option.save()
else:
subject_option_list.append(subject_option)
num += 1
subject.needless = {'option_quantity': num}
if is_exist:
await subject.save()
else:
subject_list.append(subject)
if len(subject_list) == 500:
await Subject.insert_many(subject_list)
subject_list = []
if len(subject_option_list) == 500:
await SubjectOption.insert_many(subject_option_list)
subject_option_list = []
if subject_list:
await Subject.insert_many(subject_list)
if subject_option_list:
await SubjectOption.insert_many(subject_option_list)
return result_code
async def post(self):
r_dict = {'code': 0}
subject_id = None
try:
title = self.get_argument('title', None)
option_str = self.get_argument('option_list', None)
option_list = json.loads(option_str) if option_str else []
# difficulty = self.get_argument('difficulty', None)
# category = self.get_argument('category', None)
content = self.get_argument('content', None)
status = self.get_argument('status', None) # 状态
knowledge_first = self.get_argument('knowledge_first', None)
knowledge_second = self.get_argument('knowledge_second', None)
category_use = self.get_argument('category_use', None)
resolving = self.get_argument('resolving', None)
subject_dimension_list = self.get_arguments('subject_dimension')
custom_code = self.get_argument('custom_code', None)
if title and len(option_list) >= 2 and resolving and custom_code:
c_count = await Subject.count(dict(custom_code=custom_code))
if c_count > 0:
r_dict['code'] = -10
else:
if status == 'on':
status = STATUS_SUBJECT_ACTIVE
else:
status = STATUS_SUBJECT_INACTIVE
image_cid = None
image_cid_list = await save_upload_file(self, 'image', category=CATEGORY_UPLOAD_FILE_IMG_SUBJECT)
if image_cid_list:
image_cid = image_cid_list[0]
code = get_increase_code(KEY_INCREASE_SUBJECT_CODE)
# subject = Subject(code=code, title=title, difficulty=int(difficulty), category=int(category))
subject = Subject(code=code, title=title)
subject.custom_code = custom_code
subject.image_cid = image_cid
subject.status = status
subject.content = content
subject.created_id = self.current_user.oid
subject.updated_id = self.current_user.oid
subject.resolving = resolving
knowledge_first = int(knowledge_first) if knowledge_first else None
knowledge_second = int(knowledge_second) if knowledge_second else None
subject.knowledge_first = knowledge_first
subject.knowledge_second = knowledge_second
subject.category_use = int(category_use) if category_use else None
subject_dimension_dict = {}
if subject_dimension_list:
for subject_dimension in subject_dimension_list:
try:
subject_dimension_cid, sub_subject_dimension_cid = subject_dimension.split('_')
subject_dimension_dict[subject_dimension_cid] = sub_subject_dimension_cid
except ValueError as e:
if subject_dimension != 'DFKX':
raise e
subject.dimension_dict = subject_dimension_dict
# 冗余信息
if not isinstance(subject.needless, dict):
subject.needless = {}
subject.needless['option_quantity'] = len(option_list)
if option_list:
subject_id = await subject.save()
for index, option_dict in enumerate(option_list):
if option_dict:
so = SubjectOption(subject_cid=subject.cid, code=str(index + 1),
title=option_dict.get('content'),
correct=option_dict.get('is_correct'))
so.sort = str(index + 1)
so.created_id = self.current_user.oid
so.updated_id = self.current_user.oid
await so.save()
await set_subject_choice_rules_redis_value(1)
r_dict['code'] = 1
else:
if not title:
r_dict['code'] = -1
# if not difficulty:
# r_dict['code'] = -4
# if not category:
# r_dict['code'] = -5
if not resolving:
r_dict['code'] = -8
if not option_list and len(option_list) < 2:
r_dict['code'] = -6
if not custom_code:
r_dict['code'] = -9
if not category_use:
r_dict['code'] = -11
except Exception as e:
if subject_id:
subject = await Subject.get_by_id(subject_id)
if subject:
await Subject.delete_by_ids([subject.oid])
await Subject.delete_many({'code': subject.code})
logger.error(traceback.format_exc())
return r_dict