from flask_user import UserManager user_manager = UserManager(None, None, None)
def create_app():
""" Flask application factory """
#ayar yapılandırmamızı içe aktarıyoruz
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
db = SQLAlchemy(app)
#tablolarımızı oluşturuyoruz
class User(db.Model, UserMixin):
__tablename__ = 'users'
kullanici_id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), nullable=False, unique=True)
email_confirmed_at = db.Column(db.DateTime())
password = db.Column(db.String(50), nullable=False)
kullanici_adi = db.Column(db.String(50))
kullanici_soyadi = db.Column(db.String(50))
kullanici_tcno = db.Column(db.Integer())
kullanici_telno = db.Column(db.Integer())
kullanici_puan = db.Column(db.Float(), server_default='0')
kullanici_rol = db.Column('adminlik', db.Boolean())
def __init__(self, email, password, kullanici_adi, kullanici_soyadi,
kullanici_tcno, kullanici_telno, email_confirmed_at,
kullanici_rol):
self.email = email
self.password = password
self.kullanici_adi = kullanici_adi
self.kullanici_soyadi = kullanici_soyadi
self.kullanici_tcno = kullanici_tcno
self.kullanici_telno = kullanici_telno
self.email_confirmed_at = email_confirmed_at
self.kullanici_rol = kullanici_rol
class Otel(db.Model):
__tablename__ = 'oteller'
otel_id = db.Column(db.Integer(), primary_key=True)
otel_adi = db.Column(db.String(100), nullable=False)
otel_sehir = db.Column(db.Integer(), nullable=False)
otel_yildizi = db.Column(db.Integer(), nullable=False)
def __init__(self, otel_adi, otel_sehir, otel_yildizi):
self.otel_adi = otel_adi
self.otel_sehir = otel_sehir
self.otel_yildizi = otel_yildizi
class Oda(db.Model):
__tablename__ = 'odalar'
oda_id = db.Column(db.Integer(), primary_key=True)
otel_id = db.Column(
db.Integer, db.ForeignKey('oteller.otel_id', ondelete='CASCADE'))
oda_adi = db.Column(db.String(50), nullable=False)
oda_tipi = db.Column(db.String(50), nullable=False)
oda_fiyat = db.Column(db.Float())
oda_durum = db.Column(db.Boolean(), server_default='0')
def __init__(self, otel_id, oda_adi, oda_tipi, oda_fiyat):
self.otel_id = otel_id
self.oda_adi = oda_adi
self.oda_tipi = oda_tipi
self.oda_fiyat = oda_fiyat
class Sepet(db.Model):
__tablename__ = 'sepetler'
sepet_id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(
db.Integer(),
db.ForeignKey('users.kullanici_id', ondelete='CASCADE'))
oda_id = db.Column(db.Integer(),
db.ForeignKey('odalar.oda_id', ondelete='CASCADE'))
otel_id = db.Column(
db.Integer, db.ForeignKey('oteller.otel_id', ondelete='CASCADE'))
toplam_tutar = db.Column(db.Float())
rezerve_tarih = db.Column(db.DateTime(), nullable=False)
giris_tarih = db.Column(db.Date())
cikis_tarih = db.Column(db.Date())
kalinacak_gun = db.Column(db.Integer())
sepet_durum = db.Column(db.Boolean(), server_default='0')
def __init__(self, user_id, otel_id, oda_id, toplam_tutar,
rezerve_tarih, giris_tarih, cikis_tarih, kalinacak_gun):
self.user_id = user_id
self.otel_id = otel_id
self.oda_id = oda_id
self.toplam_tutar = toplam_tutar
self.rezerve_tarih = rezerve_tarih
self.giris_tarih = giris_tarih
self.cikis_tarih = cikis_tarih
self.kalinacak_gun = kalinacak_gun
user_manager = UserManager(app, db, User)
#veritabanımızı oluşturuyor ve tablolara erişim
#için takma isimler veriyoruz
db.create_all()
engine = create_engine('sqlite:///otel_rezervasyon.sqlite')
meta = MetaData(engine, reflect=True)
table_users = meta.tables['users']
table_otel = meta.tables['oteller']
table_oda = meta.tables['odalar']
table_sepet = meta.tables['sepetler']
#sistemde admin kayıtlı değilse bir admin oluşturuyoruz
if not User.query.filter(User.email == '*****@*****.**').first():
#şifremizi hashli bir şekilde tutmak için fonksiyona tabi tutuyoruz
tmp_psw = '12345678'
tmp_psw = hashlib.md5(tmp_psw.encode())
tmp_psw = tmp_psw.hexdigest()
user = User(email='*****@*****.**',
password=tmp_psw,
email_confirmed_at=datetime.datetime.utcnow(),
kullanici_adi=None,
kullanici_soyadi=None,
kullanici_tcno=None,
kullanici_telno=None,
kullanici_rol=1)
db.session.add(user)
db.session.commit()
#anasayfaya yönlendirme fonksiyonumuzu oluşturuyoruz
@app.route('/')
def home_page():
return render_template("index.html")
#giriş yap fonksiyonumuzu oluşturuyoruz
#formdan gelen verileri veritabanındaki
#
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
email = request.form['email']
tmp_psw = request.form['password']
tmp_psw = hashlib.md5(tmp_psw.encode())
tmp_psw = tmp_psw.hexdigest()
password = tmp_psw
try:
sorgu1 = User.query.filter_by(email=email,
password=password).first()
if sorgu1 is not None:
global sorgu_kullanici_id
conn = engine.connect()
select_st = select([table_users.c.kullanici_id
]).where(table_users.c.email == email)
sorgu_kullanici_id = conn.execute(select_st).scalar()
sorgu2 = User.query.filter_by(email=email,
password=password,
kullanici_rol=1).first()
if sorgu2 is not None:
session['admin'] = True
session['logged_in'] = True
flash('Hoşgeldiniz')
return redirect(url_for('home_page'))
else:
flash('Kullanıcı adı veya şifre yanlış')
return redirect(url_for('home_page'))
except:
flash('Beklenmeyen bir hata oluştu!')
return redirect(url_for('home_page'))
else:
return redirect(url_for('home_page'))
@app.route('/rezerve_login', methods=['GET', 'POST'])
def rezerve_login():
if request.method == 'POST':
email = request.form['email']
tmp_psw = request.form['password']
tmp_psw = hashlib.md5(tmp_psw.encode())
tmp_psw = tmp_psw.hexdigest()
password = tmp_psw
try:
sorgu1 = User.query.filter_by(email=email,
password=password).first()
if sorgu1 is not None:
global sorgu_kullanici_id
conn = engine.connect()
select_st = select([table_users.c.kullanici_id
]).where(table_users.c.email == email)
sorgu_kullanici_id = conn.execute(select_st).scalar()
sorgu2 = User.query.filter_by(email=email,
password=password,
kullanici_rol=1).first()
if sorgu2 is not None:
session['admin'] = True
session['logged_in'] = True
flash('Hoşgeldiniz')
return redirect(url_for('rezerve'))
else:
flash('Kullanıcı adı veya şifre yanlış')
return redirect(url_for('rezerve'))
except:
flash('Beklenmeyen bir hata oluştu!')
return redirect(url_for('rezerve'))
else:
return redirect(url_for('rezerve'))
@app.route("/logout")
@login_required
def logout():
conn = engine.connect()
select_st = table_sepet.delete().where(
and_(table_sepet.c.user_id == sorgu_kullanici_id,
table_sepet.c.sepet_durum == 0))
conn.execute(select_st)
session.clear()
flash("Başarı ile çıkış yaptınız.")
return redirect(url_for('home_page'))
@app.route('/', methods=['GET', 'POST'])
def uye_ol():
if request.method == 'POST':
tmp_psw = request.form['parola']
tmp_psw = hashlib.md5(tmp_psw.encode())
tmp_psw = tmp_psw.hexdigest()
password = tmp_psw
try:
new_user = User(kullanici_tcno=request.form['tcno'],
kullanici_adi=request.form['adi'],
kullanici_soyadi=request.form['soyadi'],
kullanici_telno=request.form['telno'],
email=request.form['email'],
password=password,
kullanici_rol=0,
email_confirmed_at=datetime.datetime.utcnow())
db.session.add(new_user)
db.session.commit()
flash("Kayıt başarı ile eklendi")
except:
flash("Kayıt işlemi sırasında hata oluştu")
finally:
return redirect(url_for('home_page'))
@app.route('/uye_gor', methods=['GET', 'POST'])
@login_required
@admin_required
def uye_gor():
conn = engine.connect()
select_st = select([
table_users.c.kullanici_id, table_users.c.kullanici_adi,
table_users.c.kullanici_soyadi, table_users.c.kullanici_tcno,
table_users.c.email, table_users.c.kullanici_telno
]).where(table_users.c.adminlik == 0)
rows = conn.execute(select_st)
return render_template("uye_gor.html", rows=rows)
@app.route('/uye_sil/<id>')
@login_required
@admin_required
def uye_sil(id=0):
conn = engine.connect()
select_st = table_users.delete().where(
table_users.c.kullanici_id == id)
rows = conn.execute(select_st)
return redirect(url_for('uye_gor'))
@app.route('/otel_listele', methods=['GET', 'POST'])
@login_required
@admin_required
def otel_listele():
if request.method == 'POST':
new_otel = Otel(otel_adi=request.form['oteladi'],
otel_sehir=request.form['otelsehir'],
otel_yildizi=request.form['otelyildizi'])
db.session.add(new_otel)
db.session.commit()
return redirect(url_for('otel_listele'))
conn = engine.connect()
select_st = select([
table_otel.c.otel_id, table_otel.c.otel_adi,
table_otel.c.otel_sehir, table_otel.c.otel_yildizi
])
rows = conn.execute(select_st)
return render_template("otel_listele.html", rows=rows)
@app.route('/otel_duzenle/<id>', methods=['GET', 'POST'])
@login_required
@admin_required
def otel_duzenle(id=0):
if request.method == 'POST':
otel_adi = request.form['oteladi']
otel_sehir = request.form['otelsehir']
otel_yildizi = request.form['otelyildizi']
conn = engine.connect()
select_st1 = table_otel.update().where(
table_otel.c.otel_id == id).values(otel_adi=otel_adi,
otel_sehir=otel_sehir,
otel_yildizi=otel_yildizi)
conn.execute(select_st1)
return redirect(url_for('otel_listele'))
else:
conn = engine.connect()
select_st2 = select([
table_otel.c.otel_adi, table_otel.c.otel_sehir,
table_otel.c.otel_yildizi
]).where(table_otel.c.otel_id == id)
rows = conn.execute(select_st2)
return render_template("otel_duzenle.html",
tmp_otel_id=id,
rows=rows)
@app.route('/otel_sil/<id>')
@login_required
@admin_required
def otel_sil(id=0):
conn = engine.connect()
select_st = table_otel.delete().where(table_otel.c.otel_id == id)
rows = conn.execute(select_st)
return redirect(url_for('otel_listele'))
@app.route('/oda_listele', methods=['GET', 'POST'])
@login_required
@admin_required
def oda_listele():
if request.method == 'POST':
if request.form['btn'] == 'Ekle':
try:
new_oda = Oda(otel_id=request.form['id'],
oda_adi=request.form['odaadi'],
oda_tipi=request.form['odatipi'],
oda_fiyat=request.form['odafiyat'])
db.session.add(new_oda)
db.session.commit()
flash("Kayıt başarı ile eklendi")
return redirect(url_for('oda_listele'))
except:
flash("Kayıt işlemi sırasında hata oluştu")
elif request.form['btn'] == 'Seç':
otel_id = request.form['otel_id']
conn = engine.connect()
select_st = select(
[table_otel.c.otel_id, table_otel.c.otel_adi])
rows_otel = conn.execute(select_st)
select_st1 = select([
table_oda.c.oda_id, table_oda.c.oda_adi,
table_oda.c.otel_id, table_oda.c.oda_tipi,
table_oda.c.oda_fiyat
]).where(table_oda.c.otel_id == otel_id)
rows_oda = conn.execute(select_st1)
return render_template("oda_listele.html",
rows=rows_oda,
rows2=rows_otel,
otel_id=otel_id)
conn = engine.connect()
select_st = select([table_otel.c.otel_id, table_otel.c.otel_adi])
rows_otel = conn.execute(select_st)
return render_template("oda_listele.html", rows2=rows_otel)
@app.route('/oda_duzenle/<id>', methods=['GET', 'POST'])
@login_required
@admin_required
def oda_duzenle(id=0):
if request.method == 'POST':
oda_adi = request.form['odaadi']
oda_tipi = request.form['odatipi']
oda_fiyat = request.form['odafiyat']
conn = engine.connect()
select_st1 = table_oda.update().where(
table_oda.c.oda_id == id).values(oda_adi=oda_adi,
oda_tipi=oda_tipi,
oda_fiyat=oda_fiyat)
conn.execute(select_st1)
return redirect(url_for('oda_listele'))
else:
conn = engine.connect()
select_st2 = select([
table_oda.c.oda_id, table_oda.c.oda_adi, table_oda.c.oda_tipi,
table_oda.c.oda_fiyat
]).where(table_oda.c.oda_id == id)
rows = conn.execute(select_st2)
return render_template("oda_duzenle.html",
tmp_oda_id=id,
rows=rows)
@app.route('/oda_sil/<id>')
@login_required
@admin_required
def oda_sil(id=0):
conn = engine.connect()
select_st = table_oda.delete().where(table_oda.c.oda_id == id)
rows = conn.execute(select_st)
return redirect(url_for('oda_listele'))
@app.route('/rezerve', methods=['GET', 'POST'])
def rezerve():
conn = engine.connect()
j = table_oda.join(table_otel,
table_oda.c.otel_id == table_otel.c.otel_id)
stmt = select([
table_oda.c.oda_id, table_oda.c.oda_adi, table_oda.c.oda_tipi,
table_oda.c.oda_fiyat, table_otel.c.otel_sehir,
table_otel.c.otel_adi, table_oda.c.otel_id
]).select_from(j).where(table_oda.c.oda_durum == 0)
rows = conn.execute(stmt)
return render_template("rezerve.html", rows=rows)
@app.route('/sepet_ekle/<id>', methods=['GET', 'POST'])
@login_required
def sepet_ekle(id=0):
conn = engine.connect()
select_st1 = select([table_oda.c.oda_fiyat
]).where(table_oda.c.oda_id == id)
toplam_tutar = conn.execute(select_st1).scalar()
print('toplam tutar: ', toplam_tutar)
select_st2 = select([table_oda.c.otel_id
]).where(table_oda.c.oda_id == id)
otel_id = conn.execute(select_st2).scalar()
sepet = Sepet(user_id=sorgu_kullanici_id,
otel_id=otel_id,
oda_id=id,
toplam_tutar=toplam_tutar,
rezerve_tarih=datetime.datetime.utcnow(),
giris_tarih=None,
cikis_tarih=None,
kalinacak_gun=0)
db.session.add(sepet)
db.session.commit()
return redirect(url_for('sepet'))
@app.route('/sepet', methods=['GET', 'POST'])
@login_required
def sepet():
global sorgu_kullanici_puan
conn = engine.connect()
j = table_oda.join(table_otel,
table_oda.c.otel_id == table_otel.c.otel_id).join(
table_sepet,
table_oda.c.oda_id == table_sepet.c.oda_id)
sorgu1 = select([
table_sepet.c.sepet_id, table_oda.c.oda_id, table_oda.c.oda_adi,
table_oda.c.oda_tipi, table_oda.c.oda_fiyat,
table_otel.c.otel_sehir, table_otel.c.otel_adi, table_oda.c.otel_id
]).select_from(j).where(table_sepet.c.sepet_durum == 0)
rows = conn.execute(sorgu1)
sorgu2 = select([
table_users.c.kullanici_puan
]).where(table_users.c.kullanici_id == sorgu_kullanici_id)
sorgu_kullanici_puan = conn.execute(sorgu2).scalar()
sorgu_kullanici_puan = round(sorgu_kullanici_puan, 4)
return render_template("sepet.html",
rows=rows,
puan=sorgu_kullanici_puan)
@app.route('/sepet_sepet_tarih_sec/<id>/<odaid>', methods=['GET', 'POST'])
@login_required
def sepet_tarih_sec(id=None, odaid=None):
return render_template("sepet_onay.html", sepet_id=id, oda_id=odaid)
@app.route('/sepet_duzenle/<id>/<odaid>', methods=['GET', 'POST'])
@login_required
def sepet_duzenle(id=None, odaid=None):
if request.method == 'POST':
tmp_giris = request.form['giristarihi']
tmp_cikis = request.form['cikistarihi']
giris_liste = tmp_giris.split('-')
cikis_liste = tmp_cikis.split('-')
giris_tarih = date(int(giris_liste[0]), int(giris_liste[1]),
int(giris_liste[2]))
cikis_tarih = date(int(cikis_liste[0]), int(cikis_liste[1]),
int(cikis_liste[2]))
kalinacak_gun = request.form['kalinacakgun']
puan_kullanma_durumu = request.form['puan']
if puan_kullanma_durumu == '1':
conn = engine.connect()
select_st2 = select([
table_users.c.kullanici_puan
]).where(table_users.c.kullanici_id == sorgu_kullanici_id)
puan_kullanma_durumu = conn.execute(select_st2).scalar()
print('puan_kullanma_durumu: ', puan_kullanma_durumu)
else:
puan_kullanma_durumu = 0
print('puan_kullanma_durumu: ', puan_kullanma_durumu)
global sorgu_kazanilan_puan
conn = engine.connect()
select_st2 = select([table_oda.c.oda_fiyat
]).where(table_oda.c.oda_id == odaid)
birim_fiyat = conn.execute(select_st2).scalar()
print('birim fiyat: ', birim_fiyat)
toplam_tutar = float(kalinacak_gun) * birim_fiyat - float(
puan_kullanma_durumu)
sorgu_kazanilan_puan = toplam_tutar * 0.03 - puan_kullanma_durumu
print('kazanilan puan: ', sorgu_kazanilan_puan)
select_st1 = table_sepet.update().where(
table_sepet.c.sepet_id == id).values(
giris_tarih=giris_tarih,
cikis_tarih=cikis_tarih,
kalinacak_gun=kalinacak_gun,
toplam_tutar=toplam_tutar)
conn.execute(select_st1)
return redirect(url_for('sepet'))
@app.route('/sepet_onay/<id>', methods=['GET', 'POST'])
@login_required
def sepet_onay(id=0):
global sorgu_kullanici_puan
try:
conn = engine.connect()
tmp_tarihzaman = datetime.datetime.utcnow()
select_st1 = table_sepet.update().where(
table_sepet.c.sepet_id == id).values(
sepet_durum=1, rezerve_tarih=tmp_tarihzaman)
sorgu_kullanici_puan += sorgu_kazanilan_puan
select_st2 = table_users.update().where(
table_users.c.kullanici_id == sorgu_kullanici_id).values(
kullanici_puan=sorgu_kullanici_puan)
conn.execute(select_st1)
conn.execute(select_st2)
except:
flash('Önce tarih seçmelisiniz')
return redirect(url_for('sepet'))
@app.route('/sepet_sil/<id>', methods=['GET', 'POST'])
@login_required
def sepet_sil(id=0):
conn = engine.connect()
select_st1 = table_sepet.delete().where(table_sepet.c.sepet_id == id)
conn.execute(select_st1)
return redirect(url_for('sepet'))
@app.route('/islemlerim', methods=['GET', 'POST'])
@login_required
def islemler():
conn = engine.connect()
j = table_sepet.join(table_oda,
table_sepet.c.oda_id == table_oda.c.oda_id).join(
table_otel,
table_sepet.c.otel_id == table_otel.c.otel_id)
stmt = select([
table_otel.c.otel_adi, table_otel.c.otel_sehir,
table_otel.c.otel_id, table_oda.c.oda_adi, table_oda.c.oda_tipi,
table_sepet.c.giris_tarih, table_sepet.c.cikis_tarih,
table_sepet.c.kalinacak_gun, table_sepet.c.toplam_tutar,
table_sepet.c.rezerve_tarih
]).select_from(j).where(
and_(table_sepet.c.user_id == sorgu_kullanici_id,
table_sepet.c.sepet_durum == 1))
rows = conn.execute(stmt)
return render_template("islem.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-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)
# 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='')
# Create all database tables
db.create_all()
# Setup Flask-User and specify the User data-model
user_manager = UserManager(app, db, User)
# The Home page is accessible to anyone
@app.route('/')
def home_page():
# String-based templates
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 %}
""")
# The Members page is only accessible to authenticated users via the @login_required decorator
@app.route('/members')
@login_required # User must be authenticated
def member_page():
# String-based templates
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 %}
""")
return app
__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():
user = User(
email='*****@*****.**',
email_confirmed_at=datetime.datetime.utcnow(),
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()
@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():
if request.method=='POST':
if request.form['email']!='*****@*****.**' or request.form['sifre']!='admin':
if Kullanici.query.filter_by(email=request.form['email'],sifre=request.form['sifre']) is not None:
return redirect(url_for('anasayfa'))
else:
hata='Hatalı giriş yaptınız!'
else:
flash('giriş başarılı')
return redirect(url_for('admin'))
@app.route('/admin')
def admin():
return render_template("admin.html")
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'.
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
application.config['USER_AFTER_REGISTER_ENDPOINT'] = 'user.login'
application.config.from_pyfile('config.cfg')
db = SQLAlchemy(application)
mail = Mail(application)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
active = db.Column(db.Boolean(), nullable=False, server_default='0')
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, application)
@application.route('/')
def index():
return '<h1>This is the home page!</h1>'
@application.route("/pop_up_html")
def pop_up_html():
return render_template("/pop_up_html.html")
@application.route('/profile')
@login_required
def profile():
return '<h1>This is the protected profile page!</h1>'
if __name__ == '__main__':
# Forgot Password E-mails
app.config['USER_ENABLE_FORGOT_PASSWORD'] = True
# Changing Password E-mails
app.config['USER_ENABLE_CHANGE_PASSWORD'] = True
app.config['USER_SEND_PASSWORD_CHANGED_EMAIL'] = True
# Change Username E-Mails
app.config['USER_ENABLE_CHANGE_USERNAME'] = True
app.config['USER_SEND_USERNAME_CHANGED_EMAIL'] = True
db.init_app(app)
mail = Mail(app)
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app, register_form=MyRegisterForm)
##################################################
###### REST API Registration ###########
##################################################
## TODO: Register API...need to place this somewhere better.
## TODO: What is best practice on how to organize these?
api_manager = flask.ext.restless.APIManager(app, flask_sqlalchemy_db=db)
# TODO: Decide what all user information is appropriate to make available.
user_blueprint = api_manager.create_api(
User,
methods=['GET'],
exclude_columns=['password', 'reset_password_token'],
url_prefix='/api/v1')
site_blueprint = api_manager.create_api(Site,
def init_app(app):
"""
Initialize Flask applicaton
"""
# Initialize app config settings
app.config.from_object('tendril.frontend.startup.settings')
if app.testing:
# Disable CSRF checks while testing
app.config['WTF_CSRF_ENABLED'] = False
# Initialize Assets
from tendril.frontend.startup import assets # noqa
# Create Filters
def unicode_filter(s):
if not isinstance(s, unicode):
try:
s = unicode(s, 'utf-8')
except UnicodeDecodeError:
s = unicode(s, 'latin-1')
return s
app.jinja_env.filters['unicode'] = unicode_filter
def quote_filter(s):
return quote(s)
app.jinja_env.filters['quote'] = quote_filter
def unquote_filter(s):
return unquote(s)
app.jinja_env.filters['unquote'] = unquote_filter
def strip(s):
return s.strip()
app.jinja_env.filters['strip'] = strip
def monthname(s):
return arrow_locale.month_abbreviation(s)
app.jinja_env.filters['monthname'] = monthname
def latex_render_filter(s):
# TODO make this generic
if not isinstance(s, str):
s = str(s)
s = s.replace('$\pm$', '±')
return s
app.jinja_env.filters['latex_render'] = latex_render_filter
# TODO Consider using these filters to produce python-nvd3 graphs
# instead of having all of that mess in JS in the html templates.
from .helpers import lineplot_filter
app.jinja_env.filters['lineplot'] = lineplot_filter
from .helpers import histogram_filter
app.jinja_env.filters['histogram'] = histogram_filter
# Setup Flask-Mail
mail = Mail(app) # noqa
# Setup an error-logger to send emails to app.config.ADMINS
init_error_logger_with_email_handler(app)
# Setup Flask-User to handle user account related forms
from tendril.auth.db.model import UserAuth, User
from tendril.frontend.users.forms import MyRegisterForm
from tendril.frontend.users.views import user_profile_page
db_adapter = SQLAlchemyAdapter(db, User, UserAuthClass=UserAuth)
user_manager = UserManager(
db_adapter,
app, # noqa
register_form=MyRegisterForm,
user_profile_view_function=user_profile_page,
)
# Load all views.py files to register @app.routes() with Flask
from tendril.frontend.pages import views # noqa
from tendril.frontend.users import views # noqa
# Configure send_file
from tendril.utils.config import USE_X_SENDFILE
app.use_x_sendfile = USE_X_SENDFILE
# Register blueprints
from tendril.frontend.blueprints.expose import expose
app.register_blueprint(expose, url_prefix='/expose')
from tendril.frontend.blueprints.doc import doc
app.register_blueprint(doc, url_prefix='/doc')
from tendril.frontend.blueprints.gsymlib import gsymlib
app.register_blueprint(gsymlib, url_prefix='/gsymlib')
from tendril.frontend.blueprints.entityhub import entityhub
app.register_blueprint(entityhub, url_prefix='/entityhub')
from tendril.frontend.blueprints.conventions import conventions
app.register_blueprint(conventions, url_prefix='/conventions')
from tendril.frontend.blueprints.customs import customs
app.register_blueprint(customs, url_prefix='/sourcing/customs')
from tendril.frontend.blueprints.vendors import vendors
app.register_blueprint(vendors, url_prefix='/sourcing/vendors')
from tendril.frontend.blueprints.testing import testing
app.register_blueprint(testing, url_prefix='/testing')
from tendril.frontend.blueprints.production import production
app.register_blueprint(production, url_prefix='/production')
from tendril.frontend.blueprints.indent import indent
app.register_blueprint(indent, url_prefix='/inventory/indent')
from tendril.frontend.blueprints.inventory import inventory
app.register_blueprint(inventory, url_prefix='/inventory/location')
from tendril.frontend.blueprints.invtransforms import invtransforms
app.register_blueprint(invtransforms, url_prefix='/inventory/transform')
# Configure context processors
from tendril.frontend.startup import helpers
@app.teardown_appcontext
def shutdown_session(exception=None):
db.session.remove()
return app
mail = Mail(app)
limiter = Limiter(
app,
key_func=get_remote_address,
default_limits=["3000 per day", "20 per minute"]
)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
assets = Environment(app)
moment = Moment(app)
css = Bundle('css/custom-footer.css','css/bootstrap.css','css/blog.css',
'css/media.css',
filters='cssmin', output='gen/packed.css')
assets.register('css_all', css)
js = Bundle('js/infiniscroll.js','js/delete.js','js/jquery.serialize-object.min.js',
filters='jsmin', output='gen/packed.js')
assets.register('js_all', js)
from app import routes, models
user_manager = UserManager(app, db, models.User)
app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \
if app.config['ELASTICSEARCH_URL'] else None
def authinit(app):
userauth = Blueprint('userauth', __name__)
google_blueprint = make_google_blueprint(
client_id=app.config['globalConfig'].Config.get(
"OAuth", "GOOGLE_CLIENT_ID"),
client_secret=app.config['globalConfig'].Config.get(
"OAuth", "GOOGLE_CLIENT_SECRET"),
scope=[ #"https://www.googleapis.com/auth/plus.me",
"https://www.googleapis.com/auth/userinfo.email"
],
offline=True)
google_blueprint.backend = SQLAlchemyBackend(OAuth,
db.session,
user=current_user,
user_required=True)
user_manager = UserManager(app, db, Member)
user_manager.USER_ENABLE_AUTH0 = True
user_manager.unauthenticated_view = our_login
login_manager = LoginManager()
login_manager.login_view = "google.login"
login_manager.init_app(app)
login_manager.anonymous_user = AnonymousMember
@login_manager.user_loader
def load_user(user_id):
if not user_id.lower().endswith("@makeitlabs.com"):
logger.error("User {0} invalid for login".format(user_id))
return None
mid = user_id.split("@")[0]
mr = Member.query.filter(Member.member == mid).one_or_none()
if not mr:
logger.error("User {0} Found no member record".format(user_id))
logger.debug("User {0} loaded".format(user_id))
return mr
#return Member.get(user_id)
@userauth.route("/google_login")
def google_login():
if not google.authorized:
logger.debug("Not google authorized")
session['next_url'] = request.args.get('next')
return redirect(url_for("google.login"))
resp = google.get(SCOPE)
assert resp.ok, resp.text
return resp.text
@oauth_authorized.connect_via(google_blueprint)
def google_logged_in(blueprint, token):
resp = google.get("/oauth2/v2/userinfo")
#print "RESP",dir(resp)
#print "HEADERS",resp.headers
#print "REASON",resp.reason
#print "TEXT",resp.text
#print "NEXT",resp.next
#print "LINKS",resp.links
#print "URL",resp.url
#print "IS_REDIRECT",resp.is_redirect
if resp.ok:
account_info_json = resp.json()
email = account_info_json['email']
member = email.split("@")[0]
logger.debug("Google auth RESP for {0} {1}".format(email, member))
if not email.endswith("@makeitlabs.com"):
flash(
"Not a MakeIt Labs account - You must log in with your @makeitlabs.com email address",
'warning')
logger.error("Not a MakeIt Labs account " + str(email))
return redirect(url_for('empty'))
#query = Member.query.filter_by(Member.member.ilike(member))
#if not query:
query = Member.query.filter(Member.email.ilike(email))
try:
user = query.all()
if len(user) > 1:
flash(
"Error - Multiple accounts with same email - please seek assistance",
'warning')
logger.error("%s has multiple account (GUI Login)" % email)
return redirect(url_for('empty'))
if len(user) == 0:
flash("Error - No account found - please seek assistance",
'warning')
logger.error("No account matching %s for GUI login" %
email)
return redirect(url_for('empty'))
user = user[0]
sub = quickSubscriptionCheck(member_id=user.id)
#print "UserID %s SUB IS %s" % (user.id,sub)
if sub == "Active" or sub == "Grace Period":
if (UserRoles.query.filter(
UserRoles.member_id == user.id).count() >= 1):
login_user(user, remember=True)
flash("Welcome!")
return redirect(url_for('index'))
logintype = app.config['globalConfig'].Config.get(
'General', 'Logins')
if logintype == "resource":
if (AccessByMember.query.filter(
AccessByMember.member_id == user.id,
AccessByMember.level >=
AccessByMember.LEVEL_TRAINER).count() == 0):
flash("Only resource managers may log in")
logger.error("Only resource managers may log in " +
str(email))
else:
login_user(user, remember=True)
else:
flash("Welcome!")
login_user(user, remember=True)
return redirect(url_for('index'))
else:
flash("Login Denied - " + str(sub), 'danger')
logger.error("Login Denied - " + str(email) + " is " +
str(sub))
return redirect(url_for('empty'))
except NoResultFound:
flash(
"Email adddress " + str(email) +
" not found in member database", "warning")
logger.error("Email adddress " + str(email) +
" not found in member database")
return redirect(url_for('empty'))
else:
logger.error("Google auth RESP is NOT okay")
@userauth.route('/google_logout')
def google_logout():
"""Revokes token and empties session."""
if google.authorized:
try:
google.get(
'https://accounts.google.com/o/oauth2/revoke',
params={'token': google.token['access_token']},
)
except InvalidClientIdError: # token expiration
del google.token
flash("OAuth error: Invalid Client ID", 'danger')
redirect(url_for('main.index'))
session.clear()
logout_user()
return redirect(url_for('main.index'))
app.register_blueprint(google_blueprint, url_prefix="/google_login")
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()
# The Home page is accessible to anyone
@app.route('/')
def home():
veriler=User.query.all()
return render_template('/index.html',veriler=verile)
@app.route('/üye')
def uye():
return render_template('/üye.html'r)
@app.route('/add',methods=["POST"])
def adduser():
email=request.form.get("e-mail")
sifre=request.form.get("sifre")
email_confirmed_at=datetime.datetime.utcnow()
newuser=User(email=email,password=sifre,email_confirmed_at=email_confirmed_at)
db.session.add(newuser)
db.session.commit()
return redirect(url_for("uye"))
return app
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_user import UserManager, SQLAlchemyAdapter
from flask_wtf import CSRFProtect
from wtforms.fields import HiddenField
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
app.config['WTF_CSFR_ENABLED'] = True
CSRFProtect(app)
def is_hidden_field_filter(field):
return isinstance(field, HiddenField)
app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter
#Flask User
from app.models import User
from app.forms import SomeRegisterForm
from app.views import user_profile_page
db_adapter = SQLAlchemyAdapter(db,User)
user_manager = UserManager(db_adapter, app, register_form=SomeRegisterForm,
user_profile_view_function=user_profile_page)
from app import views, models
def create_app(config=None, extra_config_settings={}, min_db_connections=1):
"""Create a Flask applicaction.
"""
# Instantiate Flask
# Load App Config settings
# Load common settings from 'app/settings.py' file
app.config.from_object('app.settings')
# Load local settings from 'app/local_settings.py'
if config:
app.config.from_object("app." + config)
# Load extra config settings from 'extra_config_settings' param
app.config.update(extra_config_settings)
app.config["SQLALCHEMY_DATABASE_URI"] = 'postgresql://{}:{}@{}/{}'.format(
app.config["DB_USER"], app.config["DB_PASS"], app.config["DB_HOST"],
app.config["SYSTEM_DATABASE"])
#get connections for the main databases (Non Flask-SQLAlchemy)
get_databases(databases, app, min_db_connections)
# Setup Flask-Extensions -- do this _after_ app config has been loaded
#database.init_app(app)
# Setup Flask-SQLAlchemy
db.init_app(app)
#work out modules
root = app.root_path
modules_folder = os.path.join(root, "modules")
template_folders = []
for folder in app.config["MODULES"]:
module_folder = os.path.join(modules_folder, folder)
if os.path.isdir(module_folder):
load_module(app, module_folder)
template_folders.append(
os.path.join(root, "modules", folder, "templates"))
my_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader(template_folders),
])
app.jinja_loader = my_loader
app.config['MLV_MAIN_PROJECTS'] = []
for p in app.config['MLV_PROJECTS']:
im = app.config['MLV_PROJECTS'][p].get("import")
#legacy
if im:
importlib.import_module(im)
if app.config['MLV_PROJECTS'][p].get("main_project"):
app.config['MLV_MAIN_PROJECTS'].append(p)
#uplo
celery.conf.update(app.config)
# Setup Flask-Migrate
#migrate.init_app(app, db)
# Setup Flask-Mail
mail.init_app(app)
# Setup WTForms CSRFProtect
csrf_protect.init_app(app)
# Register blueprints
from app.main import main
app.register_blueprint(main, url_prefix="/")
from app.meths import meths
app.register_blueprint(meths, url_prefix="/meths")
csrf_protect.exempt(meths)
# Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html
from wtforms.fields import HiddenField
def is_hidden_field_filter(field):
return isinstance(field, HiddenField)
app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter
load_loggers(app)
# Setup Flask-User to handle user account related forms
from .databases.user_models import MyRegisterForm, User
db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter
user_manager = UserManager(
db_adapter,
app, # Init Flask-User and bind to app
register_form=
MyRegisterForm # using a custom register form with UserProfile fields
)
return app
def create_app(extra_config_settings={}):
"""Create a Flask application.
"""
# Instantiate Flask
app = Flask(__name__)
# Load common settings
app.config.from_object('app.settings')
# Load environment specific settings
app.config.from_object('app.local_settings')
# Load extra settings from extra_config_settings param
app.config.update(extra_config_settings)
# Setup Flask-SQLAlchemy
db.init_app(app)
# Setup Flask-Migrate
migrate.init_app(app, db)
# Setup Flask-Mail
mail.init_app(app)
# Setup WTForms CSRFProtect
csrf_protect.init_app(app)
# Register blueprints
from .views import register_blueprints
register_blueprints(app)
# Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html
from wtforms.fields import HiddenField
def is_hidden_field_filter(field):
return isinstance(field, HiddenField)
app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter
# Setup an error-logger to send emails to app.config.ADMINS
init_email_error_handler(app)
# Additional persistent(not streamed) error log
import logging
from logging import Formatter
from logging.handlers import WatchedFileHandler
file_handler = WatchedFileHandler('logs/flask_app_error.log')
file_handler.setLevel(logging.ERROR)
file_handler.setFormatter(
Formatter(f'%(asctime)s %(levelname)s : %(message)s'))
app.logger.addHandler(file_handler)
# Setup Flask-User to handle user account related forms
from .models.user_models import User
from .views.main_views import user_profile_page
# Setup Flask-User
user_manager = UserManager(app, db, User)
@app.context_processor
def context_processor():
return dict(user_manager=user_manager)
return app
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():
""" Flask application factory """
# Setup Flask app and app.config
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
mail = Mail(app) # Initialize Flask-Mail
# 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 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='')
# Relationship
user_emails = db.relationship('UserEmail')
# Define UserEmail DataModel.
class UserEmail(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
is_primary = db.Column(db.Boolean(), nullable=False, default=False)
# Relationship
user = db.relationship('User', uselist=False)
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(
db, User, UserEmailClass=UserEmail) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
# 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>
{% 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>
{% endblock %}
""")
return app
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'mysecretkey'
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site_aumai.db?check_same_thread=False'
#app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:aumai123!@mysql:3306/aumaiDB'
app.config['SQLALCHEMY_ECHO'] = False
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['CSRF_ENABLE'] = True
app.config['USER_ENABLE_EMAIL'] = False
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(minutes=5)
formatter = logging.Formatter(
"[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s")
handler = RotatingFileHandler('../aumai/logs/aumai.log',
maxBytes=1000000,
backupCount=5)
handler.setLevel(logging.DEBUG)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
app.logger.debug('Inizializzo DB')
db.init_app(app)
app.logger.debug('Inizializzo Utenti')
from .models import User
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
user_manager.login_manager.login_view = 'auth.login'
app.logger.debug('Inizializzo Auth')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
app.logger.debug('Inizializzo Main')
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
app.logger.debug('Inizializzo Responsabile')
from .responsabile import responsabile as responsabile_blueprint
app.register_blueprint(responsabile_blueprint)
app.logger.debug('Inizializzo Cassiere')
from .cassiere import cassiere as cassiere_blueprint
app.register_blueprint(cassiere_blueprint)
app.logger.debug('Inizializzo REST_API')
from .rest_api import rest as rest_blueprint
app.register_blueprint(rest_blueprint)
app.logger.debug('Inizializzo Reports')
from .reports import reports as report_blueprint
app.register_blueprint(report_blueprint)
app.logger.debug('Inizializzo Form_Validartor')
from .form_validator import form_validator as validator_blueprint
app.register_blueprint(validator_blueprint)
app.logger.info('Application initialized')
return app
return self.first_name + ' ' + self.last_name
else:
return self.email
class UserInvitation(db.Model):
__tablename__ = 'user_invite'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), nullable=False)
invited_by_user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
token = db.Column(db.String(100), nullable=False, server_default='')
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User, UserInvitationClass=UserInvitation)
user_manager = UserManager()
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
def __repr__(self):
return self.name
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(),
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
def create_app(extra_config_settings={}):
"""Create a Flask applicaction.
"""
# Instantiate Flask
app = Flask(__name__)
# Load App Config settings
# Load common settings from 'app/settings.py' file
app.config.from_object('app.settings')
# Load local settings from 'app/local_settings.py'
app.config.from_object('app.local_settings')
# Load extra config settings from 'extra_config_settings' param
app.config.update(extra_config_settings)
# Setup Flask-Extensions -- do this _after_ app config has been loaded
# Setup Flask-SQLAlchemy
db.init_app(app)
# Setup Flask-Migrate
migrate.init_app(app, db)
# Setup Flask-Mail
mail.init_app(app)
# Setup WTForms CSRFProtect
csrf_protect.init_app(app)
# Initialize Flask-BabelEx
babel = Babel(app)
app.config['BABEL_DEFAULT_LOCALE'] = 'es'
# Register blueprints
from app.views.misc_views import main_blueprint
app.register_blueprint(main_blueprint)
# Define bootstrap_is_hidden_field for flask-bootstrap's bootstrap_wtf.html
from wtforms.fields import HiddenField
Bootstrap(app)
def is_hidden_field_filter(field):
return isinstance(field, HiddenField)
app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter
# Setup an error-logger to send emails to app.config.ADMINS
init_email_error_handler(app)
# Setup Flask-User to handle user account related forms
from .models.user_models import User, MyRegisterForm
from .views.misc_views import user_profile_page
db_adapter = SQLAlchemyAdapter(db, User) # Setup the SQLAlchemy DB Adapter
user_manager = UserManager(
db_adapter,
app, # Init Flask-User and bind to app
register_form=
MyRegisterForm, # using a custom register form with UserProfile fields
user_profile_view_function=user_profile_page,
)
# API REST
api = Api(app)
add_resources_api_rest(api)
return app
from datetime import datetime
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_user import UserManager
from config import Config
app = Flask(__name__)
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
from app import models
user_manager = UserManager(app, db, models.User, RoleClass=models.Role)
from app import routes
months = [
'januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus',
'september', 'oktober', 'november', 'december'
]
# Parse the timestamp to a readable date
def parse_date(date):
day = str(date.day)
month = months[date.month - 1]
year = str(date.year)
return day + " " + month + " " + year
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
limiter = Limiter(app,
key_func=get_remote_address,
default_limits=["2000 per hour"])
#babel = Babel(app)
db = SQLAlchemy(app)
#mysql = MySQL(app)
migrate = Migrate(app, db)
login = LoginManager(app)
login.login_view = 'login'
login.login_message = ""
app.jinja_env.autoescape = True
from app.models import User, Role, UserRoles, MyModelView, Messages
user_manager = UserManager(app, db,
User) #initialize flask-user implementation
# database creation and user addition
# Create all database tables
db.create_all()
# chat
socketio = SocketIO(app)
@socketio.on('message')
def handle_message(message):
print('received message: ' + str(message))
status = "Pending"
msg = Messages(message=message["message"],
username=message["user_name"],
from application.items import models
from application.items import views
from application.auth import models
from application.auth import views
from application.recipes import models
from application.recipes import views
# kirjautuminen
from application.auth.models import User, Role
from flask_login import LoginManager
from flask_user import UserManager
user_manager = UserManager(app, db, User)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth_login"
login_manager.login_message = "Please login to use this functionality."
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
# luodaan taulut tarvittaessa
try:
db.create_all()
# 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='')
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
@app.route("/viz")
# @login_required
def viz():
# official_file = "official.csv"
# unofficial_file = "un_official.csv"
# article_file = "articles.csv"
# if session.get('official'):
# official_file = session["official"]
# if session.get('unofficial'):
# unofficial_file = session["unofficial"]
# if session.get('article'):
# article_file = session["article"]
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
from app import app
from datetime import datetime
from flask import render_template, flash, redirect
from app.models import User, Role, db
from flask_user import SQLAlchemyAdapter, UserManager, login_required, roles_required
from flask import Blueprint
editor = Blueprint('editor',
__name__,
url_prefix="/editor",
template_folder='templates')
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
# Cria os usuarios de teste
@app.before_first_request
def setup():
# cria o usuario '*****@*****.**' com role de editor
if not User.query.filter(User.email == '*****@*****.**').first():
user = User(email='*****@*****.**',
email_confirmed_at=datetime.now(),
password=user_manager.hash_password('Password1'),
username='******',
first_name='First',
last_name='Member',
is_enabled=True)
user.roles.append(Role(name='Editor'))
db.session.add(user)
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
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
mail = Mail(app) # Initialize Flask-Mail
babel = Babel(app) # Initialize Flask-Babel
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
language = request.accept_languages.best_match(translations)
return language
# 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='')
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Select database adapter
user_manager = UserManager(db_adapter,
app) # Init Flask-User and bind to app
# The Home 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>
{% if current_user.is_authenticated() %}
<p> <a href="{{ url_for('user_profile_page') }}">
{%trans%}Profile Page{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% else %}
<p> <a href="{{ url_for('user.login') }}">
{%trans%}Sign in or Register{%endtrans%}</a></p>
{% endif %}
{% endblock %}
""")
if current_user.is_authenticated():
return redirect(url_for('user_profile_page'))
else:
return redirect(url_for('user.login'))
# 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('home_page') }}">
{%trans%}Home Page{%endtrans%}</a></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.logout') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
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 ImportError:
pass
# Load optional test_config # For automated tests
if test_config:
app.config.update(test_config)
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
babel = Babel(app) # Initialize Flask-BabelEx
@babel.localeselector
def get_locale():
translations = [
str(translation) for translation in babel.list_translations()
]
language = request.accept_languages.best_match(translations)
return language
# Define the User data-model. Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
username = db.Column(db.String(50), nullable=True, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# User email 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(), nullable=True)
# User information
is_enabled = db.Column(db.Boolean(),
nullable=False,
server_default='0')
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='')
class UserInvitation(db.Model):
__tablename__ = 'user_invitations'
id = db.Column(db.Integer, primary_key=True)
# UserInvitation email 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)
# save the user of the invitee
invited_by_user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(
db, User,
UserInvitationClass=UserInvitation) # Select database adapter
user_manager = UserManager(db_adapter,
app) # Init Flask-User and bind to app
@user_registered.connect_via(app)
def after_registered_hook(sender, user, user_invitation):
sender.logger.info("USER REGISTERED")
@user_sent_invitation.connect_via(app)
def after_invitation_hook(sender, **extra):
sender.logger.info("USER SENT INVITATION")
# 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 Pages{%endtrans%}</h2>
{% if call_or_get(current_user.is_authenticated) %}
<p> <a href="{{ url_for('user_profile_page') }}">
{%trans%}Profile Page{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% else %}
<p> <a href="{{ url_for('user.login') }}">
{%trans%}Sign in or Register{%endtrans%}</a></p>
{% endif %}
{% endblock %}
""")
user_manager = current_app.user_manager
if user_manager.call_or_get(current_user.is_authenticated):
return redirect(url_for('user_profile_page'))
else:
return redirect(url_for('user.login'))
# The Profile page requires a logged-in user
@app.route('/user/profiles')
@login_required # Use of @login_required decorator
@confirmed_email_required
def user_profile_page():
return render_template_string("""
{% extends "flask_user_layout.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('home_page') }}">
{%trans%}Home Page{%endtrans%}</a></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_user') }}">
{%trans%}Invite User{%endtrans%}</a></p>
<p> <a href="{{ url_for('user.logout') }}">
{%trans%}Sign out{%endtrans%}</a></p>
{% endblock %}
""")
return app
