def put_user():
data = request.json or {}
id = g.user.id
data['id'] = id
form = UserPutForm()
form.validate_for_api()
UserModel.put_user(id, data=data)
return Success(msg='修改个人信息成功!')
def get_score_of_specific_users(username):
"""获取某用户的成绩情况
:param username: 用户邮箱
:return: 该用户的成绩情况
"""
current_app.logger.info('get_score_of_specific_users ' + username)
if '@' in username:
# 邮箱登录
email = username
if not validate_email(email):
return jsonify(errors.Params_error)
if ScoreConfig.DEFAULT_USER_EMAIL in username:
# 默认邮箱，通过主键查询
user_object_id = username[:-16]
all_answers = AnalysisModel.objects(
user=user_object_id).order_by('date')
else:
# 真实邮箱
cur_user = UserModel.objects(email=username).first()
if not cur_user:
return jsonify(errors.Score_criteria_not_exist)
all_answers = AnalysisModel.objects(user=cur_user['id']).\
fields(voice_features=0, key_hits=0, detail_hits=0).order_by('date')
else:
# 手机号登录
cur_user = UserModel.objects(phone=username).first()
if not cur_user:
return jsonify(errors.Score_criteria_not_exist)
all_answers = AnalysisModel.objects(user=cur_user['id']). \
fields(voice_features=0, key_hits=0, detail_hits=0).order_by('date')
if len(all_answers) == 0:
return jsonify(errors.Score_no_data)
date_mapper = DateMapper()
result_by_date = __generate_result_from_dict(
date_mapper.map_answers(all_answers), 'date')
question_id_mapper = QuestionNumMapper()
result_by_qid = __generate_result_from_dict(
question_id_mapper.map_answers(all_answers), 'questionId')
# 按照 q_id 排序
result_by_qid.sort(key=__sort_by_question_id)
result_all = []
for answer in result_by_qid:
result_all.append({
'questionId': answer['questionId'],
'totalScore': answer['totalScore']
})
return jsonify(
errors.success({
'resultByDate': result_by_date,
'allResult': result_all
}))
def _handle_regular_user(self, data):
session_model = Session()
session_id = g.get("session_id", None)
model = UserModel(session_id)
user = model.create(data)
if user:
session_model.update(session_id, user_id=user.id)
return user
return None
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {"message": "Error: username already exists"}, 409
user = UserModel(**data)
user.save()
return {"message": "User registered successfully"}, 201
def validate_username(self, data):
username = data.get("username")
if username and len(username) < 2:
raise ValidationError(
"Username must be at least 2 characters long", "username")
model = UserModel(None)
if not data.get("social_uid") and model.username_exists(username):
raise ValidationError("Username already taken", "username")
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'This username already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully'}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "User with that username already exists."}, 400
user = UserModel(**data) ## unpack the data, because its a dictionary
user.save_to_db()
return {"message": "User created successfully."}, 201
def create_tables():
db.create_all()
db.session.commit()
from app.models.user import UserModel
if not UserModel.find_by_username("admin"):
UserModel(username="******",
password="******",
firstName="admin",
lastName="admin",
phoneNumber="123467890").save_to_db()
def put(cls, user_id):
data = request.get_json()
create_error = UserSchema().validate(data)
update_error = UserUpdateSchema().validate(data)
if update_error:
return {'message': update_error}, 400
if data.get('password', None):
data['password'] = bcrypt.generate_password_hash(
data['password'], 10)
user_by_id = UserModel.get_by_id(user_id)
if user_by_id:
try:
UserModel.update_by_id(user_id, data)
return {'message': 'user was updated'}, 200
except IntegrityError as err:
return {'message': err.args}, 400
if create_error:
return {'message': create_error}, 400
user = UserModel(**data)
if UserModel.get_by_email(user.email):
return {
'message': f'User with email {user.email} already exist'
}, 400
user.password = bcrypt.generate_password_hash(user.password)
user.save()
return {'message': 'User was created'}, 201
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_email(data['email']):
return {
'message': 'A user with that username already exists.'
}, 400
user = UserModel(data['email'], data['password'])
user.save_to_db()
return {"message": "User created successfully."}, 201
def register(data):
"""A new user sends username & password to register."""
# check if username exists
if UserModel.query.filter_by(username=data['username']).first():
raise BadRequest('Username existed.')
# save user's data & response a successful message
user = UserModel(**data)
user.save_to_db()
return jsonify(UserSchema(exclude=("password",)).dump(user)), 201
def post(self):
payload = request.json
id = payload['id']
pw = payload['pw']
email = payload['email']
name = payload['name']
nickname = payload.get('nickname')
bio = payload.get('bio')
UserModel.signup(id, pw, email, name, nickname, bio)
return Response('', 201)
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {
'message': 'UserModel has already been created, aborting.'
}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'user has been created successfully.'}, 201
def get(self):
user = UserModel.find_by_id(current_identity.id)
if not user:
abort(500, message="Some internal user fault.")
employees = EmployeeModel.query.all()
res = {"employees": []}
if len(employees) == 0:
return res, 200
for employee in employees:
user = UserModel.find_by_id(employee.user_id)
res["employees"].append(employee.get_employee(user))
return res, 200
def post(self):
"""
일반 사용자 회원가입
"""
id = request.form['id']
pw = request.form['pw']
if UserModel.objects(id=id):
return Response('', 204)
UserModel(id=id, pw=pw).save()
return Response('', 201)
def get_user_list():
data = request.args or {}
form = UserGetListForm(data=data)
form.validate_for_api()
page = form.page.data
size = form.size.data
userName = data['userName'] or ''
schoolId = data['schoolId'] or ''
classroom = data['classroom'] or ''
if classroom != '':
try:
classroom = ObjectId(classroom)
except:
return FormValidateError(msg='班级id有误')
cls = ClassModel.objects(id=classroom).first()
if cls is None:
return FormValidateError(msg='班级id有误')
count = UserModel.objects(name__contains=userName,
schoolId__contains=schoolId,
classId=cls).count()
users = UserModel.objects(
name__contains=userName, schoolId__contains=schoolId,
classId=cls).order_by('classId', 'schoolId').skip(
(int(page) - 1) * int(size)).limit(int(size))
else:
count = UserModel.objects(name__contains=userName,
schoolId__contains=schoolId).count()
users = UserModel.objects(
name__contains=userName,
schoolId__contains=schoolId).order_by('classId', 'schoolId').skip(
(int(page) - 1) * int(size)).limit(int(size))
list = []
for user in users:
list.append({
'id': str(user['id']),
'name': user['name'],
'classId': str(user['classId']['id']),
'classname': str(user['classId']['name']),
'schoolId': user['schoolId'],
'avatar': user['avatar']
})
data = {
'pagination': {
'count': count,
'size': int(size),
'page': int(page)
},
'list': list
}
return Success(msg='获取成功!', data=data)
def post(self):
req_data = {}
req_data['username'] = request.values.get('username', None)
req_data['password'] = request.values.get('password', None)
print('\nff' * 5, req_data, '\n**' * 5)
get_user = UserModel.find_username(_username=req_data['username'])
if get_user:
user = get_user.first()
print(user.is_admin, '**********\n\n')
if user.check_password(password=req_data['password']):
token = Auth.generate_token(user.username)
message = {'Token': token}
return jsonify(message)
else:
message = {'MSG': "wrong password!"}
return jsonify(message)
admin = request.values.get('admin', None)
if admin == 'yes':
new_user = UserModel.create_admin(username=req_data['username'],
password=req_data['password'])
else:
new_user = UserModel.create_user(username=req_data['username'],
password=req_data['password'])
try:
new_user.save()
except Exception as e:
logging.error('Error! {}'.format(e))
return jsonify({"Error": e})
print(new_user.items())
token = Auth.generate_token(new_user.username)
print('\n\n', token)
retJson = {
"jwt_token": token,
"status": 201,
}
return jsonify(retJson)
def put(self, username):
data = UserInfo.parser.parse_args()
user = UserModel.find_by_username(username)
if user:
if data['password']:
data['password'] = UserModel.get_password_hash(
data['password'])
user.password = data['password']
if data['first_name']:
user.first_name = data['first_name']
if data['last_name']:
user.last_name = data['last_name']
if data['active']:
user.active = data['active']
else:
if data['password']:
data['password'] = UserModel.get_password_hash(
data['password'])
user = UserModel(username, data['password'], data['first_name'],
data['last_name'], data['active'])
user.save_to_db()
return user.json()
def new_user():
user_data = request.json
schema = UserSchema()
schema.load(user_data)
user = UserModel(user_data['full_name'], user_data['username'],
user_data['password'], user_data['email'])
user.save_to_db()
return jsonify({
'id': user.id,
'username': user.username,
'full_name': user.full_name,
'password': user.password,
'email': user.email
}), 201
def post(self):
payload = request.json
data = {
"email": payload["email"],
"password": payload["password"],
"name": payload["name"]
}
user = UserModel.objects(email=request.json['email']).first()
if user:
abort(409)
UserModel(**data).save()
return "", 201
def post(self):
data = User.parser.parse_args()
first_name = data['first_name']
last_name = data['last_name']
email = data['email']
password = data['password']
if UserModel.find_by_email(email):
return {
'result': 'Email {} is already registered'.format(email)
}, 400
user = UserModel(userid=str(uuid.uuid1()),
first_name=first_name,
last_name=last_name,
email=email,
password=password)
user.set_password()
try:
user.save_to_db()
return user.json()
except Exception as err:
return {
'result':
'There was an error while registering your email {}'.format(
email)
}, 500
def post(self, person_id):
if UserModel.find_by_person_id(person_id):
return {
"message":
gettext("person_id_already_exists").format(person_id)
}, 400
user = UserModel(person_id=person_id)
try:
user.save_to_db()
except:
return {"message": gettext("person_id_error_inserting")}, 500
return user_schema.dump(user), 201
def post(self):
self.parser.add_argument('username', type=not_empty_string, location="json", required=True)
self.parser.add_argument('password', type=not_empty_string, location="json", required=True)
args = self.parse_args()
username = args.get('username')
password = gen_md5(args.get('password'))
user = UserModel.get_model_by_fields(username=username, password=password, deleted_at=0)
if user is None:
return res_json(code='invalid_auth_params')
try:
# 填写当前登录信息
user.login_ip = get_client_ip(request)
user.login_time = int(time.time())
user_data = user.res_format(password=False, token_expires=False, deleted_at=False)
# 更新 Api token
new_token = gen_md5(str(uuid.uuid4()))
UserRepository.update_user_token_by_model(user, new_token)
user_data['api_token'] = genrate_jwt_token(new_token, current_app.config.get("SECRET_KEY"),
current_app.config.get("USER_VALIDITY"))
except Exception as e:
current_app.logger.error(e)
return res_json(code='user_login_fail')
return res_json(data=user_data)
def login_by_google_callback():
"""Github OAuth 回调
"""
code, state, info = OAuthSignIn.get_provider('google').callback()
if code is None:
return 'google 授权失败'
if current_user.is_authenticated:
if _get_user_oauth_state('google') != state:
return '错误的用户，授权失败'
user = UserModel.query.filter_by(google_id=info.get('id')).first()
if user is not None and user.id != current_user.id:
return ' google 帐户已经被绑定过了'
current_user.google_id = info.get('id')
current_user.google_email = info.get('email')
current_user.google_name = info.get('name')
db.session.commit()
return '绑定成功'
else:
user = UserModel.query.filter_by(google_id=info.get('id')).first()
if user is None:
user = UserModel(
google_id=info.get('id'),
google_email=info.get('email'),
google_name=info.get('name'),
)
db.session.add(user)
_login_user(user)
return '登录成功'
def check_session(*args, **kwargs):
from app.models.session import Session
from app.models.user import UserModel
g.user = None
header = current_app.config.get("SESSION_HEADER")
session_id = request.headers.get(header)
session = Session()
session_data = session.read(session_id)
if session_data:
g.user = UserModel(session_id)
g.user.load()
if request.endpoint in ["session", "status"]:
pass
elif request.method == "POST" and request.endpoint == "user":
if not validate_session(session_id):
abort(403)
else:
if not validate_session(session_id):
abort(403)
if request.method in ["POST", "PUT", "PATCH", "DELETE"]:
if request.endpoint == "auth":
pass
elif not g.user or not g.user.get_id():
print("Request denied (no auth)", request.endpoint)
abort(403)
g.session_id = session_id
def delete(self, uuid):
user = UserModel.find_by_uuid(uuid)
if user:
return {"user": user_schema.dump(user)}, 200
return {"message": "No user found"}, 404
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('email', required=True)
parser.add_argument('password', required=True)
parser.add_argument('first_name')
parser.add_argument('last_name')
args = parser.parse_args()
user = UserModel(email=args['email'],
password=args['password'],
first_name=args['first_name'],
last_name=args['last_name'])
db.session.add(user)
try:
db.session.commit()
except Exception as e:
match = duplicate_pattern.search(e.message)
if match:
db.session.rollback()
groups = {
'value': match.group('value'),
'filed': match.group('filed')
}
abort(409,
message="duplicate value '{value}' for key '{filed}'".
format(**groups),
**groups)
_send_activate_email(user.email)
return {'id': user.id}, 201
def search_friend_by_user_id(user_id):
user = UserModel.get_user_data_by_user_id(user_id)
if not user:
abort(404, "This user id not found")
return {"message": "I find that user!"}
def wrapped(*args, **kwargs):
parser = RequestParser()
parser.add_argument('class',
type=str,
help='This field cannot be blank',
required=True)
g.data = data = parser.parse_args()
# check if class is correct type
if data['class'] not in ['people', 'landscape']:
return {'message': 'class field should not be empty'}, 400
# check if event exists
g.event = event = EventModel.query.get(kwargs['event_id'])
if not event:
return {
'message':
'Event id {} does not exist'.format(kwargs['event_id'])
}, 404
# check if current_user has access to the group
username = get_jwt_identity()
g.current_user = current_user = UserModel.find_by_username(
username)
group = GroupModel.query.join(GroupModel.users).filter(
UserModel.username == username,
GroupModel.id == event.group.id).first()
if not group:
return {
'message':
'Group id {} does not exist'.format(kwargs['event_id'])
}, 404
return fn(*args, **kwargs)
def get(self, id):
user = UserModel.get_user_with_id(id)
skip = int(request.args.get('skip', cp.post_list_default_skip))
size = int(request.args.get('size', cp.post_list_default_size))
return [post.json for post in PostModel.list(user, skip, size)]
def post(self):
email = self.request.get('email')
password = self.request.get('password')
current_user = UserModel()
if email and password:
password = base64.b64encode(password)
this_user = current_user.get_user(email)
if this_user.password == password:
user = {
'first_name': this_user.first_name,
'last_name': this_user.last_name,
'email': this_user.email,
'is_admin': this_user.is_admin,
'enterprise': this_user.enterprise,
'is_custom_user': this_user.is_custom_user,
}
self.session['user'] = user
self.redirect('/')
else:
self.redirect('/login/')
else:
self.redirect('/login/')
def post(self):
first_name = self.request.get('first_name')
last_name = self.request.get('last_name')
email = self.request.get('email')
password1 = self.request.get('password1')
password2 = self.request.get('password2')
enterprise = self.request.get('enterprise')
if password1 == password2:
try:
new_user = UserModel()
new_user.first_name = first_name.lower()
new_user.last_name = last_name.lower()
new_user.email = email.lower()
new_user.password = base64.b64encode(password1)
new_user.enterprise = enterprise.lower()
new_user.put()
self.response.write("creado")
except:
self.response.write("Error")
else:
self.redirect('/admin/users/new')
def get(self):
user = None
user = self.session['user']
first_name = self.request.get('first_name')
last_name = self.request.get('last_name')
if first_name and last_name:
update_user = UserModel.get_user(user['email'])
update_user.first_name = first_name
update_user.last_name = last_name
update_user.put()
session_user = {
'first_name': update_user.first_name,
'last_name': update_user.last_name,
'email': update_user.email,
'is_admin': update_user.is_admin,
'enterprise': update_user.enterprise,
'is_custom_user': update_user.is_custom_user,
}
self.session['user'] = session_user
self.response.write({'response': 'ok'})
else:
self.response.write({'response': 'fail'})
def get(self):
user = None
user = self.session['user']
old_pass = self.request.get('old_pass')
new_pass1 = self.request.get('new_pass1')
new_pass2 = self.request.get('new_pass2')
if old_pass and new_pass1 and new_pass2:
update_user = UserModel.get_user(user['email'])
update_user.first_name = first_name
update_user.last_name = last_name
update_user.put()
session_user = {
'first_name': update_user.first_name,
'last_name': update_user.last_name,
'email': update_user.email,
'is_admin': update_user.is_admin,
'enterprise': update_user.enterprise,
'is_custom_user': update_user.is_custom_user,
}
self.session['user'] = session_user
self.response.write({'response': 'ok'})
else:
self.response.write({'response': 'fail'})
def post(self):
export_type = self.request.get("export_type")
if export_type == "export_general_email":
options = self.request.get("options")
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_all_emails_by_dates_async(date_from, date_to, options)
elif export_type == "export_sended_email":
options = self.request.get("options")
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_all_sended_emails_by_dates_async(date_from, date_to, options)
elif export_type == "export_failure_email":
options = self.request.get("options")
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_all_failure_emails_by_dates_async(date_from, date_to, options)
elif export_type == "export_search_by_email":
email = self.request.get("email")
email = str(email).lower()
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_info_by_email_async(date_from, date_to, email)
elif export_type == "export_search_by_folio":
folio = self.request.get("folio")
folio = str(folio).lower()
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
# Consulta
data = EmailModel.get_emails_by_folio_async(folio)
elif export_type == "export_search_by_rut":
rut = self.request.get("rut")
rut = str(rut).upper()
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_emails_by_rut_receptor_async(date_from, date_to, rut)
elif export_type == "export_search_by_failure":
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_all_failure_emails_by_dates_async(date_from, date_to)
elif export_type == "export_search_by_mount":
mount_from = self.request.get("mount_from")
mount_to = self.request.get("mount_to")
mount_from = int(mount_from, base=10)
mount_to = int(mount_to, base=10)
user_email = self.request.get("user_email")
file_name = self.request.get("file_name")
date_from = self.request.get("date_from")
date_to = self.request.get("date_to")
date_from = int(date_from, base=10)
date_to = int(date_to, base=10)
date_from = datetime.datetime.fromtimestamp(date_from)
date_to = datetime.datetime.fromtimestamp(date_to)
# Consulta
data = EmailModel.get_emails_by_mount_async(date_from, date_to, mount_from, mount_to)
# Creación del documento
doc_export = create_tablib_async(data)
# Buscar el objeto usuario
user = UserModel.get_user(user_email)
logging.info(user)
# Proceso de correo
mail = EmailClient()
mail_report = {
"email": user.email,
"user_name": user.first_name,
"subject": REPORT_SUBJECT_MAIL,
"html": REPORT_HTML_MAIL.format(user_name=user.first_name),
"attach": {"name": file_name, "file": doc_export.xlsx},
}
mail.send_mail_to_user_attach(mail_report)
def get(self):
http = decorator.http()
data = user_info_service.userinfo().get().execute(http=http)
users = UserModel.query().fetch()
self.response.write(json.dumps(users))
