def main():
db_session.global_init("db/group_B.sqlite")
@login_manager.user_loader
def load_pupil(pupil_id):
session = db_session.create_session()
return session.query(Pupil).get(pupil_id)
@app.route('/vivod', methods=['GET', 'POST'])
def vivod():
session = db_session.create_session()
news = session.query(Pupil).all()
return render_template("index.html", a = True, b = False, news=news)
@app.route('/register', methods=['GET', 'POST'])
def register():
form = RegisterForm()
if form.validate_on_submit():
session = db_session.create_session()
if session.query(Pupil).filter(Pupil.email == form.email.data).first():
return render_template('register.html', a = True, b = False, title='Регистрация ученика', form=form, message="Такой ученик уже зарегистрирован")
pupil = Pupil(
surname=form.surname.data,
name=form.name.data,
email=form.email.data,
telephone=form.telephone.data,
class_=form.class_.data,
)
pupil.set_password(form.email.data)
session.add(pupil)
session.commit()
return redirect('/')
return render_template('register.html', a = True, b = False, title='Регистрация ученика', form=form)
@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
def index():
session = db_session.create_session()
names = session.query(Pupil)
return render_template('base.html', a = False, b = True, names=names)
@app.route('/logout')
def logout():
logout_user()
return redirect("/")
@app.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
session = db_session.create_session()
user = session.query(Pupil).filter(Pupil.email == form.email.data).first()
if user and user.check_password(form.email.data):
login_user(user)
jobs = session.query(Jobs).all()
return render_template("jobs.html", a = True, b = False, jobs=jobs)
#return redirect("/")
return render_template('login.html', a = True, b = False,
message="Такого почтового адреса не зарегистрировано",
form=form)
return render_template('login.html', a = True, b = False, title='Авторизация ученика', form=form)
app.run(port=8050, host='127.0.0.1')
def main():
db_session.global_init("db/forum.sqlite")
app.run()
from data.users import User
from data.questions import Questions
from data.replies import Replies
from data.groups import Groups
from data.articles import Articles
from werkzeug.security import generate_password_hash, check_password_hash
from random import choice
import os
app = Flask(__name__)
cache = Cache(config={'CACHE_TYPE': 'simple'})
cache.init_app(app)
app.secret_key = b'iw7d/546adit&#'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['REMEMBER_COOKIE_DURATION'] = timedelta(seconds=20)
db_session.global_init("db/data.sqlite")
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.session_protection = "strong"
generator_ch = ascii_lowercase + digits
service_ch = None
class OurModelView(ModelView):
def is_accessible(self):
return current_user.is_authenticated
class OurAdminIndexView(AdminIndexView):
def is_accessible(self):
return current_user.admin
def main():
db_session.global_init("db/mars.sqlite")
app.run()
def main():
db_session.global_init('db/jobs.db')
app.register_blueprint(blueprint)
app.run('127.0.0.1', 8080)
from data import db_session
from data.jobs import Jobs
db_session.global_init('mars_db.sqlite')
session = db_session.create_session()
job_1 = Jobs()
job_1.team_leader = 1
job_1.job = 'deployment of residential modules 1 and 2'
job_1.work_size = 15
job_1.collaborators = '2, 3'
job_1.is_finished = False
session.add(job_1)
job_2 = Jobs()
job_2.team_leader = 2
job_2.job = 'installing equipment'
job_2.work_size = 7
job_2.collaborators = "1"
job_2.is_finished = False
session.add(job_2)
session.commit()
db_sess.add(user)
db_sess.commit()
return redirect('/')
return render_template('register.html', title='Регистрация', form=form)
# обработка выхода
@app.route('/logout')
@login_required
def logout():
logout_user()
return redirect("/")
# обработка ошибки 404
@app.errorhandler(404)
def not_found(error):
return make_response(jsonify({'error': 'Not found'}), 404)
# обработка ошибки 405
@app.errorhandler(405)
def method_not_allowed(error):
return make_response(jsonify({'error': 'Method Not Allowed'}), 405)
if __name__ == '__main__':
db_session.global_init("db/library.db")
db_sess = db_session.create_session()
main()
def main():
db_session.global_init("db/yaschool")
app.run(host='0.0.0.0', port=8080)
def main():
db_session.global_init("db/School.sqlite")
app.run()
] for job in jobs]
return render_template("main_page.html",
title="Главная страница",
name=user_name,
keys=keys,
data=values)
@app.route("/add_job", methods=["GET", "POST"])
@login_required
def add_job():
form = AddJobForm()
if form.validate_on_submit():
db_sess = db_session.create_session()
jobs = Jobs()
jobs.team_leader = form.team_leader.data
jobs.job = form.job.data
jobs.work_size = form.work_size.data
jobs.collaborators = form.collaborators.data
jobs.is_finished = form.is_finished.data
current_user.jobs.append(jobs)
db_sess.merge(current_user)
db_sess.commit()
return redirect("/")
return render_template("job.html", title="Добавление работы", form=form)
if __name__ == '__main__':
db_session.global_init("db/blogs.db")
app.run(port=8080, host='127.0.0.1')
def main():
db_session.global_init("db/mars_explorer.db")
port = int(os.environ.get("PORT", 5000))
app.run(host='0.0.0.0', port=port)
def main():
db_session.global_init("db/mars_explorer.db")
app.run()
def comments():
db_session.global_init("db/data_base.sqlite")
session = db_session.create_session()
object = session.query(otzyv.Otzyv)
session.commit()
return render_template("comments.html", obj=object)
return redirect('/departments')
form.title.data = department.title
form.email.data = department.email
members = []
for member in department.members.split(', '):
members.append(session.query(User).filter(User.id == member).first().fio())
form.members.data = ', '.join(members)
return render_template('department.html', title="Редактирование департамента", form=form)
@app.route('/delete_department/<int:id>', methods=['GET', 'DELETE'])
@login_required
def delete_department(id):
session = create_session()
department = session.query(Department).filter(Department.id == id).first()
if current_user.id == 1 or current_user.id == department.chief:
session.delete(department)
session.commit()
return redirect('/departments')
if __name__ == '__main__':
global_init('db/blogs.db')
app.register_blueprint(jobs_api.blueprint)
app.register_blueprint(users_api.blueprint)
app.run(debug=True)
def main():
db_session.global_init("db/database.db")
app.run()
def main():
db_session.global_init('db/db.sqlite')
app.register_blueprint(blueprint)
app.run()
from flask import Flask
from flask_restful import reqparse, abort, Api, Resource
from users_ap import users_resource
from jobs_ap import jobs_resource
from data.db_session import global_init
app = Flask(__name__)
api = Api(app)
api.add_resource(users_resource.UsersListResource, '/api/v2/users')
api.add_resource(users_resource.UsersResource, '/api/v2/users/<int:user_id>')
api.add_resource(jobs_resource.JobsListResource, '/api/v2/jobs')
api.add_resource(jobs_resource.JobsResource, '/api/v2/jobs/<int:job_id>')
global_init("db/book_store.db")
if __name__ == '__main__':
app.run()
app.config['SECRET_KEY'] = generate_random_string(16)
app.config['SQLITE3_SETTINGS'] = {'host': 'db/bugtracker.sqlite'}
# This for pythonwanywhere.com
if __name__ != '__main__' and not app.testing and os.path.exists(
'/home/Sadn3ss'):
app.root_path = os.path.dirname(os.path.abspath(__file__))
if sys.platform != 'win32':
app.config['SQLITE3_SETTINGS'] = {
'host': '/home/Sadn3ss/mysite/db/bugtracker.sqlite'
}
else:
app.config['SQLITE3_SETTINGS'] = {'host': 'db/bugtracker.sqlite'}
db_session.global_init(app.config['SQLITE3_SETTINGS']['host'])
# Init login manager
login_manager = LoginManager()
login_manager.init_app(app)
# Create session for flask-admin
adm_session = db_session.create_session()
admin = Admin(app, index_view=MyAdminIndexView(), template_mode='bootstrap3')
# Add all our models to flask-admin
admin.add_view(MyModelView(User, adm_session))
admin.add_view(MyModelView(Project, adm_session))
admin.add_view(MyModelView(Issue, adm_session))
adm_session.close()
form=form,
title='Редактирование профиля')
else:
form = UserProfileForm()
if form.validate_on_submit():
if 'save' in [i for i in request.form]:
db_sess.query(People).filter(People.email == current_user.email). \
update({"email": form.email.data,
"surname": form.surname.data,
"name": form.name.data})
db_sess.commit()
return redirect('/')
else: # если это не кнопка сохранить
db_sess.query(People).filter(
People.email == current_user.email).delete()
db_sess.commit()
return redirect('/')
form.email.data = info['email']
form.surname.data = info['surname']
form.name.data = info['name']
return render_template('lets see user profile.html',
form=form,
title='Редактирование профиля')
if __name__ == '__main__':
db_session.global_init("db/library.db") # инициилизация дб
app.register_blueprint(api.blueprint)
port = int(os.environ.get("PORT", 5000))
app.run(host='0.0.0.0', port=port)
def main(host=HOST, port=PORT, debug=1):
db_session.global_init(app.config['SQLITE3_SETTINGS']['host'])
app.run(host=host, port=port, debug=debug)
def main():
db_session.global_init("db/passwords.db")
app.run()
def index():
db_session.global_init("db/filmoteka.db")
db_sess = db_session.create_session()
return render_template("index.html") #, res=res)
def main():
db_session.global_init(DB)
# add_colonist()
# add_job()
app.run()
from wtforms import PasswordField, BooleanField, SubmitField
from wtforms.fields.html5 import EmailField
from wtforms.validators import DataRequired
from data import db_session
from data.register import RegisterForm
from data.users import User
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
app.config['SECRET_KEY'] = 'yandexlyceum_secret_key'
login_manager = LoginManager()
login_manager.init_app(app)
db_session.global_init("blog.db")
@login_manager.user_loader
def load_user(user_id):
db_sess = db_session.create_session()
return db_sess.query(User).get(user_id)
@app.route('/')
@app.route('/home')
def index():
return render_template("index.html")
@app.route('/about')
import os
import sqlite3
from data import db_session
from data import users
from flask import Flask, render_template, request, redirect, flash, url_for
from flask_login import login_user, login_required
from werkzeug.security import check_password_hash
app = Flask(__name__)
app.config['SECRET_KEY'] = 'yandexlyceum_secret_key'
db_session.global_init("db/blogs.sqlite")
@app.route("/")
def home():
return render_template('Osnova.html')
@app.route("/Lyshee")
def lyshee():
return render_template('Lyshee.html')
@app.route("/O nas")
def onas():
return render_template('O nas.html')
@app.route("/Contact")
def contact():
@login_manager.user_loader
def load_user(user_id):
session = db_session.create_session()
return session.query(User).get(user_id)
class NotLoginStartPageForm(FlaskForm):
login = SubmitField('Login')
register = SubmitField('Register')
class LoginStartPageForm(FlaskForm):
my_commands = SubmitField('My Commands')
add_command = SubmitField('Add new command')
command_workshop = SubmitField('All public commands')
logout = SubmitField('Logout')
@app.route('/', methods=['GET', 'POST'])
def start_page():
if current_user:
form = LoginStartPageForm
else:
form = NotLoginStartPageForm
return render_template('start_page.html', title='Moxy', form=form)
db_session.global_init("data/db/custom_commands.sqlite")
app.run()
# проверка на доступность email
if not db_sess.query(User).filter(
User.email == ch_email.new_email.data).first():
user.email = ch_email.new_email.data # изменение
db_sess.commit()
return redirect("/my_profile")
return redirect("/my_profile")
@login_required
@app.route('/change_password', methods=['POST'])
def change_password():
"""Фунция для обработки смены пароля пользователя"""
ch_password = ChangePassword() # необходимая форма
db_sess = db_session.create_session()
user = db_sess.query(User).filter(
User.id == current_user.id).first() # пользователь
user.set_password(
ch_password.new_password.data) # изменение с помощью хеширования
db_sess.commit()
return redirect("/my_profile")
if __name__ == '__main__':
db_session.global_init(
"db/market.db") # создание/инициализация базы данных
db_sess = db_session.create_session()
port = int(os.environ.get(
"PORT", 5000)) # создаём порт сервера (в основном для Heroku)
app.run(host='0.0.0.0', port=port) # фиксируем запуск
def main():
db_session.global_init(r"C:\Yandex\Flask-YaL\db\jobs.sqlite")
app.register_blueprint(jobs_api.blueprint)
app.register_blueprint(users_api.blueprint)
app.run()
from data.db_session import global_init, create_session
from data.users import User
db_name = input()
global_init(db_name)
db_sess = create_session()
users = db_sess.query(User).filter(
User.position.like("%chief%") | User.position.like("%middle%"))
for user in users:
print(user, user.position)
def main():
db_session.global_init("db/shop.db")
api.add_resource(ProductListResource, '/api/products')
api.add_resource(ProductResource, '/api/product/<int:product_id>')
app.register_blueprint(product_api.blueprint)
session = db_session.create_session()
@app.route("/")
def index():
session = db_session.create_session()
special = session.query(Product).get(1)
products = session.query(Product).order_by(Product.views.desc())
return render_template("index.html", products=products, special=special)
@app.route("/TopSingles")
def singles():
session = db_session.create_session()
special = False
products = session.query(Product).filter(Product.is_lp == False).order_by(Product.views.desc())
return render_template("index.html", products=products, special=special)
@app.route("/TopAlbums")
def albums():
session = db_session.create_session()
special = False
products = session.query(Product).filter(Product.is_lp == True).order_by(Product.views.desc())
return render_template("index.html", products=products, special=special)
@app.route("/year/<int:year>")
def year(year):
session = db_session.create_session()
special = False
products = session.query(Product).filter(Product.year == year).order_by(Product.views.desc())
return render_template("index.html", products=products, special=special)
@app.route("/musician/<name>")
def musician(name):
name = name.replace('%20', ' ')
session = db_session.create_session()
musician = session.query(Musician).filter(Musician.name == name).first()
special = False
products = session.query(Product).filter(Product.musician_id == musician.id).order_by(Product.views.desc())
return render_template("index.html", products=products, special=special)
@app.route('/register', methods=['GET', 'POST'])
def reqister():
form = RegisterForm()
if form.validate_on_submit():
if form.password.data != form.password_again.data:
return render_template('register.html', title='Registration',
form=form,
message="Passwords don't match")
session = db_session.create_session()
if session.query(User).filter(User.email == form.email.data).first():
return render_template('register.html', title='Registration',
form=form,
message="This user already exists")
user = User(
name=form.name.data,
surname=form.surname.data,
email=form.email.data,
)
user.set_password(form.password.data)
session.add(user)
session.commit()
return redirect('/login')
return render_template('register.html', title='Registration', form=form)
@app.route('/add_to_cart/<int:id>')
@login_required
def add_to_cart(id):
product = session.query(Product).get(id)
cart = session.query(Cart).filter(Cart.user_id == current_user.id).first()
cart_product = Cart_Product(
product_id=product.id,
cart_id=cart.id,
count=1,
one_price=product.price,
full_price=product.price
)
session.add(cart_product)
session.commit()
address = '/product/' + str(id)
return redirect(address)
@app.route('/delete/<int:id>', methods=['GET', 'POST'])
@login_required
def delete(id):
session = db_session.create_session()
cart_products = session.query(Cart_Product).filter(Cart_Product.id == id).first()
if cart_products:
session.delete(cart_products)
session.commit()
else:
abort(404)
return redirect('/cart')
@app.route('/cart')
def cart():
empty_cart = False
cart = session.query(Cart).get(current_user.id)
cart_products = session.query(Cart_Product).filter(Cart_Product.cart_id == cart.id)
product_count = session.query(func.sum(Cart_Product.count)).filter_by(cart_id=cart.id).scalar()
sum_price = session.query(func.sum(Cart_Product.full_price)).filter_by(cart_id=cart.id).scalar()
sum_price = str(sum_price)
full_price = sum_price[:(sum_price.find('.') + 3)]
print(full_price, sum_price.find('.'))
current_user_id = current_user.id
if cart_products.count() == 0:
empty_cart = True
return render_template('cart.html', title='Cart', cart_products=cart_products,
product_count=product_count, full_price=full_price, empty_cart=empty_cart, current_user_id=current_user_id)
@login_manager.user_loader
def load_user(user_id):
session = db_session.create_session()
return session.query(User).get(user_id)
@app.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
session = db_session.create_session()
user = session.query(User).filter(User.email == form.email.data).first()
if user and user.check_password(form.password.data):
login_user(user, remember=form.remember_me.data)
return redirect("/create_cart")
return render_template('login.html',
message="Wrong email or password",
form=form)
return render_template('login.html', title='Authorization', form=form)
@app.route('/create_cart')
def create_cart():
old_cart = session.query(Cart).filter(Cart.user_id == current_user.id).first()
if not old_cart:
user_cart = Cart()
user_cart.user_id = current_user.id
session.add(user_cart)
session.commit()
return redirect("/")
@app.route('/logout')
@login_required
def logout():
logout_user()
return redirect("/")
@app.route('/changetheme')
@login_required
def change_theme():
session = db_session.create_session()
if current_user.dark_theme:
session.query(User).filter(User.id == current_user.id).update({User.dark_theme: 0},
synchronize_session=False)
else:
session.query(User).filter(User.id == current_user.id).update({User.dark_theme: 1},
synchronize_session=False)
session.commit()
return redirect("/")
@app.route('/changeform')
@login_required
def change_form():
session = db_session.create_session()
if current_user.circle_theme:
session.query(User).filter(User.id == current_user.id).update({User.circle_theme: 0},
synchronize_session=False)
else:
session.query(User).filter(User.id == current_user.id).update({User.circle_theme: 1},
synchronize_session=False)
session.commit()
return redirect("/")
@app.route("/count+/<int:id>")
def plus_count(id):
session.query(Cart_Product).filter(Cart_Product.id == id).\
update({Cart_Product.count: Cart_Product.count + 1,
Cart_Product.full_price: Cart_Product.one_price * (Cart_Product.count + 1)})
c_p = session.query(Cart_Product).filter(Cart_Product.id == id).first()
full_price = round(c_p.full_price, 2)
session.query(Cart_Product).filter(Cart_Product.id == id). \
update({Cart_Product.full_price: full_price})
session.commit()
return redirect("/cart")
@app.route("/count-/<int:id>")
def minus_count(id):
count = session.query(Cart_Product).get(id)
if count.count > 1:
session.query(Cart_Product).filter(Cart_Product.id == id). \
update({Cart_Product.count: Cart_Product.count - 1,
Cart_Product.full_price: Cart_Product.one_price * (Cart_Product.count - 1)})
c_p = session.query(Cart_Product).filter(Cart_Product.id == id).first()
full_price = round(c_p.full_price, 2)
session.query(Cart_Product).filter(Cart_Product.id == id). \
update({Cart_Product.full_price: full_price})
session.commit()
return redirect("/cart")
@app.route('/product/<int:id>', methods=['GET', 'POST'])
def product_page(id):
session.query(Product).filter(Product.id == id).update({Product.views: Product.views + 1})
session.commit()
form = ReviewsForm()
product = session.query(Product).filter(Product.id == id).first()
if form.validate_on_submit():
review_session = db_session.create_session()
review = Review()
review.content = form.content.data
review.product_id = id
current_user.review.append(review)
review_session.merge(current_user)
review_session.commit()
reviews = session.query(Review).filter(Review.product_id == id)
if product.is_lp == 0:
return render_template("product.html", product=product, form=form, reviews=reviews)
else:
songs = session.query(Song).filter(Song.album_id == product.id)
songs_count = songs.count()
return render_template("product.html", product=product, form=form, reviews=reviews, songs=songs, songs_count=songs_count)
@app.route('/order/<delivery>', methods=['GET', 'POST'])
def order_page(delivery):
cart = session.query(Cart).filter(Cart.id == current_user.id).first()
id = cart.id
if delivery == 'home':
delivery_price = 9.99
elif delivery == 'sdek':
delivery_price = 5.99
elif delivery == 'boxberry':
delivery_price = 4.99
full_price = session.query(func.sum(Cart_Product.full_price)).filter_by(cart_id=id).scalar()
form = OrderForm()
if form.validate_on_submit():
order_session = db_session.create_session()
order = Order()
order.cart_id = id
order.surname = form.surname.data
order.name = form.name.data
order.phone = form.phone.data
order.delivery = delivery
order.delivery_price = delivery_price
order.country = form.country.data
order.town = form.town.data
order.street = form.street.data
order.house = form.house.data
order.flat = form.flat.data
order.promo = form.promo.data
order_session.add(order)
order_session.commit()
return redirect("/thanks")
return render_template("order.html", form=form, cart_id=id,
full_price=full_price, delivery_price=delivery_price, delivery=delivery)
@app.route('/review_delete/<int:id>', methods=['GET', 'POST'])
@login_required
def review_delete(id):
session = db_session.create_session()
review = session.query(Review).filter(Review.id == id, Review.user == current_user).first()
if review:
session.delete(review)
session.commit()
else:
abort(404)
return redirect('/')
@app.route('/thanks')
def thanks():
return render_template("thanks.html")
app.run()
