def put(self, user_id):
abort_if_user_not_found(user_id)
session = db_session.create_session()
if not request.json:
return jsonify({'error': 'Empty request'})
user = session.query(User).get(user_id)
if 'name' in request.json:
user.name = request.json['name']
if 'surname' in request.json:
user.surname = request.json['surname']
if 'age' in request.json:
user.age = request.json['age']
if 'position' in request.json:
user.position = request.json['position']
if 'speciality' in request.json:
user.speciality = request.json['speciality']
if 'address' in request.json:
user.address = request.json['address']
if 'email' in request.json:
user.email = request.json['email']
if 'city_from' in request.json:
user.city_from = request.json['city_from']
user.modified_date = datetime.datetime.now()
session.commit()
return jsonify({'success': 'OK'})
def init():
# инициализация
_request = {
'token': request.json.get('token', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
resources = db_sess.query(Resource).all()
names = [i.name for i in resources]
patterns = eval(
open('static/core/resources.txt', 'r', encoding='utf8').read())
# ресурсы
for pattern in patterns:
if pattern['name'] not in names:
# создание ресурсов
new_resource = Resource()
new_resource.apply_pattern(pattern)
db_sess.add(new_resource)
db_sess.commit()
types = db_sess.query(ProductionType).all()
names = [i.name for i in types]
patterns = eval(
open('static/core/productions.txt', 'r', encoding='utf8').read())
for pattern in patterns:
if pattern['title'] not in names:
new_type = ProductionType()
new_type.apply_pattern(pattern)
db_sess.add(new_type)
db_sess.commit()
return jsonify({'result': 'OK'})
def register():
form = RegisterForm()
if form.validate_on_submit():
if form.password.data != form.password_again.data:
return render_template('register.html',
title='Регистрация',
form=form,
message="Пароли не совпадают")
session = db_session.create_session()
if session.query(User).filter(User.email == form.email.data).first():
return render_template('register.html',
title='Регистрация',
form=form,
message="Такой пользователь уже есть")
user = User(
surname=form.surname.data,
name=form.name.data,
email=form.email.data,
age=form.age.data,
position=form.position.data,
speciality=form.speciality.data,
address=form.address.data,
city_from=form.city_from.data,
)
user.set_password(form.password.data)
session.add(user)
session.commit()
return redirect('/login')
return render_template('register.html', title='Регистрация', form=form)
def create():
_request = {
'token': request.json.get('token', ''),
'input': request.json.get('input', ''),
'output': request.json.get('output', ''),
'input_number': request.json.get('input_number', ''),
'output_number': request.json.get('output_number', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
user = db_sess.query(User).get(config.USER_ID)
resources = db_sess.query(Resource).all()
new_deal = Deal()
# создание сделки
res = new_deal.create(_request, user, resources)
if res:
return jsonify(res)
res = user.create_deal(new_deal)
if res:
return jsonify(res)
db_sess.add(new_deal)
db_sess.commit()
db_sess.merge(user)
db_sess.commit()
return jsonify({'result': 'OK'})
def sign_in():
# вход пользователя
_request = {
'token': request.json.get('token', ''),
'nickname': request.json.get('nickname', ''),
'password': request.json.get('password', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
user = db_sess.query(User).filter(
User.nickname == _request['nickname']).first()
if not user:
return jsonify({'result': 'unknown nickname'})
# нет такого пользователя
if not user.check_password(_request['password']):
# неверный пароль
return jsonify({'result': 'incorrect password'})
config.USER_ID = user.id
user.get_energy()
db_sess.merge(user)
db_sess.commit()
return jsonify({
'result': 'OK',
'user': user.to_dict(),
})
def accept():
# принять сделку
_request = {
'token': request.json.get('token', ''),
'deal_id': request.json.get('deal_id', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
deal = db_sess.query(Deal).get(_request['deal_id'])
user = db_sess.query(User).get(config.USER_ID)
author = db_sess.query(User).get(deal.user.id)
res = user.send_deal(deal)
if res:
return jsonify(res)
author.get_deal(deal)
db_sess.delete(deal)
db_sess.commit()
db_sess.merge(user)
db_sess.commit()
db_sess.merge(author)
db_sess.commit()
return jsonify({'result': 'OK'})
def update(self):
if not self.waiting:
return
db_sess = db_session.create_session()
answer = db_sess.query(Shared).filter(Shared.id == 2).first()
if not answer.data:
return
try:
res = eval(answer.data)
if self.waiting in ['sign_in', 'sign_up']:
self.recognize_response(res)
if res['result'] == 'OK':
config.NICKNAME = self.saved
del self.saved
config.WINDOW.tabs['login'] = config.WINDOW.tabs['profile']
config.WINDOW.change_tab('profile')
user = res['user']
config.WINDOW.get('txtNickname').set_text(user['nickname'])
config.WINDOW.get('txtRating').set_text(user['rating'])
config.WINDOW.get('txtBest').set_text(user['best'])
config.WINDOW.get('txtCreated').set_text(user['created'])
elif self.waiting == 'get_users':
config.WINDOW.change_tab('rating')
for i, user in enumerate(sorted(
res['users'], key=lambda x: x['rating'])[::-1][:10]):
user['number'] = i + 1
config.WINDOW.get('tarPlayer0' + str(i)).set_text(user)
except Exception as e:
print('ERROR', e)
pass
self.waiting = ''
answer.data = ''
db_sess.merge(answer)
db_sess.commit()
def delete(self, job_id):
abort_if_job_not_found(job_id)
session = db_session.create_session()
job = session.query(Jobs).get(job_id)
session.delete(job)
session.commit()
return jsonify({'success': 'OK'})
def get_bets():
# получить ставки
_request = {
'token': request.json.get('token', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
bets = db_sess.query(Bet).all()
for bet in bets:
if bet.is_complete():
bet.on_complete()
db_sess.delete(bet)
db_sess.commit()
bets = db_sess.query(Bet).all()
while len(bets) < random.randint(15, 25):
# добавление ставок
new_bet = Bet()
new_bet.generate()
db_sess.add(new_bet)
db_sess.commit()
bets = db_sess.query(Bet).all()
bets = db_sess.query(Bet).all()
return jsonify({
'result': 'OK',
'data': [bet.to_dict() for bet in bets],
})
def delete(self, user_id):
abort_if_user_not_found(user_id)
session = db_session.create_session()
user = session.query(User).get(user_id)
session.delete(user)
session.commit()
return jsonify({'success': 'OK'})
def delete_job(job_id):
session = db_session.create_session()
job = session.query(Jobs).get(job_id)
if not job:
return jsonify({'error': 'Not found'})
session.delete(job)
session.commit()
return jsonify({'success': 'OK'})
def jobs_edit(job_id):
form = JobForm()
if request.method == "GET":
session = db_session.create_session()
if current_user.id == 1:
job = session.query(Jobs).filter(Jobs.id == job_id).first()
else:
job = session.query(Jobs).filter(
Jobs.id == job_id, Jobs.leader == current_user).first()
if job:
form.job.data = job.job
form.leader_id.data = job.leader_id
form.work_size.data = job.work_size
form.collaborators.data = job.collaborators
form.category.data = ', '.join(
map(lambda x: x.name, job.categories))
form.is_finished.data = job.is_finished
else:
abort(404)
if form.validate_on_submit():
session = db_session.create_session()
if current_user.id == 1:
job = session.query(Jobs).filter(Jobs.id == job_id).first()
else:
job = session.query(Jobs).filter(
Jobs.id == job_id, Jobs.leader == current_user).first()
if job:
job.leader_id = form.leader_id.data
job.job = form.job.data
job.work_size = form.work_size.data
job.collaborators = form.collaborators.data
for i in map(int, form.category.data.split(',')):
c = session.query(Category).filter(Category.id == i).first()
if not c:
c = Category(id=i, name=f'{i}')
job.categories.append(c)
job.is_finished = form.is_finished.data
session.commit()
return redirect('/')
else:
abort(404)
return render_template('jobs_add.html',
title='Редактирование работы',
form=form)
def get(self, user_id):
abort_if_user_not_found(user_id)
session = db_session.create_session()
user = session.query(User).get(user_id)
return jsonify({
'user':
user.to_dict(only=('id', 'name', 'surname', 'age', 'position',
'speciality', 'address', 'email',
'modified_date', 'city_from'))
})
async def bot_start(message: types.Message):
user_id = message.from_user.id
name_user = message.from_user.first_name
db_sess = db_session.create_session()
if db_sess.query(User.id).filter(User.id == user_id).all():
user = User(id_user=user_id, name_user=name_user)
db_sess.add(user)
db_sess.commit()
await message.answer(f"Привет, {message.from_user.full_name}!"
f"Жми /start_menu")
def get(self):
session = db_session.create_session()
jobs = session.query(Jobs).all()
return jsonify({
'jobs': [
item.to_dict(only=('id', 'leader_id', 'job', 'work_size',
'collaborators', 'start_date', 'end_date',
'is_finished')) for item in jobs
]
})
async def bot_start(message: types.Message):
user_id = message.from_user.id
name_user = message.from_user.first_name
db_sess = db_session.create_session()
if db_sess.query(User.id).filter(User.id == user_id).all():
user = User(id_user=user_id, name_user=name_user)
db_sess.add(user)
db_sess.commit()
await message.answer(f'Здравствуйте, {message.from_user.full_name}!'
f'Давайте начнем', reply_markup=start_mark)
def get(self, job_id):
abort_if_job_not_found(job_id)
session = db_session.create_session()
job = session.query(Jobs).get(job_id)
return jsonify({
'job':
job.to_dict(only=('id', 'leader_id', 'job', 'work_size',
'collaborators', 'start_date', 'end_date',
'is_finished'))
})
async def show_users(message: types.Message):
if str(message.from_user.id) in ADMINS:
await message.answer(
"Список пользователей, которые используют телеграмм бота: \n")
session = db_session.create_session()
news = session.query(User.id_user, User.name_user).all()
for i in news:
await message.answer(f'id - {i[0]} \nname - {i[1]}')
else:
await message.answer("У вас нет прав на использование этой команды!")
def get_job(job_id):
session = db_session.create_session()
job = session.query(Jobs).get(job_id)
if job:
return jsonify({
'jobs':
job.to_dict(only=('id', 'leader_id', 'job', 'work_size',
'collaborators', 'start_date', 'end_date',
'is_finished'))
})
return jsonify({'error': 'Not Found'})
def post(self):
args = parser.parse_args()
session = db_session.create_session()
job = Jobs(leader_id=args['leader_id'],
job=args['job'],
work_size=args['work_size'],
collaborators=args['collaborators'],
is_finished=args['is_finished'])
session.add(job)
session.commit()
return jsonify({'success': 'OK'})
def send(self, data, wait):
if self.waiting:
return
db_sess = db_session.create_session()
request = db_sess.query(Shared).filter(Shared.id == 1).first()
if request.data:
return
request.data = str(data)
self.waiting = wait
db_sess.merge(request)
db_sess.commit()
def stock_exchange():
# биржа
_request = {
'token': request.json.get('token', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
deals = db_sess.query(Deal).all()
return {'result': 'OK', 'data': [deal.to_dict() for deal in deals]}
def get(self):
session = db_session.create_session()
users = session.query(User).all()
return jsonify({
'users': [
item.to_dict(only=('id', 'name', 'surname', 'age', 'position',
'speciality', 'address', 'email',
'modified_date', 'city_from'))
for item in users
]
})
def jobs_delete(job_id):
session = db_session.create_session()
if current_user.id == 1:
job = session.query(Jobs).filter(Jobs.id == job_id).first()
else:
job = session.query(Jobs).filter(Jobs.id == job_id,
Jobs.leader == current_user).first()
if job:
session.delete(job)
session.commit()
else:
abort(404)
return redirect('/')
def departments_edit(department_id):
form = DepartmentForm()
if request.method == "GET":
session = db_session.create_session()
if current_user.id == 1:
department = session.query(Department).filter(
Department.id == department_id).first()
else:
department = session.query(Department).filter(
Department.id == department_id,
Department.chief == current_user).first()
if department:
form.title.data = department.title
form.chief_id.data = department.chief_id
form.email.data = department.email
form.members.data = department.members
else:
abort(404)
if form.validate_on_submit():
session = db_session.create_session()
if current_user.id == 1:
department = session.query(Department).filter(
Department.id == department_id).first()
else:
department = session.query(Department).filter(
Department.id == department_id,
Department.chief == current_user).first()
if department:
department.title = form.title.data
department.chief_id = form.chief_id.data
department.email = form.email.data
department.members = form.members.data
session.commit()
return redirect('/departments')
else:
abort(404)
return render_template('departments_add.html',
title='Редактирование департамента',
form=form)
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('/')
return render_template('login.html',
message='Неправильный логин или пароль',
form=form)
return render_template('login.html', title='Авторизация', form=form)
def post(self):
args = parser.parse_args()
session = db_session.create_session()
user = User(name=args['name'],
surname=args['surname'],
age=args['age'],
position=args['position'],
speciality=args['speciality'],
address=args['address'],
email=args['email'],
city_from=args['city_from'])
session.add(user)
session.commit()
return jsonify({'success': 'OK'})
def departments_delete(department_id):
session = db_session.create_session()
if current_user.id == 1:
department = session.query(Department).filter(
Department.id == department_id).first()
else:
department = session.query(Department).filter(
Department.id == department_id,
Department.chief == current_user).first()
if department:
session.delete(department)
session.commit()
else:
abort(404)
return redirect('/departments')
def rating():
# рейтинг пользователей
_request = {
'token': request.json.get('token', ''),
}
if not config.check_token(_request['token']):
return jsonify({'result': 'incorrect token'})
db_sess = create_session()
users = db_sess.query(User).all()
users = sorted(users,
key=lambda user: user.to_dict()['resources']['coin'],
reverse=True)
return jsonify({
'result': 'OK',
'data': [user.to_dict() for user in users],
})
def put(self, job_id):
abort_if_job_not_found(job_id)
session = db_session.create_session()
if not request.json:
return jsonify({'error': 'Empty request'})
user = session.query(Jobs).get(job_id)
if 'leader_id' in request.json:
user.leader_id = request.json['leader_id']
if 'job' in request.json:
user.job = request.json['job']
if 'work_size' in request.json:
user.work_size = request.json['work_size']
if 'collaborators' in request.json:
user.collaborators = request.json['collaborators']
if 'is_finished' in request.json:
user.is_finished = request.json['is_finished']
session.commit()
return jsonify({'success': 'OK'})
