def save_new_user(data):
user = User.query.filter_by(email=data['email']).first()
if not user:
new_user = User(public_id=str(uuid.uuid4()),
email=data['email'],
username=data['username'],
password=data['password'],
registered_on=datetime.datetime.utcnow())
save_changes(new_user)
return generate_token(new_user)
else:
response_object = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return response_object, 409
def generate_token(user):
try:
# generate the auth token
auth_token = User.encode_auth_token(user.id)
response_object = {
'status': 'success',
'message': 'Successfully registered.',
'Authorization': auth_token.decode()
}
return response_object, 201
except Exception as e:
response_object = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return response_object, 401
def user_sign_up(data):
try:
if User.username_exists(data["username"]):
return Response(mimetype="application/json",
response=json.dumps(
{'error': "Username already exists"}),
status=403)
if User.email_exists(data["email"]):
return Response(mimetype="application/json",
response=json.dumps(
{'error': "email already exists"}),
status=403)
password_hash = User.generate_hash_password(data["password"])
new_user = User(username=data["username"],
name=data["name"],
email=data["email"],
password=password_hash)
new_user.save()
# # Now we'll send the email confirmation link
# subject = "Confirm your email"
# token = ts.dumps(self.email, salt='email-confirm-key')
# confirm_url = url_for(
# 'confirm_email',
# token=token,
# _external=True)
# html = render_template(
# 'email/activate.html',
# confirm_url=confirm_url)
# # We'll assume that send_email has been defined in myapp/util.py
# send_email(user.email, subject, html)
return Response(mimetype="application/json",
response=json.dumps(
{'success': "User created successfully"}),
status=201)
except Exception as e:
error_msg = get_error_msg(e)
logger.error(error_msg)
return Response(mimetype="application/json",
response=json.dumps({'error': error_msg}),
status=400)
def get_menu_list(page_path=None, page_exist=False, editable=True):
items = []
if User.is_logged_in():
if page_path is not None and editable:
# FIXME: 수정해야함
base_url = 'note'
url = f'/{base_url}/{page_path}/edit'
if page_exist:
items.append({'type': 'edit', 'url': url, 'label': '편집'})
else:
items.append({'type': 'write', 'url': url, 'label': '작성'})
items.append({'type': 'list', 'url': '/note', 'label': '목록'})
items.append({'type': 'tag', 'url': '/tags', 'label': '태그'})
items.append({'type': 'config', 'url': '/config', 'label': '설정'})
items.append({'type': 'logout', 'url': '/logout', 'label': '로그아웃'})
else:
items.append({'type': 'list', 'url': '/note', 'label': '목록'})
items.append({'type': 'tag', 'url': '/tags', 'label': '태그'})
items.append({'type': 'login', 'url': '/login', 'label': '로그인'})
return items
def get(self):
auth = request.authorization
if not auth or not auth.username or not auth.password:
return make_response(
{'message': 'Could not verify'},
401,
{
'WWW-Authenticate': 'Basic realm="Login required!"'
}
)
user = User.query.filter_by(email=auth.username).first()
if not user:
return make_response(
{'message': 'Could not verify'},
401,
{
'WWW-Authenticate': 'Basic realm="Login required!"'
}
)
if User.verify_password(user.password, auth.password):
token = jwt.encode({
'uuid': user.uuid,
'exp': datetime.datetime.utcnow()
+ datetime.timedelta(minutes=30)
}, current_app.config['SECRET_KEY'])
return {'token': token.decode('utf-8')}
return make_response(
{'message': 'Could not verify'},
401,
{
'WWW-Authenticate': 'Basic realm="Login required!"'
}
)
def update_atom(atom_items, build_date):
config = Config.get()
user = User.get_user_info()
atom = ''
atom += XML_Declaration
atom += f'<feed xmlns="http://www.w3.org/2005/Atom">\n'
atom += f' <title>{config["note_title"]}</title>\n'
atom += f' <subtitle>{config["note_subtitle"]}</subtitle>\n'
atom += f' <author>\n'
atom += f' <name>{user["name"]}</name>\n'
atom += f' <email>{user["email"]}</email>\n'
atom += f' </author>\n'
atom += f' <updated>{build_date}</updated>\n'
atom += f' <id>{config["url"]}/</id>\n'
atom += f' <link rel="alternate" href="{config["url"]}" />\n'
atom += f' <link rel="self" href="{config["url"]}/atom" />\n'
atom += f' <generator>ipari-note</generator>'
atom += atom_items
atom += f'</feed>'
path = os.path.join(current_app.instance_path, 'atom.xml')
with open(path, 'w', encoding='utf-8') as f:
f.write(atom)
def save_new_user(json_body):
username = json_body.get("username")
email = json_body.get("email")
password = json_body.get("password")
password_confirm = json_body.get("password_confirm")
if not username or not password or not password_confirm:
return ResponseReturnKit.error400("Required field missing")
if any(list(StringKit.password_check(password).values())):
return ResponseReturnKit.error400(
"""A password is considered strong if: 6 characters length or more and 1 digit or more and 1 symbol or more and 1 uppercase letter or more and 1 lowercase letter or more"""
)
if password_confirm != password:
return ResponseReturnKit.error400("Password is not matching")
find_user = User.query.filter_by(username=username).first()
if find_user and not find_user.confirmed:
return ResponseReturnKit.error400("User already exists")
if find_user and find_user.confirmed:
return ResponseReturnKit.error400("User or password invalid")
if not ValidateKit.validate_email(email):
return ResponseReturnKit.error400("Email is invalid")
user = User(username=username)
if email:
user.email = email
user.hash_password(password)
user.registered_on = datetime.datetime.now()
db.session.add(user)
db.session.commit()
token = StringKit.generate_confirmation_token(user.username)
confirm_url = url_for('confirm_email', token=token, _external=True)
return {"url": confirm_url}, 201
def create_new_user(data):
try:
print("=" * 80, "Creating New User:"******"\n")
user = User.get_user_via_email(data['email'])
if (user):
print("User already exists")
print("=" * 80)
return Response(mimetype="application/json",
response=json.dumps({'error': 'user exsists'}),
status=403)
hashed_password = User.generate_hash_password(data['password'])
new_user = User(username=data['username'],
email=data['email'],
password=hashed_password)
new_user.save()
print("New User Created", "=" * 80, sep="\n")
return Response(mimetype="application/json",
response=json.dumps({'success': "New User Created"}),
status=201)
except Exception as e:
return Response(mimetype="application/json",
response=json.dumps({'error': str(e)}),
status=400)
def _create_test_users(self):
# admin user and role
admin_role = Role(name=self.ADMIN_ROLE)
admin_role.save()
admin_user = User(
name=self.ADMIN_USER,
password=self.encode_password(self.ADMIN_PW),
is_active=True,
# user_id=self._user_gen_id()
)
admin_user.save()
admin_user.permissions.add(admin_role)
# admin_user.save()
self._users[self.ADMIN_USER] = admin_user
# regular user
regular_user = User(
name=self.REGULAR_USER,
password=self.encode_password(self.REGULAR_PW),
is_active=True,
# user_id=self._user_gen_id()
)
regular_user.save()
self._users[self.REGULAR_USER] = regular_user
# regular secondary user
regular_user = User(
name=self.REGULAR_ALT_USER,
password=self.encode_password(self.REGULAR_ALT_PW),
is_active=True,
# user_id=self._user_gen_id()
)
regular_user.save()
self._users[self.REGULAR_ALT_USER] = regular_user
# inactive user
inactive_user = User(
name=self.INACTIVE_USER,
password=self.encode_password(self.INACTIVE_PW),
is_active=False,
# user_id=self._user_gen_id()
)
inactive_user.save()
self._users[self.INACTIVE_USER] = inactive_user
pass
#!env/bin/python
from app.user.model import User
from app.group.model import Group
group = Group('admin', 'grupo dos administradores')
group.add(group)
user = User('clodonil', '*****@*****.**', '(11)97987987987')
user.add(user, group.titulo)
user.group_add(user, group)
user.status = 3
user.update()
def fetch_all_items(self):
return User.select(
User
).where(
User.is_deleted == False,
).objects()
def check_permission(permission=Permission.PRIVATE, from_encrypted_path=False):
if permission == Permission.PUBLIC or User.is_logged_in():
return True
if permission == Permission.LINK_ACCESS and from_encrypted_path:
return True
return False
def test_topic(self):
user = User.new(username='******', password='******', email='*****@*****.**')
topic = Topic.new(user_id=user.id, title='开心呢', content="哈哈")
self.assertEqual(user.id, topic.user_id)
def read_item(self, item_id):
item = User.get(User.id == item_id, User.is_deleted == False)
return item
def view_update():
if User.is_logged_in():
update_all()
return redirect('/')
return error_page(page_path=None, message='로그인이 필요합니다.')
def get_permission():
if User.is_logged_in():
return Permission.PRIVATE
return Permission.PUBLIC
#!env/bin/python
from app.user.model import User
from app.group.model import Group
group = Group('admin','grupo dos administradores')
group.add(group)
user = User('clodonil','*****@*****.**','(11)97987987987')
user.add(user, group.titulo)
user.group_add(user, group)
user.status = 3
user.update()
def make_user(self, data, **kwargs):
return User(**data)
def user_logout():
User.logout()
return redirect(request.referrer)
def create(data: dict) -> User:
return save(User(id=str(uuid4()), login=data['login'], senha=data['senha']))
def test_user(test_app, test_db):
user = User(email="*****@*****.**", password="******", name="test")
expected = {"name": "Test", "email": "*****@*****.**"}
response = create(test_db, user)
assert response == expected
