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