def post(self, doc_id):
"""保存单字校对内容"""
try:
data = self.get_request_data()
if data.get('ids'):
return self.batch_pass(data)
v.validate(
data, [(v.not_empty, 'result'),
(v.in_list, 'result', ['doubt', 'invalid', 'changed'])],
self)
assert (data['result'] != 'changed') == (not data.get('txt'))
char = self.db.char.find_one({'_id': ObjectId(doc_id)})
if char is None:
return self.send_error_response(e.no_object, message='没有此单字')
if char.get('review_by') and 'review' not in self.request.path:
return self.send_error_response(e.unauthorized,
message='已审核，不能再校对')
if data.get('txt'):
if data['txt'] not in char2indice:
return self.send_error_response(e.no_object,
message='无效的单字: ' +
data['txt'])
r = self.db.char.update_one(
{'_id': char['_id']},
{'$set': dict(txt=data['txt'], result=data['result'])})
else:
r = self.db.char.update_one(
{'_id': char['_id']},
{'$set': dict(result=data['result'])})
if r.modified_count:
by = 'review' if 'review' in self.request.path else 'proof'
by = {
by + '_by': self.current_user['name'],
by + '_time': datetime.now()
}
self.db.char.update_one({'_id': char['_id']}, {'$set': by})
self.add_op_log('label_char',
target_id=char['_id'],
message='%s %s' %
(data['result'], data.get('txt', '')))
char.update(data)
self.update_labeled_count(char['old_txt'])
self.send_data_response(char)
except DbError as err:
self.send_db_error(err)
def post(self):
"""测试数据返回"""
data = self.get_request_data()
v.validate(data, [
(v.not_empty, 'name')
], self)
try:
r = self.db.dummy.find_one(dict(name=data['name']))
assert r is not None # to test send_db_error
self.send_data_response(dict(res=data['res']))
except AssertionError as err:
self.send_db_error(err)
except DbError as err:
self.send_db_error(err)
def post(self):
""" 修改用户基本信息: 姓名，手机，邮箱，性别"""
user = self.get_request_data()
rules = [
(v.not_empty, 'name'),
(v.not_both_empty, 'email', 'phone'),
(v.is_name, 'name'),
(v.is_email, 'email'),
(v.is_phone, 'phone'),
(v.not_existed, self.db.user, self.current_user['_id'], 'phone', 'email')
]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
old_user = self.db.user.find_one(dict(_id=user['_id']))
if not old_user:
return self.send_error_response(errors.no_user, id=user['_id'])
sets = {f: user[f] for f in ['name', 'phone', 'email', 'gender']
if f in user and user[f] != old_user.get(f)}
if not sets:
return self.send_error_response(errors.no_change)
r = self.db.user.update_one(dict(_id=user['_id']), {'$set': sets})
if r.modified_count:
self.add_op_log('change_user_profile', target_id=user['_id'],
context='%s: %s' % (old_user['name'], ','.join(sets.keys())))
self.send_data_response(dict(info=sets))
except DbError as e:
return self.send_db_error(e)
def post(self, page_prefix):
""" 按照页码前缀发布任务。
@param task_type 任务类型
@param pre_tasks list，前置任务
@param page_prefix str，至少2位以上
@param priority str，1/2/3，数字越大优先级越高
"""
data = self.get_request_data()
rules = [
(v.not_empty, 'task_type'),
(v.is_priority, 'priority'),
(v.in_list, 'task_type', list(self.task_types.keys())),
(v.in_list, 'pre_tasks', list(self.task_types.keys())),
]
err = v.validate(data, rules)
if err:
return self.send_error_response(err)
condition = {
'name': {
'$regex': '.*%s.*' % page_prefix,
'$options': '$i'
}
}
pages = self.db.page.find(condition, self.simple_fileds())
log = self.publish_task(data['task_type'],
data.get('pre_tasks', []),
data.get('priority', 1),
pages=pages)
self.send_data_response({k: v_ for k, v_ in log.items() if v_})
def test_validate(self):
data = {
'name': '1234567890',
'phone': '1',
'email': '1',
'password': '',
'age': 8,
'old_password': ''
}
rules = [(v.not_empty, 'name', 'password'),
(v.not_both_empty, 'old_password', 'password'),
(v.is_name, 'name'), (v.is_phone_or_email, 'phone'),
(v.is_phone, 'phone'), (v.is_email, 'email'),
(v.is_password, 'name'), (v.is_digit, 'phone'),
(v.between, 'age', 10, 100),
(v.not_equal, 'password', 'old_password'),
(v.equal, 'password', 'age'), (v.in_list, 'email', ['a',
'b'])]
errs = v.validate(data, rules)
self.assertEqual(
set(errs.keys()),
{'age', 'email', 'name', 'password', 'phone', 'old_password'})
for k, t in errs.items():
self.assertIs(t.__class__, tuple)
self.assertIs(t[0].__class__, int)
self.assertIs(t[1].__class__, str)
def post(self):
""" 修改我的密码 """
user = self.get_request_data()
rules = [
(v.not_empty, 'password', 'old_password'),
(v.not_equal, 'password', 'old_password'),
(v.is_password, 'password')
]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
u = self.db.user.find_one(dict(_id=self.current_user['_id']))
if u.get('password') != hlp.gen_id(user['old_password']):
return self.send_error_response(errors.incorrect_old_password)
self.db.user.update_one(
dict(_id=self.current_user['_id']),
{'$set': dict(password=hlp.gen_id(user['password']))}
)
self.add_op_log('change_password')
except DbError as e:
return self.send_db_error(e)
logging.info('change password %s' % self.current_user['name'])
self.send_data_response()
def post(self):
""" 登录 """
user = self.get_request_data()
rules = [
(v.not_empty, 'phone_or_email', 'password'),
]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
# 检查是否多次登录失败
login_fail = {
'type': 'login-fail',
'create_time': {'$gt': hlp.get_date_time(diff_seconds=-1800)},
'context': user.get('phone_or_email')
}
times = self.db.log.count_documents(login_fail)
if times >= 20:
return self.send_error_response(errors.unauthorized, message='登录失败，请半小时后重试，或者申请重置密码')
login_fail['create_time']['$gt'] = hlp.get_date_time(diff_seconds=-60)
times = self.db.log.count_documents(login_fail)
if times >= 5:
return self.send_error_response(errors.unauthorized, message='登录失败，请一分钟后重试')
# 尝试登录，成功后清除登录失败记录，设置为当前用户
self.login(self, user.get('phone_or_email'), user.get('password'))
except DbError as e:
return self.send_db_error(e)
def post(self):
"""用户注册时，发送邮箱验证码"""
data = self.get_request_data()
rules = [(v.not_empty, 'email')]
err = v.validate(data, rules)
if err:
return self.send_error_response(err)
email = data.get('email')
code = hlp.random_code()
self.send_email(email, code)
try:
self.db.verify.find_one_and_update(
dict(type='email', data=email), dict(code=code, stime=datetime.now()), upsert=True
)
except DbError as e:
return self.send_db_error(e)
self.send_data_response()
def test_validate(self):
data = {'name': '1234567890', 'phone': '', 'email': '', 'password': '', 'age': 8}
rules = [
(v.allowed_keys, 'name', 'phone', 'email', 'password'),
(v.not_empty, 'name', 'password'),
(v.not_both_empty, 'phone', 'email'),
(v.is_name, 'name'),
(v.is_phone, 'phone'),
(v.is_email, 'email'),
(v.is_password, 'password'),
(v.between, 'age', 10, 100),
]
errs = v.validate(data, rules)
self.assertEqual(set(errs.keys()), {'age', 'email', 'name', 'password', 'phone'})
for k, t in errs.items():
self.assertIs(t.__class__, tuple)
self.assertIs(t[0].__class__, int)
self.assertIs(t[1].__class__, str)
def post(self):
"""用户注册时，发送手机验证码"""
data = self.get_request_data()
rules = [(v.not_empty, 'phone')]
err = v.validate(data, rules)
if err:
return self.send_error_response(err)
phone = data['phone']
code = "%04d" % random.randint(1000, 9999)
self.send_sms(phone, code)
try:
self.db.verify.find_one_and_update(
dict(type='email', data=phone), dict(code=code, stime=datetime.now()), upsert=True
)
except DbError as e:
return self.send_db_error(e)
self.send_data_response()
def post(self):
""" 按照页码名称发布任务。
@param task_type 任务类型
@param pre_tasks list，前置任务
@param pages str，待发布的页面名称
@param pages_file file，待发布的页面文件
@param priority str，1/2/3，数字越大优先级越高
"""
pages_file = self.request.files.get('pages_file')
if pages_file:
pages_str = str(pages_file[0]['body'], encoding='utf-8')
pre_task = self.get_body_argument('pre_tasks')
data = {
'pages': re.sub(r"\n+", ",", pages_str),
'task_type': self.get_body_argument('task_type', ''),
'priority': self.get_body_argument('priority', 1),
'pre_tasks': pre_task and pre_task.split(',') or []
}
else:
data = self.get_request_data()
if 'page_names' in data and 'pages' not in data:
data['pages'] = data.pop('page_names')
rules = [
(v.not_empty, 'task_type'),
(v.not_both_empty, 'pages', 'pages_file'),
(v.is_priority, 'priority'),
(v.in_list, 'task_type', list(self.task_types.keys())),
(v.in_list, 'pre_tasks', list(self.task_types.keys())),
]
err = v.validate(data, rules)
if err:
return self.send_error_response(err)
page_names = data['pages'].split(',') if data.get('pages') else []
if len(page_names) > self.MAX_PUBLISH_RECORDS:
return self.send_error_response(e.task_exceed_max,
message='发布任务数量超过%s' %
self.MAX_PUBLISH_RECORDS)
log = self.publish_task(data['task_type'], data.get('pre_tasks', []),
data.get('priority', 1), page_names)
self.send_data_response({k: v_ for k, v_ in log.items() if v_})
def post(self):
""" 注册 """
user = self.get_request_data()
rules = [
(v.not_empty, 'name', 'password'),
(v.not_both_empty, 'email', 'phone'),
(v.is_name, 'name'),
(v.is_email, 'email'),
(v.is_phone, 'phone'),
(v.is_password, 'password'),
(v.not_existed, self.db.user, 'phone', 'email')]
if not options.testing and not options.debug and user.get('email'):
rules.append((v.not_empty, 'email_code'))
rules.append((v.code_verify_timeout, self.db.verify, 'email', 'email_code'))
if not options.testing and not options.debug and user.get('phone'):
rules.append((v.not_empty, 'phone_code'))
rules.append((v.code_verify_timeout, self.db.verify, 'phone', 'phone_code'))
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
user['roles'] = '用户管理员' if not self.db.user.find_one() else '' # 如果是第一个用户，则设置为用户管理员
user['img'] = 'imgs/ava%s.png' % (1 if user.get('gender') == '男' else 2 if user.get('gender') == '女' else 3)
r = self.db.user.insert_one(dict(
name=user['name'], email=user.get('email'), phone=user.get('phone'),
gender=user.get('gender'), roles=user['roles'], img=user['img'],
password=hlp.gen_id(user['password']),
create_time=hlp.get_date_time()
))
user['_id'] = r.inserted_id
self.add_op_log('register', context='%s, %s, %s' % (user.get('email'), user.get('phone'), user['name']))
except DbError as e:
return self.send_db_error(e)
user['login_md5'] = hlp.gen_id(user['roles'])
self.current_user = user
self.set_secure_cookie('user', json_util.dumps(user))
logging.info('register id=%s, name=%s, email=%s' % (user['_id'], user['name'], user.get('email')))
self.send_data_response(user)
def post(self):
""" 删除用户 """
user = self.get_request_data()
rules = [(v.not_empty, '_id')]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
old_user = self.db.user.find_one(dict(_id=user['_id']))
if not old_user:
return self.send_error_response(errors.no_user, id=user['_id'])
if user['_id'] == self.current_user['_id']: # 判断删除的用户是否为自己
return self.send_error_response(errors.cannot_delete_self)
r = self.db.user.delete_one(dict(_id=user['_id']))
if r.deleted_count < 1:
return self.send_error_response(errors.no_user)
self.add_op_log('delete_user', target_id=user['_id'], context=old_user['name'])
except DbError as e:
return self.send_db_error(e)
self.send_data_response()
def post(self):
""" 修改我的个人信息，包括姓名、性别等 """
user = self.get_request_data()
rules = [
(v.not_empty, 'name'),
(v.not_both_empty, 'email', 'phone'),
(v.is_name, 'name'),
(v.is_email, 'email'),
(v.is_phone, 'phone'),
(v.not_existed, self.db.user, self.current_user['_id'], 'phone', 'email')
]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
self.current_user['name'] = user.get('name') or self.current_user['name']
self.current_user['gender'] = user.get('gender') or self.current_user.get('gender')
self.current_user['email'] = user.get('email') or self.current_user['email']
self.current_user['phone'] = user.get('phone') or self.current_user.get('phone')
r = self.db.user.update_one(dict(_id=self.current_user['_id']), {
'$set': dict(
name=self.current_user['name'],
gender=self.current_user.get('gender'),
email=self.current_user.get('email'),
phone=self.current_user.get('phone')
)
})
if not r.modified_count:
return self.send_error_response(errors.no_change)
self.set_secure_cookie('user', json_util.dumps(self.current_user))
self.add_op_log('change_profile')
except DbError as e:
return self.send_db_error(e)
logging.info('change profile %s' % (user.get('name')))
self.send_data_response()
def post(self):
""" 重置用户密码 """
user = self.get_request_data()
rules = [(v.not_empty, '_id')]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
pwd = '%s%d' % (chr(random.randint(97, 122)), random.randint(10000, 99999))
try:
oid = objectid.ObjectId(user['_id'])
r = self.db.user.update_one(dict(_id=oid), {'$set': dict(password=hlp.gen_id(pwd))})
if not r.matched_count:
return self.send_error_response(errors.no_user)
user = self.db.user.find_one(dict(_id=oid))
self.remove_login_fails(self, user['_id'])
self.add_op_log('reset_password', target_id=user['_id'], context=user['name'])
except DbError as e:
return self.send_db_error(e)
self.send_data_response({'password': pwd})
def post(self):
""" 修改用户角色 """
user = self.get_request_data()
rules = [(v.not_empty, '_id')]
err = v.validate(user, rules)
if err:
return self.send_error_response(err)
try:
old_user = self.db.user.find_one(dict(_id=user['_id']))
if not old_user:
return self.send_error_response(errors.no_user, id=user['_id'])
user['roles'] = user.get('roles') or ''
r = self.db.user.update_one(dict(_id=user['_id']), {'$set': dict(roles=user['roles'])})
if not r.matched_count:
return self.send_error_response(errors.no_user)
self.add_op_log('change_role', target_id=user['_id'],
context='%s: %s' % (old_user['name'], user.get('roles')))
except DbError as e:
return self.send_db_error(e)
self.send_data_response({'roles': user['roles']})
def post(self):
""" 获取比对文本的前后页文本
:param page_code: 当前cmp文本的page_code（es库中的page_code）
:param neighbor: prev/next，根据当前cmp文本的page_code往前或者往后找一条数据
"""
try:
data = self.get_request_data()
err = v.validate(data,
[(v.not_empty, 'cmp_page_code', 'neighbor')])
if err:
return self.send_error_response(err)
neighbor = find_neighbor(data.get('cmp_page_code'),
data.get('neighbor'))
if neighbor:
self.send_data_response(
dict(txt=Diff.pre_cmp(''.join(
neighbor['_source']['origin'])),
code=neighbor['_source']['page_code']))
else:
self.send_error_response(errors.no_object, message='没有更多内容')
except DbError as e:
self.send_db_error(e)
