def site_edit(id):
form = AddSiteForm()
if request.method == "GET":
session = db_session.create_session()
sites = session.query(Site).filter((Site.id == id)).first()
if sites:
form.site_address.data = sites.site_address
form.site_name.data = sites.site_name
form.id_topic.data = sites.id_topic
form.site_description.data = sites.site_description
else:
abort(404)
if form.validate_on_submit():
session = db_session.create_session()
sites = session.query(Site).filter((Site.id == id)).first()
if sites:
sites.site_address = form.site_address.data
sites.site_name = form.site_name.data
sites.id_topic = form.id_topic.data
sites.site_description = form.site_description.data
session.commit()
return redirect(f'/{0}/{0}')
else:
abort(404)
session = db_session.create_session()
if current_user.is_authenticated:
topics = session.query(Topic).filter(Topic.user_id.in_([1, current_user.id]))
else:
topics = session.query(Topic).filter(Topic.user_id == 1)
list_topics = sorted([p for p in topics], key=lambda q: q.topic_title)
return render_template('add_site.html', title='Редактирование сайта', form=form, list_topics=list_topics,
nid=sites.id_topic, link=url_for('static', filename='css/style.css'))
def training(message):
message.text = message.text.replace('/Обучить ', '')
try:
msg = message.text.split('=')
answer = msg[1].lower()
question = msg[0].lower().lstrip()
session = db_session.create_session()
user_all = session.query(User).all()
f = True
for all in user_all:
try:
if f:
for i in mat:
for j in snac:
if j in answer.split() or j in question.split():
answer = answer.replace(j, '')
question = question.replace(j, '')
if i in answer.split() or i in question.split():
bot.send_message(message.chat.id,
'Пиши без мата, друг )')
f = False
break
if f:
if session.query(User).filter(
User.question == question).first():
if session.query(User).filter(
User.answer != answer).first():
if all.question == question:
all.answer += '|' + answer
session.commit()
break
else:
bot.send_message(
message.chat.id,
'Такой ответ уже есть на' + all.question +
' этот вопрос')
break
else:
user = User(
question=question,
answer=answer,
)
session.add(user)
session.commit()
break
except RuntimeError:
bot.send_message(message.chat.id, 'Ошибка')
print('error/training/2_try')
except BaseException:
Error(message)
print('error/training/1_try')
def index():
session = db_session.create_session()
return render_template(
'base.html',
news=session.query(News).order_by(News.date.desc()),
news2=session.query(News2).order_by(News2.stazh.desc()),
news3=session.query(News3).order_by(News3.zarplata.desc()))
def get(self, last_id: int):
session = create_session()
result = get_result_template(last_id)
notifications = get_notifications(last_id)
for notification, stage, contest in notifications:
result['meta']['last_id'] = max(result['meta']['last_id'],
notification.id)
for student in session.query(Group).get(
notification.group_id).students:
if contest.id in map(lambda x: x.id,
student.declined_contests):
break
if str(student.target_year
) not in contest.years or not student.registered:
break
result['students'][student.vk_id].append({
'notification':
format_notification(notification),
'stage':
stage.id,
'contest':
contest.id
})
result['stages'] = dict(
((stage.id, format_stage(stage))
for stage in map(lambda x: x[1], notifications)))
result['contests'] = dict(
((contest.id, format_contest(contest))
for contest in map(lambda x: x[2], notifications)))
return jsonify(result)
def text(message):
if message.chat.type == 'private':
session = db_session.create_session()
user_all = session.query(User).all()
for all in user_all:
try:
if all.question == message.text.lower():
msg = all.answer.split('|')
if len(msg) == 1:
bot.send_message(message.chat.id, all.answer)
else:
bot.send_message(message.chat.id, choice(msg))
break
except RuntimeError:
bot.send_message(message.chat.id, 'Ошибка')
back(message)
print('error/text/1_try')
else:
for i in mat:
if message.text.lower() == i:
bot.send_message(message.chat.id, 'Пиши без мата, друг )')
start_ht_com(message)
break
else:
answer_not(message)
def start():
id_topic, id_all = 0, 0
id_list_users = [1]
if current_user.is_authenticated:
if current_user.id != 1:
if id_all:
id_list_users = [current_user.id]
else:
id_list_users.append(current_user.id)
session = db_session.create_session()
sites = session.query(Site).filter(Site.id_user.in_(id_list_users))
if id_all:
id_list_users = [1, current_user.id]
topics = session.query(Topic).filter(Topic.user_id.in_(id_list_users))
list_topics = sorted([p for p in topics], key=lambda q: q.topic_title)
name_topics = {}
name_topics[0] = 'Все темы сайтов'
for topic in list_topics:
if topic.id not in name_topics:
name_topics[topic.id] = topic.topic_title
elif topic.id == current_user.id:
name_topics[topic.id] = topic.topic_title
dict_site = {}
list_sites = sorted([p for p in sites], key=lambda q: name_topics[q.id_topic])
count_sites = {}
count_sites[0] = len(list_sites)
for p in list_sites:
dict_site[p.id_topic] = dict_site.get(p.id_topic, []) + [p]
for p in dict_site:
count_sites[p] = len(dict_site[p])
count_sites[-1] = len(dict_site)
return render_template("index.html", dict_site=dict_site, name_topics=name_topics,
title='Лучшие сайты, отобранные вручную!', id_topic=id_topic,
id_all=id_all, count_sites=count_sites, link=url_for('static', filename='css/style.css'))
def delete(self, user_id):
"""
For Admins: Delete user
"""
current_user_id = get_jwt_identity()
session = db_session.create_session()
admin = session.query(Admin).filter(
Admin.user_id == current_user_id).scalar()
if not admin:
return make_response(
jsonify(error='Access denied: You are not admin'), 401)
check_admin = session.query(Admin).filter(
Admin.user_id == user_id).scalar()
if check_admin:
return make_response(jsonify(error='Access denied: User is admin'),
401)
user = session.query(User).get(user_id)
if not user:
return make_response(jsonify(error='User not found'), 404)
try:
session.delete(user)
session.commit()
return jsonify({'success': 'OK'})
except SQLAlchemyError as ex:
session.rollback()
return make_response(jsonify({"error": ex.args}), 400)
def get(self):
"""
For auth user: Get user back_friends
"""
current_user_id = get_jwt_identity()
session = db_session.create_session()
friends = session.query(User).get(current_user_id).friends
return jsonify(friends=[friend.to_dict() for friend in friends])
def delete_note(note_id):
db_sess = db_session.create_session()
note = db_sess.query(Note).get(note_id)
if not note:
return jsonify({'error': 'Not found'})
db_sess.delete(note)
db_sess.commit()
return jsonify({'success': 'OK'})
def delete_message(message_id):
db_sess = db_session.create_session()
message = db_sess.query(Message).get(message_id)
if not message:
return jsonify({'error': 'Not found'})
db_sess.delete(message)
db_sess.commit()
return jsonify({'success': 'OK'})
def get_notifications(last_id: int):
return create_session().query(Notification, Stage, Contest) \
.join(Stage, Notification.stage_id == Stage.id) \
.join(Contest, Stage.contest_id == Contest.id).filter(
Notification.id > last_id,
Notification.date < datetime.now(),
Stage.ending_date > datetime.now()
)
def get_notes():
db_sess = db_session.create_session()
note = db_sess.query(Note).all()
return jsonify({
'notes': [
item.to_dict(only=('id', 'name', 'text', 'author_id',
'created_at')) for item in note
]
})
def get(self):
"""
Get yourself data user
"""
user_id = get_jwt_identity()
session = db_session.create_session()
return jsonify(current_user=session.query(User).get(user_id).to_dict())
# TODO: put
def topics():
session = db_session.create_session()
if current_user.is_authenticated:
topics = session.query(Topic).filter(Topic.user_id.in_([1, current_user.id]))
else:
topics = session.query(Topic).filter(Topic.user_id == 1)
list_topics = sorted([p for p in topics], key=lambda q: q.topic_title)
return render_template("topics.html", list_topics=list_topics, title='Список тем',
link=url_for('static', filename='css/style.css'))
def site_delete(id):
session = db_session.create_session()
site = session.query(Site).filter((Site.id == id)).first()
if site:
session.delete(site)
session.commit()
else:
abort(404)
return redirect(f'/{0}/{0}')
def put(self, vk_id: str):
session = create_session()
student = session.query(Student).filter_by(vk_id=vk_id).first()
if student is None:
return abort(409)
args = parser.parse_args()
student.apply_json_args(args)
session.commit()
return 200
def get_one_note(note_id):
db_sess = db_session.create_session()
note = db_sess.query(Note).get(note_id)
if not note:
return jsonify({'error': 'Not found'})
return jsonify({
'notes':
note.to_dict(only=('name', 'text', 'author_id', 'is_private',
'created_at'))
})
def profile(id):
db_sess = db_session.create_session()
prof = db_sess.query(User).get(id)
return render_template('profile.html',
surname=prof.surname,
name=prof.name,
id=prof.id,
age=prof.age,
email=prof.email,
created_at=prof.created_at)
def get(self, user_id):
"""
For auth users: Show user
"""
# current_user_id = get_jwt_identity()
session = db_session.create_session()
user = session.query(User).get(user_id)
if not user:
return make_response(jsonify(error="User not found"), 404)
return jsonify(user=user.to_dict())
def topic_edit(id):
form = AddTopicForm()
if request.method == "GET":
session = db_session.create_session()
topic = session.query(Topic).filter(Topic.id == id, Topic.user_id == current_user.id).first()
if topic:
form.topic_title.data = topic.topic_title
else:
abort(404)
if form.validate_on_submit():
session = db_session.create_session()
topic = session.query(Topic).filter(Topic.id == id, Topic.user_id == current_user.id).first()
if topic:
topic.topic_title = form.topic_title.data
session.commit()
return redirect(f'/{0}/{0}')
else:
abort(404)
return render_template('add_topic.html', title='Редактирование темы', form=form,
link=url_for('static', filename='css/style.css'))
def get_one_message(message_id):
db_sess = db_session.create_session()
message = db_sess.query(Message).get(message_id)
if not message:
return jsonify({'error': 'Not found'})
return jsonify(
{
'message': message.to_dict(only=('recipient_id', 'note_id',
'message_text', 'is_anonymous'))
}
)
def delete(self, vk_id: str):
args = parser.parse_args()
if args['contest_id'] is None:
return 409
session = db_session.create_session()
student_id = session.query(Student).filter(
Student.vk_id == vk_id).first().id
deleting = student_declines.delete().where(
student_id=student_id, contest_id=args['contest_id'])
db_session.engine.execute(deleting)
return 200
def get(self):
"""
Only for SuperAdmin: Shutdown server
"""
current_user_id = get_jwt_identity()
session = db_session.create_session()
admin = session.query(Admin).filter(Admin.user_id==current_user_id).scalar()
if session.query(SuperAdmin).filter(SuperAdmin.admin_id==admin.id).scalar():
Shutdown.__shutdown_server()
return jsonify(answer='Server shutting down...')
return jsonify(answer='You are not super admin!')
def login():
global f, men_page, reg, adm, rig
if not f or rig:
reg = True
form = LoginForm()
if form.validate_on_submit():
if form.login.data == 'admin':
if form.password.data == '123':
f, adm = True, True
rig = None
session = db_session.create_session()
return render_template(
'bases/admin.html',
User=session.query(User).order_by(User.date.desc())
)
else:
return render_template("Error/Admin_error.html", flag=f, admi=adm, men=men_page)
session = db_session.create_session()
if session.query(User).filter(User.login == form.login.data).first():
user = session.query(User).filter(User.login == form.login.data).first()
if user and user.check_password(form.password.data):
f = True
rig = None
return render_template('Osnova.html', flag=f, men=men_page)
else:
return render_template('reg_and_log/login.html', title='Регистрация',
log=True,
form=form,
reg=reg,
message="Не правильный пароль")
else:
return render_template('reg_and_log/login.html', title='Регистрация',
log=True,
form=form,
reg=reg,
message="Такого пользователя нету в базе данных, может зарегистрируешься?")
return render_template('reg_and_log/login.html', title='Авторизация', form=form, reg=reg)
else:
abort(401)
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(f'/{0}/{0}')
return render_template('login.html', message="Неверный логин или пароль", form=form,
link=url_for('static', filename='css/style.css'))
return render_template('login.html', title='Авторизация', form=form,
link=url_for('static', filename='css/style.css'))
def topic_delete(id):
session = db_session.create_session()
topic = session.query(Topic).filter(Topic.id == id, Topic.user_id == current_user.id).first()
site = session.query(Site).filter(Site.id_topic == topic.id).first()
if site:
return redirect(f'/{0}/{0}')
if topic:
session.delete(topic)
session.commit()
else:
abort(404)
return redirect(f'/{0}/{0}')
def del_log():
global url, login1, password, men_page, reg, adm, rig, f
form = Delete_login()
session = db_session.create_session()
if form.validate_on_submit():
if session.query(User).filter(User.login == form.login.data).first():
if session.query(User).filter(
User.hashed_password == form.password.data +
form.login.data).first():
user = session.query(User).filter(
User.login == form.login.data).first()
session.delete(user)
session.commit()
toaddr = str(user.mail)
topic = 'Аккаунт удален'
message = 'Вы удалили аккаунт на сайте RuPit'
msg = MIMEMultipart()
msg['Subject'] = topic
msg['From'] = login1
body = message
msg.attach(MIMEText(body, 'plain'))
server = root.SMTP_SSL(url, 465)
server.login(login1, password)
server.sendmail(login1, toaddr, msg.as_string())
f = False
men_page, reg, adm, rig = None, None, None, None
return redirect('/')
else:
return render_template('reg_and_log/deletelogin.html',
title='удаление аккаунта',
form=form,
reg=reg,
new=4,
message="Пароли не совпадают")
else:
return render_template(
'reg_and_log/deletelogin.html',
title='удаление аккаунта',
form=form,
reg=reg,
log=True,
new=4,
message="Пользователя с таким login нет в базе")
return render_template('reg_and_log/deletelogin.html',
new=4,
title='удаление аккаунта',
form=form,
reg=reg)
def add_site():
add_form = AddSiteForm()
if add_form.validate_on_submit():
session = db_session.create_session()
site = Site(
id_user=current_user.id,
site_address=add_form.site_address.data.lower(),
site_name=add_form.site_name.data,
id_topic=add_form.id_topic.data,
site_description=add_form.site_description.data
)
session.add(site)
session.commit()
return redirect(f'/{0}/{0}')
session = db_session.create_session()
if current_user.is_authenticated:
topics = session.query(Topic).filter(Topic.user_id.in_([1, current_user.id]))
else:
topics = session.query(Topic).filter(Topic.user_id == 1)
list_topics = sorted([p for p in topics], key=lambda q: q.topic_title)
return render_template('add_site.html', title='Добавление сайта', form=add_form, list_topics=list_topics,
nid=0, link=url_for('static', filename='css/style.css'))
def login():
form = LoginForm()
if form.validate_on_submit():
db_sess = db_session.create_session()
user = db_sess.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("/")
return render_template('login.html',
message="Неправильный логин или пароль",
form=form)
return render_template('login.html', form=form)
def add_topic():
add_form = AddTopicForm()
if add_form.validate_on_submit():
session = db_session.create_session()
topic = Topic(
topic_title=add_form.topic_title.data,
user_id=current_user.id
)
session.add(topic)
session.commit()
return redirect(f'/{0}/{0}')
return render_template('add_topic.html', title='Добавление темы', form=add_form,
link=url_for('static', filename='css/style.css'))
