def preload():
user_manager = UserManager(app, db, User)
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='admin'))
db.session.add(user)
db.session.commit()
for role in ROLES:
if not Role.query.filter(Role.name == role).first():
r = Role(name=role)
db.session.add(r)
db.session.commit()
def init_user_manager(app):
from flask_user import SQLAlchemyAdapter, UserManager
from ..core import db
from ..model import User
from ..service import userService
from .. import signals
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter)
user_manager.init_app(app)
import hashlib
def hash_password(self, password):
_md5 = hashlib.md5()
_md5.update(password)
return _md5.hexdigest()
def generate_password_hash(self, password):
_md5 = hashlib.md5()
_md5.update(password)
return _md5.hexdigest()
def verify_password(self, password, user):
return self.hash_password(password) == user.password
def login_manager_usercallback(user_id):
user_id = int(user_id) if isinstance(user_id,
basestring) else int(user_id)
user_dict = userService.user_by_id(user_id)
return User(**user_dict)
user_manager.hash_password = hash_password.__get__(user_manager,
UserManager)
user_manager.generate_password_hash = generate_password_hash.__get__(
user_manager, UserManager)
user_manager.verify_password = verify_password.__get__(
user_manager, UserManager)
user_manager.login_manager.user_callback = login_manager_usercallback
def create_app(first_time=False):
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
api = Api(app)
# Initialize Flask-SQLAlchemy
db = SQLAlchemy(app)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
username = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
db.create_all()
user_manager = UserManager(app, db, User)
## member_page template
@app.route('/members')
@login_required
def member_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>Members page</h2>
<p><a href={{ url_for('user.register') }}>Register</a></p>
<p><a href={{ url_for('user.login') }}>Sign in</a></p>
<p><a href={{ url_for('home_page') }}>Home page</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>Member page</a> (login required)</p>
<p><a href={{ url_for('user.logout') }}>Sign out</a></p>
{% endblock %}
""")
## home_page template
@app.route('/')
def home_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>Home page</h2>
<p><a href={{ url_for('user.register') }}>Register</a></p>
<p><a href={{ url_for('user.login') }}>Sign in</a></p>
<p><a href={{ url_for('home_page') }}>Home page</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>Member page</a> (login required)</p>
<p><a href={{ url_for('user.logout') }}>Sign out</a></p>
{% endblock %}
""")
if first_time:
try:
admin_role = Role(name='Admin')
user1 = User(username='******',
active=True,
password=user_manager.hash_password('Password1'))
user2 = User(username='******',
active=True,
password=user_manager.hash_password('Password2'))
user1.roles = [
admin_role,
]
db.session.add(admin_role)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
except exc.IntegrityError:
pass
## attaching the url to view
from views import MovieViewset, AllMoviesViewset
api.add_resource(MovieViewset, '/movie/<int:movie_id>')
api.add_resource(AllMoviesViewset, '/allmovies')
return app
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask-SQLAlchemy
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
username = db.Column(db.String(255, collation='NOCASE'), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(), db.ForeignKey('roles.id', ondelete='CASCADE'))
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.username == 'member').first():
user = User(
username='******',
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.username == 'admin').first():
user = User(
username='******',
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Home page{%endtrans%}</h2>
<p><a href={{ url_for('user.register') }}>{%trans%}Register{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Sign in{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Home Page{%endtrans%}</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Member Page{%endtrans%}</a> (login_required: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin Page{%endtrans%}</a> (role_required: [email protected] / Password1')</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def member_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Members page{%endtrans%}</h2>
<p><a href={{ url_for('user.register') }}>{%trans%}Register{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Sign in{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Home Page{%endtrans%}</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Member Page{%endtrans%}</a> (login_required: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin Page{%endtrans%}</a> (role_required: [email protected] / Password1')</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The Admin page requires an 'Admin' role.
@app.route('/admin')
@roles_required('Admin') # Use of @roles_required decorator
def admin_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Admin Page{%endtrans%}</h2>
<p><a href={{ url_for('user.register') }}>{%trans%}Register{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Sign in{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Home Page{%endtrans%}</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Member Page{%endtrans%}</a> (login_required: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin Page{%endtrans%}</a> (role_required: [email protected] / Password1')</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
return app
def __init__(self, musteriId, urunId, siparisno, siparisTarihi, odemeId):
self.musteriId = musteriId
self.urunId = urunId
self.siparisno = siparisno
self.siparisTarihi = siparisTarihi
self.odemeId = odemeId
user_manager = UserManager(app, db, Kullanici)
db.create_all()
if not Kullanici.query.filter(Kullanici.email == request.form['email']).first():
kullanici = Kullanici(
email=request.form['email'],
tarih=datetime.datetime.utcnow(),
sifre=user_manager.hash_password(request.form['sifre']),
)
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not Kullanici.query.filter(Kullanici.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
@app.route('/')
def anasayfa():
return render_template('index.html')
def __init__(self, musteriId, urunId, siparisno, siparisTarihi, odemeId):
self.musteriId = musteriId
self.urunId = urunId
self.siparisno = siparisno
self.siparisTarihi = siparisTarihi
self.odemeId = odemeId
user_manager = UserManager(app, db, Kullanici)
db.create_all()
if not Kullanici.query.filter(Kullanici.email == request.form['email']).first():
kullanici = Kullanici(
email=request.form['email'],
tarih=datetime.datetime.utcnow(),
sifre=user_manager.hash_password(request.form['sifre']),
)
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not Kullanici.query.filter(Kullanici.email == '*****@*****.**').first():
kullanici = Kullanici(
email='*****@*****.**',
tarih=datetime.datetime.utcnow(),
sifre=user_manager.hash_password('admin'),
)
@app.route('/')
def anasayfa():
return render_template('index.html')
def init_app(app, test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
babel = Babel(app) # Initialize Flask-Babel
mail = Mail(app) # Initialize Flask-Mail
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db,
User,
UserInvitationClass=UserInvitation)
user_manager = UserManager(db_adapter, app)
# Create regular 'member' user
if not User.query.filter(User.username == 'member').first():
user = User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('Password1'),
confirmed_at=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username == 'user007').first():
user1 = User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('Password1'))
user1.roles.append(Role(name='secret'))
user1.roles.append(Role(name='agent'))
db.session.add(user1)
db.session.commit()
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Home Page{%endtrans%}</h2>
<p><a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a></p>
{% endblock %}
""")
# The '/profile' page requires a logged-in user
@app.route('/user/profile')
@login_required # Use of @login_required decorator
@confirm_email_required
def user_profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Profile Page{%endtrans%}</h2>
<p> {%trans%}Hello{%endtrans%}
{{ current_user.username or current_user.email }},</p>
<p> <a href="{{ url_for('user.change_username') }}">
{%trans%}Change username{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_password') }}">
{%trans%}Change password{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.invite') }}">
{%trans%}Invite User{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The '/special' page requires a user that has the 'special' AND ('sauce' OR 'agent') role.
@app.route('/special')
@roles_required('secret',
['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Special Page{%endtrans%}</h2>
{% endblock %}
""")
# For testing only
app.db = db
app.UserEmailClass = UserEmail
return app
def init_user_manager(app):
from flask_user import SQLAlchemyAdapter, UserManager
from ..core import db, FromCache
from ..models import Account
from .user_login import login
from .user_register import register
from .user_forgot_password import forgot_password
from ..tasks import send_email
import hashlib
from flask.ext.wtf import Form
from wtforms import BooleanField, HiddenField, PasswordField, SubmitField, StringField
from wtforms import validators, ValidationError
def hash_password(self, password):
_md5 = hashlib.md5()
_md5.update(password)
return _md5.hexdigest()
def generate_password_hash(self, password):
_md5 = hashlib.md5()
_md5.update(password)
return _md5.hexdigest()
def verify_password(self, password, user):
return self.hash_password(password) == user.password
def login_manager_usercallback(account_id):
account_id = int(account_id) if isinstance(account_id, basestring) else account_id
account = db.session.query(Account). \
options(FromCache('model', 'account:%d' % account_id)). \
filter(Account.id == account_id).first()
return account
def password_validator(form, field):
""" Password must have one lowercase letter, one uppercase letter and one digit."""
# Convert string to list of characters
password = list(field.data)
password_length = len(password)
# Count lowercase, uppercase and numbers
lowers = uppers = digits = 0
for ch in password:
if ch.islower(): lowers += 1
if ch.isupper(): uppers += 1
if ch.isdigit(): digits += 1
# Password must have one lowercase letter, one uppercase letter and one digit
is_valid = password_length >= 6 and lowers and uppers and digits
if not is_valid:
raise ValidationError(u'密码至少超过6位,其中要求包含一个大写字母,一个小写字母和一个数字')
class ResetPasswordForm(Form):
new_password = PasswordField(u'新密码', validators=[validators.Required(u'新密码不能为空')])
retype_password = PasswordField(u'再次输入新密码', validators=[
validators.EqualTo('new_password', message=u'两次输入的新密码匹配')])
next = HiddenField()
submit = SubmitField(u'修改密码')
def validate(self):
# Use feature config to remove unused form fields
user_manager = current_app.user_manager
if not user_manager.enable_retype_password:
delattr(self, 'retype_password')
# Add custom password validator if needed
has_been_added = False
for v in self.new_password.validators:
if v == user_manager.password_validator:
has_been_added = True
if not has_been_added:
self.new_password.validators.append(user_manager.password_validator)
# Validate field-validators
if not super(ResetPasswordForm, self).validate():
return False
# All is well
return True
def async_send_email(recipient, subject, html_message, text_message):
send_email.delay(recipient, subject, html_message, text_message)
db_adapter = SQLAlchemyAdapter(db, Account)
user_manager = UserManager(db_adapter, login_view_function=login, register_view_function=register,
forgot_password_view_function=forgot_password,
reset_password_form=ResetPasswordForm, password_validator=password_validator,
send_email_function=async_send_email)
user_manager.init_app(app)
user_manager.hash_password = hash_password.__get__(user_manager, UserManager)
user_manager.generate_password_hash = generate_password_hash.__get__(user_manager, UserManager)
user_manager.verify_password = verify_password.__get__(user_manager, UserManager)
user_manager.login_manager.user_callback = login_manager_usercallback
orig_unauthenticated_view_function = user_manager.unauthenticated_view_function
def unauthenticated_view_function():
if request.is_xhr:
return jsonify({'success': False, 'error_code': errors.user_unauthenticated})
else:
return orig_unauthenticated_view_function()
setattr(user_manager, 'unauthenticated_view_function', unauthenticated_view_function)
orig_unauthorized_view_function = user_manager.unauthorized_view_function
def unauthorized_view_function():
if request.is_xhr:
return jsonify({'success': False, 'error_code': errors.operation_unauthorized})
else:
return orig_unauthorized_view_function()
setattr(user_manager, 'unauthorized_view_function', unauthorized_view_function)
def init_app(app, test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app.config.from_object(__name__+'.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try: app.config.from_object('local_settings')
except: pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
babel = Babel(app) # Initialize Flask-Babel
mail = Mail(app) # Initialize Flask-Mail
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User, UserInvitationClass=UserInvitation)
user_manager = UserManager(db_adapter, app)
# Create regular 'member' user
if not User.query.filter(User.username=='member').first():
user = User(username='******', email='*****@*****.**', active=True,
password=user_manager.hash_password('Password1'), confirmed_at=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username=='user007').first():
user1 = User(username='******', email='*****@*****.**', active=True,
password=user_manager.hash_password('Password1'))
user1.roles.append(Role(name='secret'))
user1.roles.append(Role(name='agent'))
db.session.add(user1)
db.session.commit()
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Home Page{%endtrans%}</h2>
<p><a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a></p>
{% endblock %}
""")
# The '/profile' page requires a logged-in user
@app.route('/user/profile')
@login_required # Use of @login_required decorator
@confirm_email_required
def user_profile_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Profile Page{%endtrans%}</h2>
<p> {%trans%}Hello{%endtrans%}
{{ current_user.username or current_user.email }},</p>
<p> <a href="{{ url_for('user.change_username') }}">
{%trans%}Change username{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.change_password') }}">
{%trans%}Change password{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.invite') }}">
{%trans%}Invite User{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The '/special' page requires a user that has the 'special' AND ('sauce' OR 'agent') role.
@app.route('/special')
@roles_required('secret', ['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>{%trans%}Special Page{%endtrans%}</h2>
{% endblock %}
""")
# For testing only
app.db = db
app.UserEmailClass = UserEmail
return app
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try: app.config.from_object('local_settings')
except: pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
mail = Mail(app) # Initialize Flask-Mail
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
User, Role, UserRoles, Posts = create_models(db)
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username=='admin').first():
user1 = User(username='******', email='*****@*****.**', active=True,
password=user_manager.hash_password('password'))
user1.roles.append(Role(name='admin'))
db.session.add(user1)
db.session.commit()
if len(Posts.query.all()) == 0:
post = Posts(user_id=3, title='hello world', content='this is a test post to test the query')
db.session.add(post)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
@login_required
def home_page():
# posts = get_posts(db)
posts = Posts.query.all()
return render_template('main.html', posts=posts)
@app.route('/post', methods=['GET', 'POST'])
def new_post():
if request.method == 'GET':
return render_template('post_form.html')
elif request.method == 'POST':
form = request.form
post = Posts(user_id=session['user_id'], title=form['title'], content=form['content'])
db.session.add(post)
db.session.commit()
flash('post successful')
return redirect(url_for('home_page'))
# The Special page requires a user with 'special' and 'sauce' roles or with 'special' and 'agent' roles.
@app.route('/admin')
@roles_required('admin') # Use of @roles_required decorator
def special_page():
return 'this isn\'t done yet'
return app
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__, static_url_path='/static')
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255), nullable=False, unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100), nullable=False, server_default='')
last_name = db.Column(db.String(100), nullable=False, server_default='')
gender = db.Column(db.String(100), nullable=False, server_default='')
birthday = db.Column(db.Date,server_default="1990/12/10")
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(), db.ForeignKey('roles.id', ondelete='CASCADE'))
class Country(db.Model):
__tablename__ = 'country'
abbreviation_fips = db.Column(db.String(5), nullable=False, server_default='',primary_key=True)
name = db.Column(db.String(100),nullable=False)
class City(db.Model):
__tablename__ = 'city'
id = id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False)
country_abbreviation_fips = db.Column(db.String(5), db.ForeignKey('country.abbreviation_fips', ondelete='CASCADE'))
class Preference(db.Model):
__tablename__= 'preference'
id = db.Column(db.Integer(), primary_key=True)
user_id= db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
city_id= db.Column(db.Integer, db.ForeignKey('city.id', ondelete='CASCADE'))
field_id= db.Column(db.Integer, db.ForeignKey('field.id', ondelete='CASCADE'))
class Field(db.Model):
__tablename__= 'field'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False)
class Position(db.Model):
__tablename__='position'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False)
start_date = db.Column(db.Date, server_default="2019/10/10", nullable = False)
salary = db.Column(db.Integer(), nullable=False)
description = db.Column(db.String(100), nullable = False)
field_id= db.Column(db.Integer, db.ForeignKey('field.id', ondelete='CASCADE'))
group_id= db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
class Experience(db.Model):
__tablename__ = 'experience'
id = db.Column(db.Integer, primary_key=True)
user_id= db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
description= db.Column(db.String(1000), nullable=True, server_default='Write a short description of your experience.')
class Education(db.Model):
__tablename__ = 'education'
id = db.Column(db.Integer, primary_key=True)
degree = db.Column(db.Integer, db.ForeignKey('degree.id', ondelete='CASCADE'))
degree_field = db.Column(db.Integer, db.ForeignKey('degreefield.id', ondelete='CASCADE'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
class UserHasEducation(db.Model):
__tablename__ = 'user_has_education'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
education_id = db.Column(db.Integer, db.ForeignKey('education.id', ondelete='CASCADE'))
class PI(db.Model):
__tablename__ = 'pi'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
surname = db.Column(db.String(50), nullable=False)
group_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE'))
class Institution(db.Model):
__tablename__ = 'institution'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False )
link= db.Column(db.String(100), nullable=False)
city= db.Column(db.String(50), nullable=False)
class InstitutionHasGroup(db.Model):
__tablename__ = 'institution_has_group'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
institution_id = db.Column(db.Integer, db.ForeignKey('institution.id', ondelete='CASCADE'))
class Requests(db.Model):
__tablename__ = 'requests'
id = db.Column(db.Integer(), primary_key=True)
applicant_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE'))
position_id = db.Column(db.Integer(), db.ForeignKey('position.id', ondelete='CASCADE'))
status = db.Column(db.String(50), nullable=False)
class Requirement(db.Model):
__tablename__="requirement"
id = db.Column(db.Integer(), primary_key=True)
degree = db.Column(db.Integer(), db.ForeignKey('degree.id', ondelete='CASCADE'))
degree_field = db.Column(db.Integer(), db.ForeignKey('degreefield.id', ondelete='CASCADE'))
position_id = db.Column(db.Integer(), db.ForeignKey('position.id', ondelete='CASCADE'))
class Message(db.Model):
__tablename__='message'
id = db.Column(db.Integer(), primary_key=True)
message = db.Column(db.String(500), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
group_id= db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
class Degree(db.Model):
__tablename__="degree"
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False )
class DegreeField(db.Model):
__tablename__="degreefield"
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False )
user_manager = UserManager(app, db, User, RoleClass=Role,UserRolesClass=UserRoles,
PositionClass=Position, UserHasEducationClass = UserHasEducation,
PIClass = PI, InstitutionClass = Institution,
InstitutionHasGroupClass = InstitutionHasGroup ,
EducationClass = Education, ExperienceClass= Experience,
CityClass=City, CountryClass= Country, RequestsClass=Requests,
FieldClass = Field, PreferenceClass = Preference,
DegreeClass = Degree,
DegreeFieldClass = DegreeField,
RequirementClass = Requirement, MessageClass = Message)
db.create_all()
# if not Position.query.filter(Position.name == 'Bioinformatics Technician').first():
# pos1 = Position(name = "Bioinformatics Technician", salary =1000, start_date="2019/10/10" ,description ="A cool job!")
# db.session.add(pos1)
# db.session.commit()
if not DegreeField.query.filter(DegreeField.name == 'Bioinformatics').first():
degree = DegreeField(name = "None")
degree1 = DegreeField(name = "Bioinformatics")
degree2 = DegreeField(name = "Biology")
degree3 = DegreeField(name = "Computer Science")
db.session.add(degree)
db.session.add(degree1)
db.session.add(degree2)
db.session.add(degree3)
db.session.commit()
if not Degree.query.filter(Degree.name == 'Bachelor').first():
none_degree = Degree(name = "None")
bachelor = Degree(name = "Bachelor")
master = Degree(name = "Master")
phd = Degree(name = "PhD")
postdoc = Degree(name = "PostDoc")
db.session.add(none_degree)
db.session.add(bachelor)
db.session.add(master)
db.session.add(phd)
db.session.add(postdoc)
db.session.commit()
if not Field.query.filter(Field.name == 'Structural Bioinformatics').first():
field = Field(name = "Structural Bioinformatics")
field2= Field(name= "Comparative Bioinformatics")
field3= Field(name= "System Biology")
field4= Field(name= "Cancer Genomics")
field5= Field(name= "Evolutionary Genomics")
field6= Field(name= "Other")
db.session.add(field)
db.session.add(field2)
db.session.add(field3)
db.session.add(field4)
db.session.add(field5)
db.session.add(field6)
db.session.commit()
if not City.query.filter(City.name == 'Barcelona').first():
country = Country(abbreviation_fips = "SP", name ="Spain")
city = City(name = "Barcelona", country_abbreviation_fips = "SP")
city2 = City(name = "Madrid", country_abbreviation_fips = "SP")
city3 = City(name = "Valencia", country_abbreviation_fips = "SP")
city4 = City(name = "Bilbao", country_abbreviation_fips = "SP")
city5 = City(name = "Sevilla", country_abbreviation_fips = "SP")
db.session.add(city)
db.session.add(city2)
db.session.add(city3)
db.session.add(city4)
db.session.add(city5)
db.session.add(country)
db.session.commit()
#Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
gender = "F"
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
if not Role.query.filter(Role.name == 'Applicant').first():
role = Role (name = "Applicant")
role2 = Role( name ="Group")
db.session.add(role)
db.session.add(role2)
db.session.commit()
@app.route('/scimatch')
def home_page():
role_name ="Guest"
if current_user is None:
return render_template("/home_page.html")
if not current_user.is_authenticated:
return render_template("/home_page.html")
else:
role_id = UserRoles.query.filter_by( user_id = current_user.id).first().role_id
role_name = Role.query.filter_by( id = role_id).first().name
if role_name == "Applicant":
matches = Position.query.order_by(Position.name).all()
return redirect(url_for('user.home_page_applicant'))
#return render_template("/home_page_applicant.html",matches=matches, role=role_name)
elif role_name == "Group":
positions = Position.query.filter_by(group_id = current_user.id).all()
return redirect(url_for('user.home_page_group'))
#return render_template("/home_page_group.html",role=role_name, positions = positions)
def who():
return render_template("/who.html")
app.add_url_rule('/scimatch/who', 'who', who)
def why():
return render_template("/why.html")
app.add_url_rule('/scimatch/why', 'why', why)
def change_pref():
dropdown_list = City.query.order_by(City.name).all()
return render_template("/scimatch/change_pref.html",dropdown_list = dropdown_list)
def profile_applicant():
return render_template("/profile_applicant.html")
app.add_url_rule('/scimatch/profile_applicant', 'profile_applicant', profile_applicant)
# def chat_applicant():
# return render_template("/chat_applicant.html")
# app.add_url_rule('/scimatch/chat_applicant', 'chat_applicant', chat_applicant)
return app
def create_app():
""" Flask application factory """
# Flask yaratılmıştır ve uygulama ismi verilmiştir.
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
#Tarih saat ve metin oluşturma işlemleri için Babel Kütüphanesi kullanılmıştır.
babel = Babel(app)
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
db = SQLAlchemy(app)
# User Class oluşturulmuştur.
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
email = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
roles = db.relationship('Role', secondary='user_roles')
# Rezervasyon Tablosu tanımlanmıştır.
class Rezervation(db.Model):
__tablename__ = 'rezervation'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
flight_id = db.Column(db.Integer())
tarih = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow())
name = db.Column(db.String(50))
last_name = db.Column(db.String(50))
phone = db.Column(db.Integer())
number = db.Column(db.Integer())
ticket = db.Column(db.Integer())
toplam = db.Column(db.Float())
asiltutar = db.Column(db.Float())
bonus = db.Column(db.Float())
#Flight Tablosu tanımlanmıştır.
class Flight(db.Model):
__tablename__ = 'flight'
id = db.Column(db.Integer(), primary_key=True)
ucus_id = db.Column(db.Integer())
departure = db.Column(db.String(25))
landing = db.Column(db.String(25))
tarih = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow())
users_id = db.Column(db.Integer())
empty_seat = db.Column(db.Float())
full_seat = db.Column(db.Float())
ticket = db.Column(db.Integer())
bonus = db.Column(db.Float())
oran = db.Column(db.Float())
capacity = db.Column(db.Integer())
pilot_name = db.Column(db.String(25))
#Sepet Tablosu tanımlanmıştır.
class Basket(db.Model):
__tablename__ = 'basket'
id = db.Column(db.Integer(), primary_key=True)
timestamp = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow())
ucus_id = db.Column(db.Integer())
users_id = db.Column(db.Integer())
name = db.Column(db.String(50))
last_name = db.Column(db.String(50))
phone = db.Column(db.Integer())
number = db.Column(db.Integer())
bonus = db.Column(db.Integer())
ticket = db.Column(db.Integer())
toplam = db.Column(db.Float())
asiltutar = db.Column(db.Float())
#Role Tablosu tanımlanmıştır.
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# User Roles Tablosu tanımlanmıştır.
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
# Uygulama veritabanları user manager modülünün içerisine eklenmiştir.
user_manager = UserManager(app, db, User)
# Tüm veritabanları oluşturulmuştur.
db.create_all()
engine = create_engine('sqlite:///basic_app2.sqlite')
meta = MetaData(engine, reflect=True)
#Metadata tablolar değişkenlere aktarılmıştır.
table_isim2 = meta.tables['rezervation']
table_isim3 = meta.tables['basket']
table_isim4 = meta.tables['flight']
#Kullanıcı Giriş Çıkış İşlemi Yapılmıştır.
@user_logged_in.connect_via(app)
def _after_login_hook(sender, user, **extra):
sender.logger.info('user logged in')
@user_logged_out.connect_via(app)
def _after_logout_hook(sender, user, **extra):
sender.logger.info('user logged out')
#Memberlar yaratılıp gerekli olan bilgileri verilmiştir.
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
#Memberlar yaratılıp gerekli olan bilgileri verilmiştir.
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
#Memberlar yaratılıp gerekli olan bilgileri verilmiştir.
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password2'),
)
db.session.add(user)
db.session.commit()
#Memberlar yaratılıp gerekli olan bilgileri verilmiştir.
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password3'),
)
db.session.add(user)
db.session.commit()
#Memberlar yaratılıp gerekli olan bilgileri verilmiştir.
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password4'),
)
db.session.add(user)
db.session.commit()
#Admin ve Rol ataması yapılmıştır.
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
#Anasayfa HTML
@app.route('/')
def home_page():
return render_template('home.html')
#Admin HTML
@app.route('/admin')
@roles_required('Admin')
def admin_page():
return render_template('admin.html')
##Member HTML
@app.route('/member')
@login_required
def member_page():
return render_template('uye_sayfasi.html')
#Admin Uçuş Rezerve Etme Kısmıdır.
@app.route('/rezervation')
def rezervation_page():
return render_template('rezervation.html')
@app.route('/rezervation_sayfasi')
@roles_required('Admin')
def rezervation_sayfasi():
return render_template('rezervation.html')
#Adminin Uçuş ekleme işlemi burada gerçekleştirilmiştir.
@app.route('/rezervation_ekle', methods=['POST', 'GET'])
@roles_required('Admin')
def rezervation_ekle():
if request.method == 'POST':
try:
ucus_id = request.form['ucus_id']
departure = request.form['departure']
landing = request.form['landing']
empty_seat = request.form['empty_seat']
full_seat = request.form['full_seat']
capacity = request.form['capacity']
pilot_name = request.form['pilot_name']
ticket = request.form['ticket']
rezervasyon = Flight(
ucus_id=ucus_id,
departure=departure,
landing=landing,
empty_seat=empty_seat,
full_seat=full_seat,
capacity=capacity,
pilot_name=pilot_name,
ticket=ticket,
)
db.session.add(rezervasyon)
db.session.commit()
msg = "UÇUŞ EKLEME İŞLEMİNİZ BAŞARIYLA GERÇEKLEŞMİŞTİR"
except:
msg = "UÇUŞ EKLEME SIRASINDA HATA OLUŞTU"
finally:
return render_template('rezervasyongoruntule.html', msg=msg)
#Kullanıcıların Uçuş listeleme işlemi burada gerçekleştirilmiştir.
@app.route('/rezervasyon_listele')
def rezervasyon_listele():
user = current_user.id
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
bonusyap = table_isim4.update().where(
table_isim4.c.bonus == None).values(bonus=(table_isim4.c.ticket) *
3 / 100)
conn.execute(bonusyap)
select_st = select([
table_isim4.c.ucus_id, table_isim4.c.departure,
table_isim4.c.landing, table_isim4.c.empty_seat,
table_isim4.c.full_seat, table_isim4.c.capacity,
table_isim4.c.pilot_name, table_isim4.c.ticket, table_isim4.c.bonus
])
rows = conn.execute(select_st)
return render_template("rezervasyon_listele.html", rows=rows)
@app.route('/sepet_sayfasi')
@login_required
def sepet_sayfasi():
return render_template('rezervasyon_listele.html')
#Sepete ekleme işlemi burada gerçekleşmiştir.
@app.route('/sepet_ekle', methods=['POST', 'GET'])
@login_required
def sepet_ekle():
if request.method == 'POST':
try:
ucus_id = request.form['ucus_id']
name = request.form['name']
last_name = request.form['last_name']
phone = request.form['phone']
number = request.form['number']
ticket = request.form['ticket']
user = current_user.id
with sql.connect('basic_app2.sqlite') as conn:
cur = conn.cursor()
cur.execute(
"SELECT count(ucus_id) FROM flight WHERE ucus_id=" +
request.form['ucus_id'])
conn.commit()
row = cur.fetchone()
msg = ''
if row[0] == 0:
msg = "Seçtiğiniz Numaraya Ait Uçuş Bulunamadı."
alert = 'alert-danger'
else:
conn.close()
alert = 'alert-success'
msg = "Sepete ekleme işleminiz başarıyla gerçekleştirildi"
sepet = Basket(
ucus_id=ucus_id,
name=name,
last_name=last_name,
phone=phone,
number=number,
users_id=user,
ticket=ticket,
)
db.session.add(sepet)
db.session.commit()
rez = Rezervation(flight_id=ucus_id,
name=name,
last_name=last_name,
phone=phone,
number=number,
user_id=user,
tarih=datetime.datetime.utcnow(),
ticket=ticket)
db.session.add(rez)
db.session.commit()
finally:
return render_template('sepetgoruntule.html',
msg=msg,
alert=alert)
#Tarihsiz sepet listeleme işlemi burada yapılmıştır.
@app.route('/sepet_listele')
@login_required
def sepet_listele():
user = current_user.id
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
bonusya = table_isim3.update().where(
table_isim3.c.bonus == None).values(
bonus=(table_isim3.c.ticket * table_isim3.c.number) * 3 / 100)
conn.execute(bonusya)
ticke = table_isim3.update().where(
table_isim3.c.ticket == None).values(ticket=table_isim3.c.number *
table_isim3.c.ticket)
conn.execute(ticke)
bilethesab = table_isim3.update().where(
table_isim3.c.toplam == None).values(toplam=(table_isim3.c.ticket *
table_isim3.c.number))
conn.execute(bilethesab)
asiltutarr = table_isim3.update().where(
table_isim3.c.asiltutar == None).values(
asiltutar=(table_isim3.c.toplam) - (table_isim3.c.bonus))
conn.execute(asiltutarr)
sepet = select([
table_isim3.c.users_id, table_isim3.c.ucus_id, table_isim3.c.name,
table_isim3.c.last_name, table_isim3.c.phone, table_isim3.c.number,
table_isim3.c.ticket, table_isim3.c.bonus, table_isim3.c.toplam,
table_isim3.c.asiltutar
]).where(table_isim3.c.users_id == user)
rows = conn.execute(sepet)
return render_template('sepet_listele.html', rows=rows)
#Uçuş listeleme işlemi (Kullanıcı tüm detaylarıyla uçuşları görüntülüyor.)
@app.route('/rez_listele')
@login_required
def rez_listele():
user = current_user.id
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
alert = 'alert-success'
msg = "Bilet alma işleminiz başarıyla gerçekleştirildi."
bonus = table_isim2.update().where(table_isim2.c.bonus == None).values(
bonus=(table_isim2.c.ticket * table_isim2.c.number) * 3 / 100)
conn.execute(bonus)
bilethesabı = table_isim2.update().where(
table_isim2.c.toplam == None).values(toplam=(table_isim2.c.ticket *
table_isim2.c.number))
conn.execute(bilethesabı)
asiltut = table_isim2.update().where(
table_isim2.c.asiltutar == None).values(
asiltutar=(table_isim2.c.toplam) - (table_isim2.c.bonus))
conn.execute(asiltut)
rezliste = select([
table_isim2.c.user_id, table_isim2.c.tarih, table_isim2.c.name,
table_isim2.c.last_name, table_isim2.c.phone, table_isim2.c.number,
table_isim2.c.ticket, table_isim2.c.bonus, table_isim2.c.toplam,
table_isim2.c.asiltutar
]).where(table_isim2.c.user_id == user)
rows = conn.execute(rezliste)
return render_template('rezlist.html', rows=rows, msg=msg, alert=alert)
#Kullanıcı girişi olmadan anasayfada tüm uçuşlar listeleniyor.
@app.route('/rez2_listele')
def rez2_listele():
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
tumucus = select([
table_isim4.c.ucus_id, table_isim4.c.departure,
table_isim4.c.landing, table_isim4.c.capacity,
table_isim4.c.empty_seat, table_isim4.c.full_seat,
table_isim4.c.pilot_name
])
rows = conn.execute(tumucus)
return render_template('rezlist1.html', rows=rows)
#Kullanıcı bazında bonus listeleme işlemi yapılıyor.
@app.route('/bonuslistele')
def bonuslistele():
user = current_user.id
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
bonusliste = select([
table_isim3.c.users_id, table_isim3.c.name,
table_isim3.c.last_name, table_isim3.c.bonus
]).where(table_isim3.c.users_id == user)
rows = conn.execute(bonusliste)
return render_template('bonuslistele.html', rows=rows)
#Admin sepet listeleme işlemi Burada yapılmıştır.
@app.route('/adminsepetlistele')
@roles_required('Admin')
def adminsepetlistele():
user = current_user.id
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
sepetlistele = select([
table_isim3.c.users_id, table_isim3.c.timestamp,
table_isim3.c.ucus_id, table_isim3.c.name, table_isim3.c.last_name,
table_isim3.c.phone, table_isim3.c.number
]).where(user == 6)
rows = conn.execute(sepetlistele)
return render_template('adminsepetlistele.html', rows=rows)
#Doluluk oranı hesabını yapılması burada gerçekleştirilmiştir.
@app.route('/doluluk_orani')
@login_required
def doluluk_orani():
user = current_user.id
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
oranhesabı = table_isim4.update().where(
table_isim4.c.oran == None).values(
oran=(table_isim4.c.full_seat / table_isim4.c.capacity) * 100)
conn.execute(oranhesabı)
dolulukhesabi = select([
table_isim4.c.ucus_id, table_isim4.c.capacity,
table_isim4.c.empty_seat, table_isim4.c.full_seat,
table_isim4.c.oran
]).order_by(desc(table_isim4.c.capacity))
rows = conn.execute(dolulukhesabi)
return render_template('dolulukorani.html', rows=rows)
#Adminin Sepetten Silme İşlemi Gerçekleştirilmiştir.
@app.route('/adminsepettensil/<ucus_id>')
def adminsepettensil(ucus_id):
adminsil = Basket.query.filter_by(ucus_id=ucus_id).first()
db.session.delete(adminsil)
db.session.commit()
return redirect(url_for('sepet_listele'))
#Kullanıcı tarafından Sepetten silme işlemi gerçekleştirilmiştir.
@app.route('/sepettensil/<ucus_id>')
def sepettensil(ucus_id):
sepetsil = Basket.query.filter_by(ucus_id=ucus_id).first()
db.session.delete(sepetsil)
db.session.commit()
return redirect(url_for('sepet_listele'))
#Admin Uçuş Silme İşlemi Yapılmıştır.
@app.route('/rezsill/<ucus_id>')
@roles_required('Admin')
def rezsill(ucus_id):
ucussil = Flight.query.filter_by(ucus_id=ucus_id).first()
db.session.delete(ucussil)
db.session.commit()
return redirect(url_for('rezervasyon_listele'))
#Admin Rezervasyon Id'si Güncelleme İşlemi Yapabiliyor.
@app.route('/rezguncelle/<ucus_id>')
@roles_required('Admin')
def rezguncelle(ucus_id):
db_uri = 'sqlite:///basic_app2.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
ucusguncelle = table_isim4.update().where(
table_isim4.c.id == table_isim4.c.ucus_id).values(
ucus_id=table_isim4.c.ucus_id + str(1))
conn.execute(ucusguncelle)
db.session.commit()
return redirect(url_for('rezervasyon_listele'))
#Doluluk Silme İşlemi Admin Tarafından Gerçekleştirlmiştir.
@app.route('/doluluksil/<capacity>')
@roles_required('Admin')
def doluluksil(capacity):
doluluksilme = Flight.query.filter_by(capacity=capacity).first()
db.session.delete(doluluksilme)
db.session.commit()
return redirect(url_for('doluluk_orani'))
return app
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template("index.html")
# The Members page is only accessible to authenticated users
@app.route('/biblioteca')
@login_required # Use of @login_required decorator
def biblioteca():
return render_template("biblioteca.html")
@app.route('/biblioteca2')
@login_required # Use of @login_required decorator
def biblioteca2():
return render_template("biblioteca2.html")
# The Admin page requires an 'Admin' role.
@app.route('/nuevolibro')
@roles_required('Admin') # Use of @roles_required decorator
def admin_new_libro():
return render_template("nuevolibro.html")
@app.route('/actualizarlibro')
@roles_required('Admin')
def admin_updatelibro():
return render_template("updatelibro1.html")
@app.route('/actualizarlibro2')
@roles_required('Admin')
def admin_updatelibro2():
return render_template("updatelibro.html")
@app.route('/libros', methods=['Post'])
def create_book():
titulo = request.form['titulo']
autor = request.form['autor']
genero = request.form['genero']
nacionalidad = request.form['nacionalidad']
descripcion = request.form['descripcion']
imagen = request.files['imagen']
archivo = request.files['archivo']
fotoautor = request.files['fotoautor']
nombreimagen = imagen.filename
nombrearchivo = archivo.filename
nombrefotoautor = fotoautor.filename
rutaimagen = os.path.abspath(nombreimagen)
rutaarchivo = os.path.abspath(nombrearchivo)
rutafotoautor = os.path.abspath(nombrefotoautor)
libro = entities.Libro(titulo=titulo,
autor=autor,
genero=genero,
nacionalidad=nacionalidad,
descripcion=descripcion,
imagen=imagen.read(),
archivo=archivo.read(),
fotoautor=fotoautor.read(),
nombreimagen=nombreimagen,
nombrearchivo=nombrearchivo,
nombrefotoautor=nombrefotoautor,
rutaimagen=rutaimagen,
rutaarchivo=rutaarchivo,
rutafotoautor=rutafotoautor)
session = db.Session(engine)
session.add(libro)
session.commit()
return render_template('success.html')
@app.route('/libros', methods=['PUT'])
def update_book():
session = db.Session(engine)
ID = request.form['key']
libros = session.query(entities.Libro).filter(entities.Libro.ID == ID)
content = json.loads(request.form['values'])
for libro in libros:
if 'titulo' in content:
libro.titulo = content['titulo']
if 'autor' in content:
libro.autor = content['autor']
if 'genero' in content:
libro.genero = content['genero']
if 'nacionalidad' in content:
libro.nacionalidad = content['nacionalidad']
if 'descripcion' in content:
libro.descripcion = content['descripcion']
if 'imagen' in content:
imagen = content['imagen']
libro.imagen = imagen
nombreimagen = imagen.filename
libro.nombreimagen = nombreimagen
libro.rutaimagen = os.path.abspath(nombreimagen)
if 'archivo' in content:
archivo = content['archivo']
libro.archivo = archivo
nombrearchivo = archivo.filename
libro.nombrearchivo = nombrearchivo
libro.rutaarchivo = os.path.abspath(nombrearchivo)
if 'fotoautor' in content:
fotoautor = content['fotoautor']
libro.fotoautor = fotoautor
nombrefotoautor = fotoautor.filename
libro.nombrefotoautor = nombrefotoautor
libro.rutafotoautor = os.path.abspath(nombrefotoautor)
session.add(libro)
session.commit()
return 'Update exitosa'
@app.route('/actualizarconput')
def update_put():
return render_template('updatePut.html')
@app.route('/libro/<ID>', methods=['DELETE'])
def delete_book(ID):
session = db.Session(engine)
libros = session.query(entities.Libro).filter(entities.Libro.ID == ID)
for libro in libros:
session.delete(libro)
session.commit()
return 'User Deleted'
@app.route('/titulo/<ID>', methods=['GET'])
@login_required
def titulo(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].titulo, mimetype='text/txt')
@app.route('/autor/<ID>', methods=['GET'])
@login_required
def autor(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].autor, mimetype='text/txt')
@app.route('/genero/<ID>', methods=['GET'])
@login_required
def genero(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].genero, mimetype='text/txt')
@app.route('/nacionalidad/<ID>', methods=['GET'])
@login_required
def nacionalidad(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].nacionalidad, mimetype='text/txt')
@app.route('/descripcion/<ID>', methods=['GET'])
@login_required
def descripcion(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].descripcion, mimetype='text/txt')
@app.route('/imagen/<ID>', methods=['GET'])
@login_required
def imagen(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].imagen, mimetype='image/png')
@app.route('/archivo/<ID>', methods=['GET'])
@login_required
def archivo(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].archivo, mimetype='application/pdf')
@app.route('/fotoautor/<ID>', methods=['GET'])
@login_required
def fotoautor(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
break
return Response(data[0].fotoautor, mimetype='image/png')
@app.route('/libros', methods=['GET'])
@login_required
def libros():
db_session = db.Session(engine)
libros = db_session.query(entities.Libro)
data = []
for libro in libros:
data.append(libro)
return Response(json.dumps(data, cls=connector.AlchemyEncoder),
mimetype='application/json')
@app.route('/mobile_login', methods=["POST"])
def mobile_login():
body = request.get_json(silent=True)
print(body)
username = body['username']
password = body['password']
sessiondb = db.Session(engine)
user = sessiondb.query(entities.MobileUser).filter(
and_(entities.MobileUser.username == username,
entities.MobileUser.password == password)).first()
if user != None:
return Response(json.dumps({
'response': True,
'id': user.id
},
cls=connector.AlchemyEncoder),
mimetype='application/json')
else:
return Response(json.dumps({'response': False},
cls=connector.AlchemyEncoder),
mimetype='application/json')
@app.route('/mobile_register', methods=['POST'])
def mobile_register():
username = request.form['username']
email = request.form['email']
password = request.form['password']
print(username, email, password)
user = entities.MobileUser(username=username,
email=email,
password=password)
register = db.Session(engine)
register.add(user)
register.commit()
return "Todo Ok!"
@app.route('/mobile_libros', methods=['GET'])
def get_libros():
db_session = db.Session(engine)
libros = db_session.query(entities.Libro)
data = []
for libro in libros:
data.append(libro)
return Response(json.dumps({'data': data},
cls=connector.AlchemyEncoder),
mimetype='application/json')
@app.route('/mobile_libros/<ID>', methods=['GET'])
def mobile_libros_id(ID):
db_session = db.Session(engine)
libros = db_session.query(
entities.Libro).filter(entities.Libro.ID == ID)
data = []
for libro in libros:
data.append(libro)
print(data)
return Response(json.dumps({'data': data},
cls=connector.AlchemyEncoder),
mimetype='application/json')
@app.route('/newUsers', methods=['GET'])
def newUsers():
db_session = db.Session(engine)
users = db_session.query(entities.MobileUser)
data = []
for user in users:
data.append(user)
return Response(json.dumps({'data': data},
cls=connector.AlchemyEncoder),
mimetype='application/json')
return app
def create_app():
""" Flask application factory """
app = Flask(__name__)
bcrypt = Bcrypt(app)
app.config.from_object(__name__ + '.ConfigClass')
login_manager = LoginManager(app)
babel = Babel(app)
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Oteller(db.Model):
__tablename__ = 'oteller'
otel_id = db.Column(db.Integer(), autoincrement=True, primary_key=True)
isim = db.Column(db.String(255))
adres = db.Column(db.String(255))
yildiz = db.Column(db.Integer())
image_url = db.Column(db.String(500))
class Odalar(db.Model):
__tablename__ = 'odalar'
oda_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
fiyat = db.Column(db.Integer())
kac_kisilik = db.Column(db.Integer())
otel_id = db.Column(
db.Integer, db.ForeignKey('oteller.otel_id', ondelete='CASCADE'))
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
class Rezervasyonlar(db.Model):
__tablename__ = 'rezervasyonlar'
rez_id = db.Column(db.Integer, autoincrement=True, primary_key=True)
oda_id = db.Column(db.Integer,
db.ForeignKey('odalar.oda_id', ondelete='CASCADE'))
baslangic = db.Column(db.String(20))
bitis = db.Column(db.String(20))
fiyat = db.Column(db.Integer)
users_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
def serialize(self):
return {
"rez_id": self.rez_id,
"oda_id": self.oda_id,
"baslangic": self.baslangic,
"bitis": self.bitis,
"fiyat": self.fiyat,
"users_id": self.users_id
}
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
engine = create_engine('sqlite:///basic_app.sqlite')
meta = MetaData(engine, reflect=True)
t_oteller = meta.tables['oteller']
t_odalar = meta.tables['odalar']
t_rez = meta.tables['rezervasyonlar']
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
rol = ''
# The Home page is accessible to anyone
@app.route('/')
def home_page():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
rows = engine.execute('SELECT * FROM oteller LIMIT 3')
global rol
rol = ''
if current_user.is_authenticated:
rol = engine.execute(
'SELECT r.name From roles r,user_roles ur,roles rol,users u WHERE u.id='
+ str(current_user.id) +
' AND ur.user_id=u.id AND ur.role_id=rol.id AND rol.name="' +
'Admin' + '"').fetchone()
if rol:
rol = rol[0]
return render_template('index.html', oteller=rows, rol=rol)
@app.route('/anasayfa')
def anasayfa():
return redirect('/')
@app.route('/login')
def login():
if current_user.is_authenticated:
return redirect('/')
else:
return render_template('/login/index.html')
@app.route('/giris_yap', methods=['POST', 'GET'])
def giris_yap():
session.pop('sepetim', None)
sepetim.clear()
if request.method == 'POST':
mail = request.form['mail']
password = request.form['pass']
con = sql.connect('basic_app.sqlite')
cur = con.cursor()
user = User.query.filter_by(email=mail).first()
msg = "Kullanıcı bulunamadı"
if user:
if bcrypt.check_password_hash(user.password, password):
user.authenticated = True
db.session.add(user)
db.session.commit()
login_user(user, remember=True)
return redirect('/')
return render_template('./login/index.html',
msg=msg,
hata='alert alert-danger')
@app.route('/register')
def register():
return render_template('/register/index.html')
@app.route('/kayit', methods=['POST', 'GET'])
def kayit():
if request.method == 'POST':
mail = request.form['mail']
password = request.form['pass']
if not User.query.filter(User.email == mail).first():
user = User(
email=mail,
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password(password),
)
role = Role.query.filter_by(name='Agent').one()
user.roles.append(role)
db.session.add(user)
db.session.commit()
return render_template('/register/index.html',
msg='Kayıt başarıyla eklendi',
hata='alert alert-success')
else:
return render_template('/register/index.html',
msg='Bu kişi daha önce kaydolmuş',
hata='alert alert-danger')
@app.route('/otelekleme')
@roles_required('Admin') # Use of @roles_required decorator
def otelekleme():
return render_template('otelekleme.html', rol=rol)
@app.route('/OtelEkle', methods=['POST', 'GET'])
def OtelEkle():
otel = Oteller(
isim=request.form['isim'],
adres=request.form['adres'],
yildiz=request.form['yildiz'],
)
db.session.add(otel)
msg = "Otel başarıyla eklendi"
db.session.commit()
return render_template('otelekleme.html',
mesaj=msg,
alert_tur="alert alert-success")
@app.route('/otellerigetir')
def otellerigetir():
oteller = Oteller.query.all()
global rol
for otel in oteller:
con = sql.connect('basic_app.sqlite')
cur = con.cursor()
today = strftime("%Y-%m-%d", gmtime())
print("TODAY :" + today)
cur.execute(
"SELECT count(od.oda_id) FROM odalar od JOIN rezervasyonlar r ON r.oda_id=od.oda_id JOIN oteller o ON o.otel_id = od.otel_id WHERE r.baslangic='"
+ str(today) + "' AND o.otel_id =" + str(otel.otel_id) + "")
con.commit()
oran = cur.fetchone()
cur.execute("SELECT count(oda_id) FROM odalar WHERE otel_id=" +
str(otel.otel_id) + "")
con.commit()
odasayisi = cur.fetchone()
odasayisi = odasayisi[0]
sayi = int(oran[0])
oran2 = int((sayi / odasayisi) * 100)
otel.oran = oran2
return render_template('oteller.html', oteller=oteller, rol=rol)
@app.route('/otelguncelleme', methods=['POST', 'GET'])
@roles_required('Admin') # Use of @roles_required decorator
def otelguncelleme():
global rol
con = sql.connect('basic_app.sqlite')
otel_id = request.form['otel_id']
return render_template('otelguncelleme.html', otel_id=otel_id, rol=rol)
@app.route('/otelguncelle', methods=['POST', 'GET'])
def otelguncelle():
otel_id = request.form['otel_id']
isim = request.form['isim']
adres = request.form['adres']
yildiz = request.form['yildiz']
con = sql.connect('basic_app.sqlite')
cur = con.cursor()
cur.execute(
"UPDATE oteller SET isim=(?),adres=(?),yildiz=(?) WHERE otel_id='"
+ str(otel_id) + "'", (isim, adres, yildiz))
con.commit()
return render_template('otelguncelleme.html',
mesaj="Otel başarıyla güncellendi",
alert_tur="alert alert-success",
oda=oda)
@app.route('/otelsil', methods=['POST', 'GET'])
@roles_required('Admin') # Use of @roles_required decorator
def otelsil():
con = sql.connect('basic_app.sqlite')
otel_id = request.form['otel_id']
cur = con.cursor()
cur.execute('DELETE FROM oteller WHERE otel_id =' + str(otel_id) + '')
cur.execute('DELETE FROM odalar WHERE otel_id=' + str(otel_id) + '')
con.commit()
return redirect('otellerigetir')
@app.route('/odaekleme')
@roles_required('Admin') # Use of @roles_required decorator
def odaekleme():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
select_st = select([t_oteller.c.isim, t_oteller.c.otel_id])
otel_isim = conn.execute(select_st)
return render_template('odaekleme.html', otel_isim=otel_isim)
@app.route('/OdaEkle', methods=['POST', 'GET'])
def OdaEkle():
msg = "Hata oluştu"
oda = Odalar(fiyat=request.form['fiyat'],
otel_id=request.form['otel_id'],
kac_kisilik=request.form['kac_kisilik'])
db.session.add(oda)
db.session.commit()
msg = 'Oda eklendi'
return redirect('odaekleme')
oda = {}
@app.route('/odaguncelleme', methods=['POST', 'GET'])
@roles_required('Admin') # Use of @roles_required decorator
def odaguncelleme():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
select_oteller = select([t_oteller.c.isim, t_oteller.c.otel_id])
otel_isim = conn.execute(select_oteller)
con = sql.connect('basic_app.sqlite')
oda_id = request.form['oda_id']
cur = con.cursor()
cur.execute('SELECT * FROM odalar WHERE oda_id=' + str(oda_id) + '')
global oda
oda = cur.fetchall()
return render_template('odaguncelleme.html',
oda=oda,
otel_isim=otel_isim,
oda_id=oda_id)
@app.route('/odasilme', methods=['POST', 'GET'])
@roles_required('Admin') # Use of @roles_required decorator
def odasilme():
con = sql.connect('basic_app.sqlite')
oda_id = request.form['oda_id']
cur = con.cursor()
cur.execute('DELETE FROM odalar WHERE oda_id =' + str(oda_id) + '')
cur.execute('DELETE FROM rezervasyonlar WHERE oda_id =' + str(oda_id) +
'')
con.commit()
return redirect('otellerigetir')
@app.route('/OdaGuncelle', methods=['POST', 'GET'])
def OdaGuncelle():
msg = "Hata oluştu"
fiyat = request.form['fiyat']
kac_kisilik = request.form['kac_kisilik']
oda_id = request.form['oda_id']
con = sql.connect('basic_app.sqlite')
cur = con.cursor()
cur.execute(
"UPDATE odalar SET fiyat=(?),kac_kisilik=(?) WHERE oda_id='" +
str(oda_id) + "'", (fiyat, kac_kisilik))
con.commit()
return render_template('odaguncelleme.html',
msg="Oda başarıyla güncellendi",
hata="alert alert-success",
oda=oda)
@app.route('/odalar', methods=['POST', 'GET'])
def odalar():
global rol
con = sql.connect('basic_app.sqlite')
secilen_id = request.form['secilen_id']
con.row_factory = sql.Row
cur = con.cursor()
cur.execute(
"SELECT o.isim, od.oda_id, od.kac_kisilik, od.fiyat FROM oteller o INNER JOIN odalar od ON od.otel_id=o.otel_id WHERE o.otel_id ="
+ secilen_id + " ORDER BY od.oda_id ASC")
odalar = cur.fetchall()
return render_template('odalar.html', odalar=odalar, rol=rol)
@app.route('/rezervasyonlarim')
@login_required
def rezervasyonlarim():
global rol
con = sql.connect('basic_app.sqlite')
con.row_factory = sql.Row
cur = con.cursor()
cur.execute(
"SELECT r.*,ot.isim, o.kac_kisilik FROM odalar o JOIN rezervasyonlar r ON r.oda_id = o.oda_id JOIN oteller ot ON ot.otel_id = o.otel_id WHERE r.users_id="
+ str(current_user.id) + "")
rezervasyonlar = cur.fetchall()
return render_template('rezervasyonlarim.html',
rezervasyonlar=rezervasyonlar,
rol=rol)
@app.route('/rezsil', methods=['POST', 'GET'])
@login_required
def rezsil():
con = sql.connect('basic_app.sqlite')
rez_id = request.form['rez_id']
cur = con.cursor()
cur.execute('DELETE FROM rezervasyonlar WHERE rez_id =' + str(rez_id) +
'')
con.commit()
return redirect('rezervasyonlarim')
sepetim = []
fiyat = 0
@app.route('/sepetal', methods=['POST', 'GET'])
@login_required
def sepetal():
con = sql.connect('basic_app.sqlite')
con.row_factory = sql.Row
cur = con.cursor()
cur.execute("SELECT * FROM Rezervasyonlar WHERE oda_id =" +
request.form['oda_id'] + "")
rezervasyonlar = cur.fetchall()
baslangicsepet = datetime.datetime.strptime(request.form['baslangic'],
'%Y-%m-%d')
bitissepet = datetime.datetime.strptime(request.form['bitis'],
'%Y-%m-%d')
baslangic = datetime.datetime.strptime(request.form['baslangic'],
'%Y-%m-%d')
bitis = datetime.datetime.strptime(request.form['bitis'], '%Y-%m-%d')
global fiyat
msg = ''
if baslangic < bitis:
if len(rezervasyonlar) > 0:
for rez in rezervasyonlar:
baslangic = datetime.datetime.strptime(
rez['baslangic'], '%Y-%m-%d')
bitis = datetime.datetime.strptime(rez['bitis'],
'%Y-%m-%d')
#baslangicsepet=datetime.datetime.strptime(request.form['baslangic'],'%Y-%m-%d')
#bitissepet=datetime.datetime.strptime(request.form['bitis'],'%Y-%m-%d')
if not ((baslangic <= baslangicsepet <= bitis) or
(baslangic <= bitissepet <= bitis)):
user = current_user.id
rez = len(sepetim) + 1
gunler = bitissepet - baslangicsepet
cur.execute('Select * From odalar WHERE oda_id="' +
str(request.form['oda_id']) + '"')
records = cur.fetchall()
odaucreti = 0
for row in records:
odaucreti = row[1]
fiyat = gunler.days * int(odaucreti)
rezervasyon = Rezervasyonlar(
rez_id=rez,
oda_id=request.form['oda_id'],
baslangic=request.form['baslangic'],
bitis=request.form['bitis'],
users_id=user,
fiyat=fiyat)
if session.get('sepetim'):
sepetim.clear()
sepetim.extend(session['sepetim'])
sepetim.append(rezervasyon.serialize())
session.pop('sepetim', None)
session['sepetim'] = sepetim
else:
return render_template(
'sepetigoster.html',
mesaj="Oda bu tarihler arasında müsait değildir",
alert_tur="alert alert-danger")
else:
user = current_user.id
rez = len(sepetim) + 1
gunler = bitissepet - baslangicsepet
cur.execute('Select * From odalar WHERE oda_id="' +
str(request.form['oda_id']) + '"')
records = cur.fetchall()
odaucreti = 0
for row in records:
odaucreti = row[1]
fiyat = gunler.days * int(odaucreti)
rezervasyon = Rezervasyonlar(
rez_id=rez,
oda_id=request.form['oda_id'],
baslangic=request.form['baslangic'],
bitis=request.form['bitis'],
users_id=user,
fiyat=fiyat)
if session.get('sepetim'):
sepetim.clear()
sepetim.extend(session['sepetim'])
sepetim.append(rezervasyon.serialize())
session.pop('sepetim', None)
session['sepetim'] = sepetim
return redirect('sepetigetir')
@app.route('/sepetigetir')
@login_required
def sepetigetir():
if session.get('sepetim'):
sepetim.clear()
sepetim.extend(session['sepetim'])
return render_template('sepetigoster.html', sepet=sepetim)
else:
tur = 'alert alert-danger'
mesaj = 'Sepette ürün yok.'
return render_template('sepetigoster.html',
alert_tur=tur,
mesaj=mesaj)
@app.route('/sepettencikar', methods=['POST', 'GET'])
def sepettencikar():
id = request.form['rez_id']
temp = []
for sepet in sepetim:
if int(sepet['rez_id']) != int(id):
temp.append(sepet)
sepetim.clear()
sepetim.extend(temp)
session.pop('sepetim', None)
session['sepetim'] = sepetim
return redirect('sepetigetir')
@app.route('/sepetibosalt', methods=['POST', 'GET'])
def sepetibosalt():
sepetim.clear()
session.pop('sepetim', None)
return redirect('/')
@app.route('/rezervasyonalpage', methods=['POST', 'GET'])
def rezervasyonalpage():
user = current_user.id
msg = ''
for sepet in sepetim:
con = sql.connect('basic_app.sqlite')
con.row_factory = sql.Row
cur = con.cursor()
cur.execute("SELECT * FROM Rezervasyonlar WHERE oda_id =" +
sepet['oda_id'] + "")
rezervasyonlar = cur.fetchall()
if len(rezervasyonlar) > 0:
for rez in rezervasyonlar:
baslangic = datetime.datetime.strptime(
rez['baslangic'], '%Y-%m-%d')
bitis = datetime.datetime.strptime(rez['bitis'],
'%Y-%m-%d')
baslangicsepet = datetime.datetime.strptime(
sepet['baslangic'], '%Y-%m-%d')
bitissepet = datetime.datetime.strptime(
sepet['bitis'], '%Y-%m-%d')
if not ((baslangic <= baslangicsepet <= bitis) or
(baslangic <= bitissepet <= bitis)):
rezervasyon = Rezervasyonlar(
oda_id=sepet['oda_id'],
baslangic=sepet['baslangic'],
bitis=sepet['bitis'],
users_id=user,
fiyat=sepet['fiyat'])
db.session.add(rezervasyon)
db.session.commit()
else:
rezervasyon = Rezervasyonlar(oda_id=sepet['oda_id'],
baslangic=sepet['baslangic'],
bitis=sepet['bitis'],
fiyat=sepet['fiyat'],
users_id=user)
db.session.add(rezervasyon)
db.session.commit()
return redirect('sepetibosalt')
return app
def setup(db, app):
# Define the User data model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# User authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# User information
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
first_name = db.Column(db.String(100), nullable=False, server_default='')
last_name = db.Column(db.String(100), nullable=False, server_default='')
# Relationships
roles = db.relationship('Role', secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
# Define the Role data model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles data model
class UserRoles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE'))
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username=='admin').first():
user_admin = User(username='******', email='*****@*****.**', active=True, password=user_manager.hash_password('admin'))
user_admin.roles.append(Role(name='admin'))
user_admin.roles.append(Role(name='secret'))
db.session.add(user_admin)
db.session.commit()
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
db = SQLAlchemy(app)
class Kullanici(db.Model):
__tablename__ = 'Kullanici'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), unique=True)
sifre = db.Column(db.String(80))
rolId = db.Column(db.Integer, db.ForeignKey('rol.rolId', ondelete='CASCADE'))
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1')
def __init__(self, email, sifre):
self.email = email
self.sifre = sifre
self.rolId = 0
class Roller(db.Model):
__tablename__ = 'rol'
rolId = db.Column(db.Integer, primary_key=True)
rolisim = db.Column(db.String(80))
class urunler(db.Model):
__tablename__ = 'urunler'
urun_id = db.Column(db.Integer, primary_key=True)
kategori_id = db.Column(db.Integer(), db.ForeignKey('kategori.kategoriId', ondelete='CASCADE'))
urunresmi = db.Column(db.String(80))
urunFiyati = db.Column(db.Integer)
markaId = db.Column(db.Integer(), db.ForeignKey('markalar.markaId', ondelete='CASCADE'))
def __init__(self, kategori_id, urun_ozellikleri, urun_fiyati):
self.kategori_id = kategori_id
self.urun_ozellikleri = urun_ozellikleri
self.urun_fiyati = urun_fiyati
class kategori(db.Model):
__tablename__ = 'kategori'
kategoriId = db.Column(db.Integer, primary_key=True)
kategori_adi = db.Column(db.String(80))
def __init__(self, kategori_adi):
self.kategori_adi = kategori_adi
class markalar(db.Model):
__tablename__ = 'markalar'
markaId = db.Column(db.Integer, primary_key=True)
markaadi = db.Column(db.String(80))
marka_modeli = db.Column(db.String(80))
def __init__(self, markaadi, marka_modeli):
self.markaadi = markaadi
self.marka_modeli = marka_modeli
class musteri(db.Model):
__tablename__ = 'musteri'
musteriId = db.Column(db.Integer, primary_key=True)
musteriadi = db.Column(db.String(80))
musterisoyadi = db.Column(db.String(80))
mail = db.Column(db.String(80), unique=True)
telefon = db.Column(db.Integer)
sifre = db.Column(db.String(80))
il = db.Column(db.String(80))
ilce = db.Column(db.String(80))
kullaniciId = db.Column(db.Integer(), db.ForeignKey('Kullanici.id', ondelete='CASCADE'))
def __init__(self, musteriadi, musterisoyadi, mail, telefon, sifre, il, ilce, kullaniciId):
self.musteriadi = musteriadi
self.musterisoyadi = musterisoyadi
self.mail = mail
self.telefon = telefon
self.sifre = sifre
self.il = il
self.ilce = ilce
self.kullaniciId = kullaniciId
class siparis(db.Model):
__tablename__ = 'siparis'
siparisId = db.Column(db.Integer, primary_key=True)
musteriId = db.Column(db.Integer(), db.ForeignKey('musteri.musteriId', ondelete='CASCADE'))
urunId = db.Column(db.Integer(), db.ForeignKey('urunler.urun_id', ondelete='CASCADE'))
siparisno = db.Column(db.Integer)
siparisTarihi = db.Column(db.Integer)
odemeId = db.Column(db.Integer())
def __init__(self, musteriId, urunId, siparisno, siparisTarihi, odemeId):
self.musteriId = musteriId
self.urunId = urunId
self.siparisno = siparisno
self.siparisTarihi = siparisTarihi
self.odemeId = odemeId
user_manager = UserManager(app, db, Kullanici)
db.create_all()
if not Kullanici.query.filter(Kullanici.email == request.form['email']).first():
kullanici = Kullanici(
email=request.form['email'],
tarih=datetime.datetime.utcnow(),
sifre=user_manager.hash_password(request.form['sifre']),
)
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not Kullanici.query.filter(Kullanici.email == '*****@*****.**').first():
kullanici = Kullanici(
email='*****@*****.**',
tarih=datetime.datetime.utcnow(),
sifre=user_manager.hash_password('admin'),
)
@app.route('/')
def anasayfa():
return render_template('index.html')
@app.route('/kayit', methods=['GET', 'POST'])
def kayit():
if request.method == 'POST':
mail = request.form['email']
parola = request.form['sifre']
yeniKullanici = Kullanici(email=mail, sifre=parola)
db.session.add(yeniKullanici)
db.session.commit()
if yeniKullanici is not None:
mesaj = "Kayıt Başarıyla Sağlanmıştır."
return render_template("index.html", mesaj=mesaj)
else:
return render_template('kayit.html')
@app.route('/uye', methods=['GET', 'POST'])
def uye():
return render_template("uyeGirisi.html")
@app.route('/giris', methods=['GET', 'POST'])
def giris():
session['giris_yap']=False
if request.method=='GET':
if(session['giris_yap']==True):
return redirect(url_for('index'))
else:
return render_template('uyeGirisi.html')
else:
def init_user_manager(app, login_view, forgot_password_view=None):
if forgot_password_view is None:
forgot_password_view = forgot_password
def hash_password(self, password):
_md5 = hashlib.md5()
_md5.update(password)
return _md5.hexdigest()
def generate_password_hash(self, password):
_md5 = hashlib.md5()
_md5.update(password)
return _md5.hexdigest()
def verify_password(self, password, user):
auth_method = getattr(request, 'auth_method', None)
if auth_method == 'basic':
return self.hash_password(password) == user.password
else:
return False
def login_manager_usercallback(account_id):
account_id = int(account_id) if isinstance(account_id,
basestring) else account_id
return Account.from_cache_by_id(account_id)
def password_validator(form, field):
""" Password must have one lowercase letter, one uppercase letter and one digit."""
# Convert string to list of characters
password = list(field.data)
password_length = len(password)
# Count lowercase, uppercase and numbers
lowers = uppers = digits = 0
for ch in password:
if ch.islower(): lowers += 1
if ch.isupper(): uppers += 1
if ch.isdigit(): digits += 1
# Password must have one lowercase letter, one uppercase letter and one digit
is_valid = password_length >= 6 and lowers and uppers and digits
if not is_valid:
raise ValidationError(u'密码至少超过6位,其中要求包含一个大写字母,一个小写字母和一个数字')
class ResetPasswordForm(Form):
new_password = PasswordField(
u'新密码', validators=[validators.DataRequired(u'新密码不能为空')])
retype_password = PasswordField(u'再次输入新密码',
validators=[
validators.EqualTo(
'new_password',
message=u'两次输入的新密码匹配')
])
next = HiddenField()
submit = SubmitField(u'修改密码')
def validate(self):
# Use feature config to remove unused form fields
user_manager = current_app.user_manager
if not user_manager.enable_retype_password:
delattr(self, 'retype_password')
# Add custom password validator if needed
has_been_added = False
for v in self.new_password.validators:
if v == user_manager.password_validator:
has_been_added = True
if not has_been_added:
self.new_password.validators.append(
user_manager.password_validator)
# Validate field-validators
if not super(ResetPasswordForm, self).validate():
return False
# All is well
return True
from .tasks import send_email
def async_send_email(recipient, subject, html_message, text_message):
send_email.delay(recipient, subject, html_message, text_message)
db_adapter = SQLAlchemyAdapter(db, Account, UserAuthClass=AccountBasicAuth)
user_manager = UserManager(
db_adapter,
login_view_function=login_view,
forgot_password_view_function=forgot_password_view,
reset_password_form=ResetPasswordForm,
password_validator=password_validator,
send_email_function=async_send_email)
user_manager.init_app(app)
user_manager.hash_password = hash_password.__get__(user_manager,
UserManager)
user_manager.generate_password_hash = generate_password_hash.__get__(
user_manager, UserManager)
user_manager.verify_password = verify_password.__get__(
user_manager, UserManager)
user_manager.login_manager.user_callback = login_manager_usercallback
orig_unauthenticated_view_function = user_manager.unauthenticated_view_function
def unauthenticated_view_function():
if request.is_xhr:
return jsonify({
'success': False,
'error_code': errors.user_unauthenticated
})
else:
return orig_unauthenticated_view_function()
setattr(user_manager, 'unauthenticated_view_function',
unauthenticated_view_function)
orig_unauthorized_view_function = user_manager.unauthorized_view_function
def unauthorized_view_function():
if request.is_xhr:
return jsonify({
'success': False,
'error_code': errors.operation_unauthorized
})
else:
return orig_unauthorized_view_function()
setattr(user_manager, 'unauthorized_view_function',
unauthorized_view_function)
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
# return request.accept_languages.best_match(translations)
# @babel.localeselector
#def get_locale():
# if request.args.get('lang'):
# session['lang'] = request.args.get('lang')
# return session.get('lang', 'tr')
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
def allowed(self, access_level):
return self.access >= access_level
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Gonderi(db.Model):
__tablename__ = 'gonderiler'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
baslik = db.Column(db.String(40))
baslikk = db.Column(db.String(40))
govde = db.Column(db.String(140))
timestamp = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
class Otel(db.Model):
__tablename__ = 'Otel'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
otel = db.Column(db.String(40))
otelpuan = db.Column(db.String(40))
otelf = db.Column(db.String(40))
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Sepet:
urunler = {}
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
engine = create_engine('sqlite:///basic_app.sqlite')
meta = MetaData(engine, reflect=True)
table = meta.tables['gonderiler']
table_otel = meta.tables['Otel']
@user_logged_in.connect_via(app)
def _after_login_hook(sender, user, **extra):
sender.logger.info('user logged in')
global sepet
sepet = Sepet()
@user_logged_out.connect_via(app)
def _after_logout_hook(sender, user, **extra):
sender.logger.info('user logged out')
#global sepet
#del sepet
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template('anasayfa.html')
@app.route(
'/sepet_islemleri', methods=['POST', 'GET']
) # /otel_ekle rotasını oluşturuyoruz,post ve get metotlarını kullanacağımızı belirtiyoruz.
@login_required # Kullanıcı girişi gerekli tanımlamasını yapıyoruz.
def sepet_islemleri():
global sepet #sepet değişkenini tanımlıyoruz.
sepet = Sepet() #sepet değişkenimizi Sepet() Class'ına eşitliyoruz.
db_uri = 'sqlite:///basic_app.sqlite' # SQLITE Bağlantımız.
engine = create_engine(db_uri) #db_uri çalıştırıyoruz.
conn = engine.connect() # Bağlantıyı açıyoruz.
if request.method == 'POST': # If bloku ile çağırılan metodun metodunun 'POST' olma durumunu kontrol ediyoruz.
try:
oid = request.form[
'otelID'] #Bağlantılı html sayfasından name='otelID' olan içeriği oid değişkenine atıyoruz.
qry = db.session.query(Otel).filter(Otel.id == oid).all(
) # qry isimli sorgu oluşturuyoruz ve bu sorguda Otel tablosunun 'otelid'si oid değişkenimize eşit olanı çekiyoruz.
sepet.urunler[
oid] = qry # 1-1 indexe oid 1-2 indexe qry sorgumuzu atıyoruz
except: # Olası hatalar için except bloku.
msg = "Otel ekleme işlemi sırasında hata oluştu"
return render_template(
'/sepeti_gor.html', sepet_ici=sepet.urunler
) # 'sepeti_gor.html' template'ini sepet_ici=sepet.urunler atamasıyla geri döndürüyoruz.
@app.route('/admin_page')
@roles_required('Admin') #Use of @roles_required decorator
def admin_page():
return render_template('anasayfa-admin.html')
#------------------------------------------------------------------#
@app.route('/otel_sayfasi') # /otel_sayasi roasını oluşturuyoruz.
@roles_required('Admin') # 'Admin' rolü gerekli tanımlamasını yapıyoruz.
def otel_sayfasi():
return render_template(
'otel-ekle.html'
) # 'otel-ekle.html' template'ini geri döndürüyoruz.
@app.route(
'/otel_ekle', methods=['POST', 'GET']
) # /otel_ekle rotasını oluşturuyoruz,post ve get metotlarını kullanacağımızı belirtiyoruz.
@roles_required('Admin') # 'Admin' rolü gerekli tanımlamasını yapıyoruz.
def otel_ekle():
if request.method == 'POST': # If bloku ile çağırılan metodun metodunun 'POST' olma durumunu kontrol ediyoruz.
try:
otel = request.form[
'otel'] #Bağlantılı html sayfasından name='otel' olan içeriği otel değişkenine atıyoruz.
otelPu = request.form[
'otelP'] #Bağlantılı html sayfasından name='otelP' olan içeriği otelPu değişkenine atıyoruz.
otelFi = request.form[
'otelF'] #Bağlantılı html sayfasından name='otelF' olan içeriği otelFi değişkenine atıyoruz.
otelE = Otel( # otelE değişkeninde 'Otel' tablosunun otel,otelpuan,otelf alanlarına çektiğimiz verileri giriyoruz.
otel=otel,
otelpuan=otelPu,
otelf=otelFi)
db.session.add(
otelE) #otelE değişkenini veritabanımıza ekliyoruz.
db.session.commit()
msg = "Otel başarı ile eklendi"
except: # Olası hatalar için except bloku.
msg = "Otel ekleme işlemi sırasında hata oluştu"
finally: # Her iki koşulda da çalışacak blok.
return render_template("otel-ekle.html", msg=msg)
@app.route('/otel_listele')
def otel_listele():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
selectt = db.select([
table_otel.c.id, table_otel.c.otel, table_otel.c.otelpuan,
table_otel.c.otelf
])
rows = conn.execute(selectt)
return render_template("otel_listele.html", rows=rows)
@app.route('/otel_listele_admin')
def otel_listele_admin():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
selectt = db.select([
table_otel.c.id, table_otel.c.otel, table_otel.c.otelpuan,
table_otel.c.otelf
])
rows = conn.execute(selectt)
return render_template("otel_listele_admin.html", rows=rows)
@app.route('/otel_sil', methods=['POST', 'GET'])
@roles_required('Admin')
def otel_sil():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
selectt = db.select([
table_otel.c.id, table_otel.c.otel, table_otel.c.otelpuan,
table_otel.c.otelf
])
rows = conn.execute(selectt)
if request.method == 'POST':
try:
otelid = request.form['otelID']
del_st = table_otel.delete().where(table_otel.c.id == otelid)
res = conn.execute(del_st)
sel_st = table_otel.select()
msg = "otel başarı ile silindi"
except:
msg = "otel silme işlemi sırasında hata oluştu"
finally:
return redirect(url_for('otel_sil'))
return render_template("otel_sil.html", rows=rows)
@app.route('/otel_sil_hepsi', methods=['POST', 'GET'])
@roles_required('Admin')
def otel_sil_hepsi():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
selectt = db.select([
table_otel.c.id, table_otel.c.otel, table_otel.c.otelpuan,
table_otel.c.otelf
])
rows = conn.execute(selectt)
if request.method == 'POST':
try:
del_st = table_otel.delete()
res = conn.execute(del_st)
msg = "otel başarı ile silindi"
except:
msg = "otel silme işlemi sırasında hata oluştu"
finally:
return redirect(url_for('otel_sil'))
return render_template("otel_sil.html", rows=rows)
@app.route('/otel_guncelle', methods=['POST', 'GET'])
@roles_required('Admin')
def otel_guncelle():
db_uri = 'sqlite:///basic_app.sqlite'
engine = create_engine(db_uri)
conn = engine.connect()
selectt = db.select([
table_otel.c.id, table_otel.c.otel, table_otel.c.otelpuan,
table_otel.c.otelf
])
rows = conn.execute(selectt)
if request.method == 'POST':
try:
oid = request.form['id']
otelY = request.form['otelY']
otelFiyat = request.form['otelYF']
otelPuan = request.form['otelYP']
upt_st = update(table_otel).where(
table_otel.c.id == oid).values(otel=otelY,
otelf=otelFiyat,
otelpuan=otelPuan)
res = conn.execute(upt_st)
msg = "otel başarı ile güncellendi"
except:
msg = "otel güncelleme işlemi sırasında hata oluştu"
finally:
return redirect('otel_guncelle')
return render_template("otel_guncelle.html", rows=rows)
return app
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
# return request.accept_languages.best_match(translations)
# @babel.localeselector
#def get_locale():
# if request.args.get('lang'):
# session['lang'] = request.args.get('lang')
# return session.get('lang', 'tr')
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
app = Flask(__name__)
app.config.from_object('spelinkyapp.config')
babel = Babel(app)
csrf = CsrfProtect(app)
mail = Mail(app)
admin = Admin(app)
api_manager = APIManager(app, flask_sqlalchemy_db=db)
db.init_app(app)
with app.app_context():
db.create_all()
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
if not User.query.filter_by(username='******').first():
user1 = User(username='******', email='*****@*****.**', active=True,
password=user_manager.hash_password('password'))
db.session.add(user1)
db.session.commit()
admin.add_view(ModelView(Link, db.session))
def get_locale():
translations = [str(translation) for translation in babel.list_translations()]
return request.accept_languages.best_match(translations)
from spelinkyapp import views
views.generate_apis(api_manager)
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try: app.config.from_object('local_settings')
except: pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
mail = Mail(app) # Initialize Flask-Mail
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_profile_id = db.Column(db.Integer(), db.ForeignKey('user_profile.id', ondelete='CASCADE'))
# User authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# Relationships
user_profile = db.relationship('UserProfile', uselist=False, foreign_keys=[user_profile_id])
class UserProfile(db.Model):
id = db.Column(db.Integer, primary_key=True)
# User information
first_name = db.Column(db.String(50), nullable=False, default='')
last_name = db.Column(db.String(50), nullable=False, default='')
# Relationships
roles = db.relationship('Role', secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
# Define Role model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define UserRoles model
class UserRoles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_profile_id = db.Column(db.Integer(), db.ForeignKey('user_profile.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE'))
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User, UserProfileClass=UserProfile)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username=='user007').first():
user_profile1 = UserProfile(first_name='James', last_name='Bond')
db.session.add(user_profile1)
user1 = User(user_profile=user_profile1, username='******',
email='*****@*****.**', password=user_manager.hash_password('Password1'),
active=True)
db.session.add(user1)
user_profile1.roles.append(Role(name='secret'))
user_profile1.roles.append(Role(name='agent'))
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Home page</h2>
<p>This page can be accessed by anyone.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def members_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Members page</h2>
<p>This page can only be accessed by authenticated users.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
# The Special page requires a user with 'special' and 'sauce' roles or with 'special' and 'agent' roles.
@app.route('/special')
@roles_required('secret', ['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Special Page</h2>
<p>This page can only be accessed by user007.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
return app
# Password hashing
from flask_bcrypt import Bcrypt
bcrypt = Bcrypt(app)
app.config.from_object('config')
db = SQLAlchemy(app)
from app import views, models
# LoginManager parts
import os
from flask.ext.login import LoginManager
from config import basedir
# Setup Flask-User
from flask_user import login_required, UserManager, UserMixin, SQLAlchemyAdapter
from app.models import User, Role, Abstract
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
from datetime import date
today = date.today()
if not User.query.filter(User.email=='*****@*****.**').first():
u = User(email='*****@*****.**', affiliation='University of Oxford', first_name='Romesh',last_name='Abeysuriya',active=True,password=user_manager.hash_password('Asdf11'),confirmed_at=today,is_admin=True)
u.roles.append(Role(name='admin'))
db.session.add(u)
db.session.commit()
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
mail = Mail(app) # Initialize Flask-Mail
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
# Define the User data model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# User authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
reset_password_token = db.Column(db.String(100),
nullable=False,
server_default='')
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# User information
is_enabled = db.Column(db.Boolean(),
nullable=False,
server_default='0')
first_name = db.Column(db.String(100),
nullable=False,
server_default='')
last_name = db.Column(db.String(100),
nullable=False,
server_default='')
# Relationships
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
def is_active(self):
return self.is_enabled
# Define the Role data model
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles data model
class UserRoles(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
# Reset all the database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
# Create 'user007' user with 'secret' and 'agent' roles
if not User.query.filter(User.username == 'user007').first():
user1 = User(username='******',
email='*****@*****.**',
is_enabled=True,
password=user_manager.hash_password('Password1'))
user1.roles.append(Role(name='secret'))
user1.roles.append(Role(name='agent'))
db.session.add(user1)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Home page</h2>
<p>This page can be accessed by anyone.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def members_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Members page</h2>
<p>This page can only be accessed by authenticated users.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
# The Special page requires a user with 'special' and 'sauce' roles or with 'special' and 'agent' roles.
@app.route('/special')
@roles_required('secret',
['sauce', 'agent']) # Use of @roles_required decorator
def special_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Special Page</h2>
<p>This page can only be accessed by user007.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
<p><a href={{ url_for('special_page') }}>Special page</a> (login with username 'user007' and password 'Password1')</p>
{% endblock %}
""")
return app
# Setup Flask-User
from flask_user import login_required, UserManager, UserMixin, SQLAlchemyAdapter
from app.models import User, Role, Abstract
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
from datetime import date
today = date.today()
names = [
'Siobhan Seale', 'Marcel Seegmiller', 'Lita Alessi', 'Wiley Spight',
'Minerva Rettig', 'Iluminada Lipari', 'Moses Pidgeon', 'Tisa Dedeaux',
'Francisco Kurland', 'Tammara Sinner', 'Charles Strong', 'Zena Morfin',
'Marlin Finklea', 'Josefine Kilbane', 'Sina Hunter', 'Karren Dunkley',
'Shea Cutter', 'Eugenie Persinger', 'Velia Heaton'
]
for n in names:
ns = n.split()
u = User(email='*****@*****.**' % (ns[0], ns[1]),
affiliation='University of Oxford',
first_name=ns[0],
last_name=ns[1],
active=True,
password=user_manager.hash_password('a'),
confirmed_at=today,
is_admin=False)
db.session.add(u)
db.session.commit()
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
username = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
transactions = db.relationship('Transactions',
backref=backref('users', uselist=False))
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class Transactions(db.Model):
__tablename__ = 'transactions'
id = db.Column(db.Integer(), primary_key=True)
company = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
amount = db.Column(db.Integer())
status = db.Column(db.Integer())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create 'user' user with user role, append two associated transaction records
if not User.query.filter(User.username == 'user').first():
user = User(
username='******',
password=user_manager.hash_password('Password1'),
)
user.transactions.append(
Transactions(company='Apple', amount=10, status=0))
user.transactions.append(
Transactions(company='Apple', amount=20, status=0))
db.session.add(user)
db.session.commit()
# Create 'admin' user with 'Admin' role
if not User.query.filter(User.username == 'admin').first():
user = User(
username='******',
password=user_manager.hash_password('admin'),
)
user.roles.append(Role(name='Admin'))
db.session.add(user)
db.session.commit()
# Create 'comp' user with 'comp' role
if not User.query.filter(User.username == 'comp').first():
user = User(
username='******',
password=user_manager.hash_password('comp'),
)
user.roles.append(Role(name='Compliance'))
db.session.add(user)
db.session.commit()
# Create 'user_test' user with 'user' role
if not User.query.filter(User.username == 'user_test').first():
user = User(
username='******',
password=user_manager.hash_password('user_test'),
)
user.roles.append(Role(name='User'))
db.session.add(user)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template('home_page.html')
# The user page requires an 'user' role.
@app.route('/user')
@roles_required('User')
def user_page():
user_id = current_user.id
pending = Transactions.query.filter(Transactions.user_id == user_id,
Transactions.status == 0).all()
approved = Transactions.query.filter(Transactions.user_id == user_id,
Transactions.status == 1).all()
rejected = Transactions.query.filter(Transactions.user_id == user_id,
Transactions.status == 2).all()
return render_template('user_page.html',
pending=pending,
approved=approved,
rejected=rejected)
#user submits transaction record
@app.route('/add_trans', methods=['POST'])
def add_trans():
company = request.form['company']
num_shares = request.form['num_shares']
user = User.query.filter(User.id == current_user.id).first()
user.transactions.append(
Transactions(company=company, amount=num_shares, status=0))
db.session.commit()
flash("Transaction Submitted!")
return redirect(url_for('user_page'))
# The compliance page requires an 'compliance' role.
@app.route('/compliance')
@roles_required('Compliance')
def member_page():
pending = Transactions.query.filter(Transactions.status == 0).all()
approved = Transactions.query.filter(Transactions.status == 1).all()
rejected = Transactions.query.filter(Transactions.status == 2).all()
return render_template('compliance_page.html',
pending=pending,
approved=approved,
rejected=rejected)
#compliance can reject/approve transactions, reload page after submitting decision
@app.route('/decide_trans', methods=['POST'])
def decide_trans():
trans_id = request.form['trans_id']
decision = 1 if request.form['submit_button'] == "Approve" else 2
trans = Transactions.query.filter(Transactions.id == trans_id).first()
trans.status = decision
db.session.commit()
pending = Transactions.query.filter(Transactions.status == 0).all()
approved = Transactions.query.filter(Transactions.status == 1).all()
rejected = Transactions.query.filter(Transactions.status == 2).all()
return render_template('compliance_page.html',
pending=pending,
approved=approved,
rejected=rejected)
# The Admin page requires an 'Admin' role.
@app.route('/admin')
@roles_required('Admin')
def admin_page():
return render_template('admin_page.html')
# admin can add new user/compliance, show 'user exists' if username has duplicates
@app.route('/add_new', methods=['POST'])
def add_new():
role = request.form['role']
username = request.form['username']
password = request.form['password']
if not User.query.filter(User.username == username).first():
user = User(
username=username,
password=user_manager.hash_password(password),
)
stored_role = Role.query.filter(Role.name == role).first()
user.roles.append(stored_role)
db.session.add(user)
db.session.commit()
return render_template_string(role)
else:
return render_template_string('user exists')
return app
def create_app():
""" Flask application factory """
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'), nullable=False, unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(), db.ForeignKey('roles.id', ondelete='CASCADE'))
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Home page{%endtrans%}</h2>
<p><a href={{ url_for('user.register') }}>{%trans%}Register{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Sign in{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Home Page{%endtrans%}</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Member Page{%endtrans%}</a> (login_required: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin Page{%endtrans%}</a> (role_required: [email protected] / Password1')</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def member_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Members page{%endtrans%}</h2>
<p><a href={{ url_for('user.register') }}>{%trans%}Register{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Sign in{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Home Page{%endtrans%}</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Member Page{%endtrans%}</a> (login_required: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin Page{%endtrans%}</a> (role_required: [email protected] / Password1')</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
# The Admin page requires an 'Admin' role.
@app.route('/admin')
@roles_required('Admin') # Use of @roles_required decorator
def admin_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Admin Page{%endtrans%}</h2>
<p><a href={{ url_for('user.register') }}>{%trans%}Register{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Sign in{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Home Page{%endtrans%}</a> (accessible to anyone)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Member Page{%endtrans%}</a> (login_required: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin Page{%endtrans%}</a> (role_required: [email protected] / Password1')</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
return app
def create_app():
# Create Flask app load app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask-BabelEx
babel = Babel(app)
# Initialize Flask-SQLAlchemy
@babel.localeselector
def get_locale():
translations = [str(translation) for translation in babel.list_translations()]
# return request.accept_languages.best_match(translations)
# @babel.localeselector
#def get_locale():
# if request.args.get('lang'):
# session['lang'] = request.args.get('lang')
# return session.get('lang', 'tr')
db = SQLAlchemy(app)
# Define the User data-model.
# NB: Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
email = db.Column(db.String(255, collation='NOCASE'), nullable=False, unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'), nullable=False, server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship('Role', secondary='user_roles')
# Define the Role data-model
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
# Define the UserRoles association table
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(), db.ForeignKey('roles.id', ondelete='CASCADE'))
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
@app.route('/')
def home_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Ana sayfa{%endtrans%}</h2>
<h1>{%trans%}Bu web sitesinin anasayfasıdır{%endtrans%}</h1>
<p><a href={{ url_for('user.register') }}>{%trans%}Kayıt ol{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Giriş Yap{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Ana sayfa{%endtrans%}</a> (Herkes erişebilir)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Üye sayfası{%endtrans%}</a> (Giriş gerekli: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin sayfası{%endtrans%}</a> (Rol gerekli: [email protected] / Password1)</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Çıkış{%endtrans%}</a></p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def member_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Üyeler sayfası {%endtrans%}</h2>
<h1>{%trans%}Sisteme giriş yapanlar bu sayfayı görüntüleyebilir{%endtrans%}</h1>
<p><a href={{ url_for('user.register') }}>{%trans%}Kayıt ol{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Giriş Yap{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Ana sayfa{%endtrans%}</a> (Herkes erişebilir)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Üye sayfası{%endtrans%}</a> (Giriş gerekli: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin sayfası{%endtrans%}</a> (Rol gerekli: [email protected] / Password1)</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Çıkış{%endtrans%}</a></p>
{% endblock %}
""")
# The Admin page requires an 'Admin' role.
@app.route('/admin')
@roles_required('Admin') #Use of @roles_required decorator
def admin_page():
return render_template_string("""
{% extends "flask_user_layout.html" %}
{% block content %}
<h2>{%trans%}Admin Sayfası{%endtrans%}</h2>
<h1>{%trans%}Bu yalnızca adminlerin giriş yapabildiği bir sayfadır{%endtrans%}</h1>
<p><a href={{ url_for('user.register') }}>{%trans%}Kayıt ol{%endtrans%}</a></p>
<p><a href={{ url_for('user.login') }}>{%trans%}Giriş Yap{%endtrans%}</a></p>
<p><a href={{ url_for('home_page') }}>{%trans%}Ana sayfa{%endtrans%}</a> (Herkes erişebilir)</p>
<p><a href={{ url_for('member_page') }}>{%trans%}Üye sayfası{%endtrans%}</a> (Giriş gerekli: [email protected] / Password1)</p>
<p><a href={{ url_for('admin_page') }}>{%trans%}Admin sayfası{%endtrans%}</a> (Rol gerekli: [email protected] / Password1)</p>
<p><a href={{ url_for('user.logout') }}>{%trans%}Çıkış{%endtrans%}</a></p>
{% endblock %}
""")
return app
db_adapter = SQLAlchemyAdapter(db, User, UserInvitationClass=UserInvitation)
user_manager = UserManager(db_adapter, app)
@user_registered.connect_via(app)
def after_registered_hook(sender, user, user_invite):
sender.logger.info("USER REGISTERED")
@user_sent_invitation.connect_via(app)
def after_invitation_hook(sender, **extra):
sender.logger.info("USER SENT INVITATION")
# Create user admin default
if not User.query.filter(User.username==os.getenv('ADMIN_USER')).first():
user1 = User(username=os.getenv('ADMIN_USER'), email=os.getenv('ADMIN_EMAIL'), is_enabled=True,
password=user_manager.hash_password(os.getenv('ADMIN_PASSWORD')))
user1.roles.append(Role(name='admin'))
db.session.add(user1)
db.session.commit()
# This part above is based on the flask-user example under BSD license
# Blueprint
admin = Blueprint('admin', __name__, template_folder='./templates', static_folder="./static", static_url_path="/static")
"""
## Add addons
from ..addon_1 import addon_1 as addon_1_blueprint
def register_sub_blueprint_admin(app, url_prefix_parent="/admin"):
app.register_blueprint(data_task_blueprint, url_prefix=url_prefix_parent+"/data_task")
dropzone = Dropzone(app)
# Setup Flask-User and specify the User dataset-model
user_manager = UserManager(app, db, User)
# Create all database tables
db.create_all()
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
username='******',
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(
username='******',
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
from loan.functions import modify_home_ownership, modify_purpose, modify_term, modify_time_of_employment
user_manager = UserManager(app, db, User)
db_manager = DBManager(app,
db,
User,
UserEmailClass=None,
UserInvitationClass=None,
RoleClass=Role)
db.create_all()
if len(User.query.all()) < 1:
user = User(username='******',
email='*****@*****.**',
password=user_manager.hash_password('asdfghjkl'),
active=True)
user.roles.append(Role(name='Admin'))
db.session.add(user)
db.session.commit()
profile = Profile(firstname='Peter',
middlename='Mike',
lastname='Ahueze',
gender='male',
nationality='Nigerian',
user_id=user.id)
db.session.add(profile)
