async def change_status(callback_query: types.CallbackQuery):
scroll = callback_query.data != button_current_status.callback_data
uid = callback_query.from_user.id
message = callback_query.message
event_id, _ = await admin_nav_context.get(user=uid, key=message.message_id)
with session_scope() as session:
event_q = session.query(Event) \
.filter(Event.id == event_id)
event: Event = event_q.all()[0]
users_enrolls_q = session.query(User, Enrollment) \
.join(Enrollment) \
.join(Event) \
.filter(Event.id == event_id) \
.order_by(Enrollment.edit_datetime.desc())
count = users_enrolls_q.count()
if scroll:
list_ = [x for x in Event.status_map.keys()]
pos = list_.index(event.status)
new_status, pos = fetch_list(list_,
current_pos=pos,
do_scroll=scroll,
where=callback_query.data)
event.status = new_status
await send_event_message(message, event, count, edit=True)
await bot.answer_callback_query(callback_query.id)
async def process_publish_message(message: types.Message):
uid = message.from_user.id
state = dp.current_state(user=uid)
state_data = await state.get_data()
if message.text.lower() == 'отмена':
await state.set_state(MenuStates.all()[0])
return
else:
await state.set_state(PublishStates.all()[1])
with session_scope() as session:
users_q = session.query(User) \
.filter(User.active == True) \
.filter(User.receive_notifications == True)
names_list = [x.full_name for x in users_q.all()]
await message.reply(MESSAGES['admin_publish_user_list'] + full_names_list_str(names_list),
reply=False)
result = await message.reply(message.text,
reply=False,
reply_markup=keyboard_publish)
await admin_nav_context.save(user=uid,
key='event_id_message_' + str(result.message_id),
value=state_data['event_id'])
def update_user(self, user_id: int, user: schemas.UserUpdate) -> Any:
""" Update User"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
db_user.first_name = user.first_name
db_user.last_name = user.last_name
db_user.full_name = user.full_name
db_user.city = user.city
db_user.country = user.country
db_user.is_active = user.is_active
db_user.is_superuser = user.is_superuser
db_user.is_admin = user.is_admin
db_user.modified_by_userid = user.modified_by_userid
db_user.modified_timestamp = datetime.utcnow()
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("update_user")
return None
def dadosIniciais():
"Popula o banco com configurações rendainiciais."
try:
with session_scope() as session:
dao = Dao(session)
# Usuário
usuario = Usuario()
usuario.login = '******'
usuario.senha = '1234'
usuario.nome = 'Admin'
usuario.nivel = 2
dao.salvar(usuario)
# renda
renda = Renda()
renda.produtor = 'Maria do Céu'
renda.variedade = 'Iapar'
renda.area = float(2)
renda.amostra = float(1)
renda.peso = float(5)
renda.peso_total = float(200000)
# renda.data = datetime.datetime.now
renda.tom = 1
renda.local = 'Paranavaí'
renda.sugestao = 'Ideal para venda'
renda.total = Decimal('35000')
renda.grama = Decimal(float(0.70))
dao.salvar(renda)
except Exception as e:
print('Erro dados iniciais: ' + str(e))
async def consultar_fonte_renda(request):
dados = request.json
if dados:
with session_scope() as session:
dao = DaoInfo(session)
fonte_renda = dao.buscar_fonte_renda(dados['cpf'])
return json(fonte_renda)
def create_user(self, user: schemas.UserCreate) -> Any:
""" Add New User"""
try:
with session_scope() as db:
hashed_password = passutil.get_password_hash(str(
user.password))
db_user = models.User(
email=user.email,
password=hashed_password,
first_name=user.first_name,
last_name=user.last_name,
full_name=user.full_name,
gender=user.gender,
is_active=user.is_active,
is_superuser=user.is_superuser,
is_admin=user.is_admin,
created_by_userid=user.created_by_userid,
modified_by_userid=user.created_by_userid)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("create_user")
return None
async def show_event_list_task(uid, markup_only=False):
state = dp.current_state(user=uid)
with session_scope() as session:
events_q = session.query(Event) \
.join(User, User.uid == uid) \
.outerjoin(Enrollment, and_(Enrollment.user_id == User.id, Enrollment.event_id == Event.id)) \
.filter(Event.status == 1) \
.filter(or_(Enrollment.id == None, Enrollment.complete == False)) \
.order_by(Event.edit_datetime.desc())
if events_q.count() > 0:
m_text = MESSAGES['show_event_menu']
events_keyboard = events_reply_keyboard(events_q.all())
if markup_only:
return events_keyboard
else:
await bot.send_message(uid,
text=m_text,
reply_markup=events_keyboard)
await state.set_state(UserStates.all()[2])
else:
m_text = MESSAGES['no_current_events']
await bot.send_message(uid, text=m_text)
return None
async def enroll_event(obj: types.base.TelegramObject):
callback = False
callback_query = None
if isinstance(obj, types.CallbackQuery):
callback = True
callback_query = obj
message = obj.message
uid = callback_query.from_user.id
elif isinstance(obj, types.Message):
message = obj
uid = message.from_user.id
else:
return
state = dp.current_state(user=uid)
with session_scope() as session:
if callback:
event_id = await user_notify_context.get(user=uid,
key=message.message_id)
else:
event_q = session.query(Event) \
.filter(Event.title == message.text)
if event_q.count() == 0:
return
event: Event = event_q.all()[0]
event_id = event.id
await state.set_data({'event_id': event_id})
user_q = session.query(User) \
.filter(User.uid == uid)
user: User = user_q.all()[0]
enrolled_q = session.query(Enrollment) \
.join(User) \
.filter(User.uid == uid) \
.filter(Enrollment.event_id == event_id)
if enrolled_q.count() == 0:
# create enrollment
enrollment = Enrollment(user_id=user.id,
event_id=event_id,
complete=False) \
.insert_me(session)
logging.info(f'enrollment created: {enrollment}')
else:
enrollment = enrolled_q.all()[0]
# build message
if enrollment.complete:
m_text = MESSAGES['registration_exists']
remove_keyboard = None
else:
m_text = MESSAGES['invoice_prompt']
remove_keyboard = ReplyKeyboardRemove()
await state.set_state(UserStates.all()[3])
await message.reply(m_text,
parse_mode=ParseMode.MARKDOWN,
reply=False,
reply_markup=remove_keyboard)
if callback:
await bot.answer_callback_query(callback_query.id)
async def process_create_event_data(message: types.Message):
uid = message.from_user.id
state = dp.current_state(user=uid)
state_str = str(await state.get_state())
state_number = int(state_str[-1:])
state_data = await state.get_data() or {}
if state_str in CreateEventStates.all():
input_data = message.text if message.text != '-' else ''
if input_data == button_cancel.text:
await state.set_state(MenuStates.all()[0])
await state.set_data({})
await process_start_command_admin(message)
return
state_data[str(state_number)] = input_data
await state.set_data(state_data)
if state_number < len(CreateEventStates.all()) - 1:
state_number += 1
await state.set_state(CreateEventStates.all()[state_number])
await message.reply(MESSAGES['create_event_prompt_data_' + str(state_number)],
reply=False,
reply_markup=keyboard_cancel)
else:
with session_scope() as session:
Event(title=state_data['1'],
description=state_data['2'],
access_info=state_data['3']) \
.insert_me(session)
await message.reply(MESSAGES['create_event_done'],
reply=False)
await state.set_state(MenuStates.all()[0])
await state.set_data({})
await process_start_command_admin(message)
async def consultar_dados_cliente(request):
dados = request.json
if dados:
with session_scope() as session:
dao = DaoInfo(session)
cliente = dao.buscar_cpf(dados['cpf'])
dic = cliente.json
return json(dic)
async def view_enrolls(callback_query: types.CallbackQuery):
refresh_header = scroll = view = edit = False
if callback_query.data == button_refresh.callback_data:
refresh_header = edit = True
elif callback_query.data in [x.callback_data for x in scroll_buttons_list]:
scroll = edit = True
else:
view = True
uid = callback_query.from_user.id
message = callback_query.message
event_id, pos = await admin_nav_context.get(user=uid,
key=message.message_id)
with session_scope() as session:
event_q = session.query(Event) \
.filter(Event.id == event_id)
event: Event = event_q.all()[0]
users_enrolls_q = session.query(User, Enrollment) \
.join(Enrollment) \
.join(Event) \
.filter(Event.id == event_id) \
.order_by(Enrollment.edit_datetime.desc())
user_enroll_list, enrolled_count = users_enrolls_q.all(
), users_enrolls_q.count()
names_list = [x[0].full_name for x in user_enroll_list]
if (view and enrolled_count > 0) or refresh_header:
result = await send_user_list_message(message,
event,
names_list,
edit=edit)
await admin_nav_context.save(user=uid,
key=result.message_id,
value=(
event.id,
pos,
))
if (view and enrolled_count > 0) or scroll:
(user, enrollment), pos = fetch_list(user_enroll_list,
current_pos=pos,
do_scroll=scroll,
where=callback_query.data)
result = await send_enrollment_message(message,
user,
enrollment,
edit=edit)
await admin_nav_context.save(user=uid,
key=result.message_id,
value=(
event.id,
pos,
))
await bot.answer_callback_query(callback_query.id)
def get_user_password(email: str) -> Any:
""" Get User Password based on email"""
try:
with session_scope() as db:
statement = select(models.User).where(models.User.email == email)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_user")
return None
async def process_delete_user_command(message: types.Message):
uid_to_delete = message.get_args()
with session_scope() as session:
user_q = session.query(User) \
.filter(User.uid == uid_to_delete)
# get one record
if user_q.count() > 0:
user: User = user_q.all()[0]
user.delete_me(session)
await message.reply(MESSAGES['admin_record_deleted'],
reply=False)
def get_article(self, article_id: str):
""" Get A Single article """
try:
with session_scope() as db:
statement = select(models.Article).where(
models.Article.article_id == article_id)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_article")
return None
def consultar_cpf():
"""
Método que retorna dados do cliente buscando pelo cpf informado.
:return: json com dados do cliente
"""
dados = request.get_json()
if dados:
with session_scope() as session:
dao = DaoCliente(session)
cliente = dao.buscar_cpf(dados['cpf'])
dic = {'id': cliente.id, 'nome': cliente.nome}
return jsonify(cliente=dic)
def get_user_id(self, id: int) -> Any:
""" Get User Data based on id"""
try:
with session_scope() as db:
statement = select(models.User).where(
models.User.id == id).options(defer('password'))
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_user_id")
return None
def check_active_session(self, session_id: str):
""" check for active session """
try:
with session_scope() as db:
statement = select(models.UsersLoginAttempt).where(
models.UsersLoginAttempt.session_id == session_id)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("check_active_session")
return None
async def name(message: types.Message):
uid = message.from_user.id
with session_scope() as session:
user = User(uid=uid,
username=message.from_user.username,
full_name=message.text) \
.insert_me(session)
logging.info(f'user created: {user}')
await message.reply(MESSAGES['pleased_to_meet_you'],
parse_mode=ParseMode.MARKDOWN,
reply=False)
await show_event_list_task(uid)
def check_password(self, user_id: int, password: str):
""" get user Password"""
try:
with session_scope() as db:
statement = select(
models.User.password).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
return passutil.verify_password(str(password),
str(db_user.password))
except SQLAlchemyError as e:
fastapi_logger.exception("get_password")
return None
def verify_user(self, email: str) -> Any:
""" Verify User"""
try:
with session_scope() as db:
statement = select(
models.User.id,
models.User.email).where(models.User.email == email)
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("verify_user")
return None
def get_all_articles(self, page_num: int) -> Any:
""" Get All Articles """
try:
with session_scope() as db:
query = select(models.Article).order_by(
models.Article.modified_timestamp)
data = pagination.paginate(query=query, db=db,
model=models.Article, page=page_num,
page_size=30)
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_all_articles")
return None
def delete_article(self, article_id: str) -> Any:
""" Delete Article """
try:
with session_scope() as db:
statement = select(models.Article).where(
models.Article.article_id == article_id)
results = db.exec(statement)
db_article = results.one()
db.delete(db_article)
db.commit()
return True
except SQLAlchemyError as e:
fastapi_logger.exception("delete_article")
return None
async def toggle_notification_click(callback_query: types.CallbackQuery):
message = callback_query.message
uid = callback_query.from_user.id
with session_scope() as session:
user_q = session.query(User) \
.filter(User.uid == uid)
user: User = user_q.all()[0]
user.receive_notifications = (
callback_query.data == button_turn_notifications_on.callback_data)
await message.edit_reply_markup(
reply_markup=get_notifications_keyboard(user.receive_notifications)
)
await bot.answer_callback_query(callback_query.id)
def get_active_user(email: str) -> Any:
""" Get User Data based on email and active status"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.email == email).where(
models.User.is_active == expression.true()).options(
defer('password'))
results = db.exec(statement)
data = results.one()
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_user")
return None
def delete_user(self, user_id: int) -> Any:
""" Delete User"""
try:
with session_scope() as db:
statement = select(
models.User).where(models.User.id == user_id)
results = db.exec(statement)
db_user = results.one()
db.delete(db_user)
db.commit()
return True
except SQLAlchemyError as e:
fastapi_logger.exception("delete_user")
return None
async def show_events_task_admin(message: types.Message, archived=False):
with session_scope() as session:
events_q = session.query(Event)
if archived:
m_text = MESSAGES['admin_archive']
events_q = events_q.filter(Event.status == 10)
else:
m_text = MESSAGES['admin_events']
events_q = events_q.filter(Event.status <= 9)
events_q = events_q.order_by(Event.edit_datetime.desc())
events_keyboard = events_reply_keyboard(events_q.all(),
admin_mode=True,
archived=archived)
await message.reply(m_text, reply=False, reply_markup=events_keyboard)
async def process_start_command(message: types.Message):
uid = message.from_user.id
state = dp.current_state(user=uid)
with session_scope() as session:
user_q = session.query(User) \
.filter(User.uid == uid)
if user_q.count() == 0:
await state.set_state(UserStates.all()[1]
) # greet and prompt for name and surname
await message.reply(MESSAGES['greet_new_user'],
parse_mode=ParseMode.MARKDOWN,
reply=False)
else:
await show_event_list_task(message.from_user.id)
def get_all_user(self, page_num: int) -> Any:
""" Get All Users"""
try:
with session_scope() as db:
# data = db.query(models.User).options(defer('password')).all()
statement = select(models.User).options(
defer('password')).order_by(models.User.modified_timestamp)
data = pagination.paginate(query=statement,
db=db,
model=models.User,
page=page_num,
page_size=100)
return data
except SQLAlchemyError as e:
fastapi_logger.exception("get_all_user")
return None
def update_user_password(self, email: str, password: str) -> Any:
""" Update User Password"""
try:
with session_scope() as db:
hashed_password = passutil.get_password_hash(password)
statement = select(
models.User).where(models.User.email == email)
results = db.exec(statement)
db_user = results.one()
db_user.password = hashed_password
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("update_user_password")
return None
def create_article(self, article: schemas.ArticleCreate) -> Any:
""" Create New Article """
try:
with session_scope() as db:
uid = str(uuid.uuid4().hex)
db_user = models.Article(article_id=uid,
user_id=article.user_id,
article_title=article.article_title,
article_text=article.article_text,
tags=article.tags)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("create_article")
return None
