def register():
if current_user.is_authenticated:
return redirect(url_for('public.index'))
form = RegisterForm()
error = None
if form.validate_on_submit():
username = form.username.data
email = form.email.data
password = form.password.data
# Comprobamos que no hay ya un usuario con ese email
user = User.get_by_email(email)
if user is not None:
flash(
'El email {} ya está siendo utilizado por otro usuario'.format(
email))
else:
# Creamos el usuario y lo guardamos
user = User(name=username, email=email)
user.set_password(password)
user.save()
# Creo el rol del nuevo usuaricio
usuario_nuevo = User.get_by_email(email)
rol = Role(rolename="user", user_id=usuario_nuevo.id)
rol.save()
# Dejamos al usuario logueado
login_user(user, remember=True)
return redirect(url_for('public.index'))
return render_template("register.html", form=form)
def setUp(self):
self.app = create_app(config.TESTING)
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
self.client = self.app.test_client(use_cookies=True)
def test_new_role(self):
role_id = Role.get_max_id()
self.login()
url = url_for('auth.new_role', _external=True)
data = {
'name': 'test_role',
'description': 'Test Role',
'role_group_id': 1,
'role_group_name':
RoleGroup.get_by(id=RoleGroup.get_max_id()).name,
}
response = self.client.post(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
data=json.dumps(data),
)
response.json = self.get_json_response(response)
new_item = Role.get_by(name=data['name'])
item_url = url_for('auth.get_role',
item_id=new_item.id,
_external=True)
self.assertEqual(response.status_code, 201)
self.assertTrue(response.json['data']['url'] == item_url)
self.assertEqual(new_item.role_group.id, 1)
Role.set_sequence_value(value=role_id)
db.session.delete(new_item)
db.session.commit()
def update():
'''
新增/编辑用户
'''
name = request.json.get('name')
permissions = request.json.get('permissions', 0)
id = request.json.get('id')
if not name:
raise JsonOutputException('请输入用户名');
if not id:
role = Role(
name=name,
permissions=permissions)
msg = '新增成功'
else:
role = Role.query.get_or_404(id)
role.name = name
role.permissions = permissions
msg = '编辑成功'
db.session.add(role)
try:
db.session.commit()
cache.clear()
except IntegrityError:
raise JsonOutputException('该用户名已被使用')
res = {'item': role.to_dict(), 'msg': msg}
return jsonify(res)
def setUp(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
self.client = self.app.test_client(use_cookies=True)
self.test_user = {
'email': '*****@*****.**',
'password': hash_password('cat')
}
def setUp(self):
self.app = create_app(TestConfig)
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client(use_cookies=True)
db.create_all()
db.session.add(models.Stock(name='Test Stock'))
db.session.commit()
Role.insert_roles()
staff = Role.query.filter_by(name='Staff').first()
self.user = User(email='*****@*****.**',
password='******',
role=staff,
confirmed=True)
self.user.role = Role.query.filter_by(name='Staff').first()
def deploy():
app.logger.info('Deploy started')
from flask_migrate import upgrade
app.logger.info('Upgrading database')
upgrade()
app.logger.info('Database upgraded')
app.logger.info('Creating roles and admin user')
from app.auth.models import User, Role
Role.insert_roles()
User.insert_admin()
app.logger.info('Admin user and roles created successfully')
from app.main.models import Stock
Stock.insert_main_stock()
app.logger.info('main stock created successfully')
def addRole():
role_name = request.args.get("role_name")
role = Role.query.filter_by(name = role_name).first()
if role:
return "error"
else:
role = Role(name = role_name)
db.session.add(role)
return "success"
def test_remove_role_from_user(self):
user = self.create_user(name='leito')
role = Role.create_with_role_group_name(name='test',
description='Test',
role_group_name='user')
user.add_role(role_name='test')
self.login()
url = url_for('auth.remove_role_from_user',
item_id=user.id,
role_name=role.name,
_external=True)
response = self.client.delete(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token, ),
)
self.assertEqual(response.status_code, 204)
User.remove_fake(item=user)
Role.remove_fake(item=role)
def test_new_role_existing_role(self):
max_role_id = Role.get_max_id()
self.login()
url = url_for('auth.new_role', _external=True)
data = {
'name': Role.get_by(id=Role.get_max_id()).name,
'description': 'Duplicate Role',
'role_group_id': RoleGroup.get_max_id(),
}
response = self.client.post(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
data=json.dumps(data),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 400)
self.assertTrue(response.json['error'] == 'bad request')
Role.set_sequence_value(value=max_role_id)
def test_remove_role_from_user_doesnt_have_role(self):
self.login()
user = self.create_user(name='leito')
role = Role.create_with_role_group_name(name='test',
description='Test',
role_group_name='user')
url = url_for('auth.remove_role_from_user',
item_id=user.id,
role_name=role.name,
_external=True)
response = self.client.delete(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token, ),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 400)
self.assertTrue(response.json['error'] == 'bad request')
User.remove_fake(item=user)
Role.remove_fake(item=role)
def test_add_role_to_user(self):
user = self.create_user(name='leito')
role = Role.create_with_role_group_name(name='test',
description='Test',
role_group_name='user')
self.login()
url = url_for('auth.add_role_to_user',
item_id=user.id,
role_name=role.name,
_external=True)
response = self.client.post(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token, ),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(response.json['data']['message'])
User.remove_fake(item=user)
Role.remove_fake(item=role)
def test_delete_role(self):
self.login()
role = Role.get_by(name='user')
url = url_for('auth.delete_role', item_id=role.id, _external=True)
response = self.client.delete(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
)
self.assertEqual(response.status_code, 204)
role.set_not_erased()
def test_edit_role_exiting_role(self):
self.login()
role = Role.get_by(name='root')
other_role = Role.get_by(name='user')
url = url_for('auth.edit_role', item_id=role.id, _external=True)
data = {
'name': other_role.name,
'description': "".join([role.description, '_edited']),
'role_group_id': role.role_group_id + 1,
'role_group_name': role.role_group.name,
}
response = self.client.put(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
data=json.dumps(data),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 400)
self.assertTrue(response.json['error'] == 'bad request')
def test_get_role(self):
self.login()
item_id = Role.get_max_id()
url = url_for('auth.get_role', item_id=item_id, _external=True)
response = self.client.get(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json['url'] == url)
self.assertIsNotNone(response.json['data'])
def test_edit_role_no_data(self):
self.login()
role = Role.get_by(name='root')
url = url_for('auth.edit_role', item_id=role.id, _external=True)
data = {}
response = self.client.put(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
data=json.dumps(data),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 400)
self.assertTrue(response.json['error'] == 'bad request')
def test_add_role_to_user_invalid_id(self):
self.login()
invalid_id = User.get_invalid_id()
role = Role.get_by(id=1)
url = url_for('auth.add_role_to_user',
item_id=invalid_id,
role_name=role.name,
_external=True)
response = self.client.post(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token, ),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 404)
self.assertTrue(response.json['error'] == 'not found')
def test_edit_role_invalid_id(self):
self.login()
invalid_id = Role.get_invalid_id()
url = url_for('auth.edit_role', item_id=invalid_id, _external=True)
data = {
'name': 'role_to_edit',
'description': 'Edited Role',
'role_group_id': 1,
}
response = self.client.put(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
data=json.dumps(data),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 404)
self.assertTrue(response.json['error'] == 'not found')
def test_edit_role(self):
self.login()
role = Role.get_by(id=1)
url = url_for('auth.edit_role', item_id=role.id, _external=True)
data = {
'name': "".join([role.name, '_edited']),
'description': "".join([role.description, '_edited']),
'role_group_id': role.role_group_id + 1,
'role_group_name': role.role_group.name,
}
response = self.client.put(
url,
content_type=self.JSON,
headers=self.set_api_headers(token=self.auth_token),
data=json.dumps(data),
)
response.json = self.get_json_response(response)
self.assertEqual(response.status_code, 200)
item_url = url_for('auth.get_role', item_id=role.id, _external=True)
self.assertTrue(response.json['data']['url'] == item_url)
role.name, _ = role.name.split('_')
role.description, _ = role.description.split('_')
role.role_group_id -= 1
db.session.commit()
def install():
from sqlalchemy import text
import csv
from config import basedir
import platform
from app import db
from .models import CoreCity, CoreProvince
from app.auth.models import Role, RolePermission
print("Installing...")
if platform.system() == "Windows":
provinces_path = basedir + "\\app" + "\\core" + "\\csv" + "\\provinces.csv"
cities_path = basedir + "\\app" + "\\core" + "\\csv" + "\\cities.csv"
elif platform.system() == "Linux":
provinces_path = basedir + "/app/core/csv/provinces.csv"
cities_path = basedir + "/app/core/csv/cities.csv"
else:
raise Exception
print("Inserting provinces to database...")
if CoreProvince.query.count() < 88:
with open(provinces_path) as f:
csv_file = csv.reader(f)
for id, row in enumerate(csv_file):
if not id == 0:
province = CoreProvince()
province.id = int(row[0])
province.name = row[2]
db.session.add(province)
db.session.commit()
print("Provinces done!")
else:
print("Provinces exists!")
print("")
print("Inserting cities to database...")
if CoreCity.query.count() < 1647:
with open(cities_path) as f:
csv_file = csv.reader(f)
for id, row in enumerate(csv_file):
if not id == 0:
city = CoreCity()
city.id = int(row[0])
city.name = row[2]
city.province_id = None
db.session.add(city)
db.session.commit()
print("Cities done!")
else:
print("Cities exists!")
print("Inserting system roles...")
if Role.query.count() > 0:
print("Role already inserted!")
else:
role = Role()
role.name = "Individual"
db.session.add(role)
db.session.commit()
print("Individual role inserted!")
print("Create a SuperUser/owner...")
_create_superuser()
print("Installation complete!")
db.session.add(c_arte)
db.session.add(q_Laos)
db.session.add(q_Armenia)
db.session.add(q_mundial)
db.session.add(q_guerra)
db.session.add(q_pintura)
db.session.add(r_Laos1)
db.session.add(r_Laos2)
db.session.add(r_Laos3)
db.session.add(r_Armenia1)
db.session.add(r_Armenia2)
db.session.add(r_Armenia3)
db.session.add(r_mundial1)
db.session.add(r_mundial2)
db.session.add(r_mundial3)
db.session.add(r_guerra1)
db.session.add(r_guerra2)
db.session.add(r_guerra3)
db.session.add(r_pintura1)
db.session.add(r_pintura2)
db.session.add(r_pintura3)
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add_all([
Role(rolename='admin', user=u1),
Role(rolename='user', user=u1),
Role(rolename='user', user=u2)
])
db.session.commit()
def initdb():
"""
Initialize the database on the first run
"""
db.create_all()
Role.insert_roles()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from app import db
from app.auth.models import User, Role
# agregamos 2 usuarios
u1 = User(name='administrador', email='*****@*****.**', menor_tiempo=None)
u2 = User(name='Jaimito', email='*****@*****.**', menor_tiempo=None)
u1.set_password("345678")
u2.set_password("456789")
db.session.add_all([u1, u2])
db.session.commit()
u3 = User.query.filter_by(email="*****@*****.**").first()
u4 = User.query.filter_by(email="*****@*****.**").first()
u5 = User.query.filter_by(email="*****@*****.**").first()
db.session.add_all([
Role(rolename='admin', user=u1),
Role(rolename='user', user=u1), # multiples roles
Role(rolename='user', user=u2),
Role(rolename='user', user=u3),
Role(rolename='user', user=u4),
Role(rolename='admin', user=u5)
])
db.session.commit()
def setUp(self):
super().setUp()
Role.insert_roles()
self.user = User(email="*****@*****.**", password='******')
self.admin_role = Role.query.filter_by(name="Administrator").first()
self.user_role = Role.query.filter_by(name="User").first()
