async def show_articles_by_category_title(self, category_title, query_id):
# products = [product for product in Product.objects(category=Category.objects(title=category_title).get())]
# session.add(Category(title=category_title))
# session.commit()
# category = session.query(Category).filter_by(title=category_title).all()
# session.add(Product(category=category))
# session.commit()
# products = [product for product in session.query(Product).filter_by(category=session.query(Product).filter_by(category=category).first())]
category = session.query(Category).filter_by(title=category_title).first()
products = session.query(Product).filter_by(category=category.id).all()
# products = [product for product in products]
await self.show_products_inline(products, query_id)
def get_cart_by_user(user, archived_id=None):
if archived_id:
# query_res = Cart.objects(user=user, id=archived_id, is_archived=True)
query_res = session.query(Cart).filter_by(user=user.telegram_id, id=archived_id, is_archived=True)
return query_res.first() if query_res else None
# query_res = Cart.objects(user=user, is_archived=False)
query_res = session.query(Cart).filter_by(user=user.telegram_id, is_archived=False).first()
# return query_res.first() if query_res else Cart.objects.create(user=user)
if query_res:
return query_res
else:
session.add(Cart(user=user.telegram_id))
session.commit()
return session.query(Cart).filter_by(user=user.telegram_id, is_archived=False).first()
async def show_categories(self, data, message):
kb = InlineKeyboardMarkup()
title_text = ' | Категории:'
# category = Category.objects.get(id=data)
category = session.query(Category).filter_by(id=data).first()
buttons = []
if category.sub_categories:
buttons = []
for cat in category.sub_categories:
if cat.sub_categories:
buttons.append(InlineKeyboardButton(text=cat.title, callback_data=str(cat.id)))
continue
buttons.append(
InlineKeyboardButton(text=cat.title,
switch_inline_query_current_chat='category_' + str(cat.title)))
if not category.is_root:
buttons.append(InlineKeyboardButton(text='<<< Назад', callback_data=str(category.parent.id)))
buttons.append(InlineKeyboardButton(text='^ В начало', callback_data=START_KB['categories']))
kb.add(*buttons)
if not category.sub_categories:
title_text = ' | Товары:'
await self.show_products_inline(category.get_products(), message.chat.id)
await self._bot.delete_message(message.chat.id, message.message_id)
await self._bot.send_message(message.chat.id, category.title + title_text, reply_markup=kb)
return
await self._bot.edit_message_text(category.title + title_text,
message_id=message.message_id,
chat_id=message.chat.id,
reply_markup=kb)
async def order_history_inline(self, query):
user_id = str(query.from_user.id)
# get carts with is_archived = True
user = await BotService.get_user_by_telegram_id(query.from_user.id)
# cart_query = Cart.objects(user=user, is_archived=True)
cart_query = session.query(Cart).filter_by(user=user.telegram_id, is_archived=True)
if not cart_query:
return await self._bot.send_message(user_id, "No archived carts found")
carts = [cart for cart in cart_query]
results = []
for i, cart in enumerate(carts):
temp_res = InlineQueryResultArticle(
id=i + 1,
title=f'DATE: {cart.archive_date.strftime(self.datetime_fmt)}',
description=f'TOTAL: {cart.get_total_str()}',
input_message_content=InputTextMessageContent(
disable_web_page_preview=False,
message_text=await self.get_bill_text(cart.get_cart_products_freq_dict(),
cart.get_total_str(),
cart.archive_date)
),
)
results.append(temp_res)
if results:
await self._bot.answer_inline_query(query.id, results, cache_time=0)
def listar(self):
try:
servidores = session.query(servermodel).all()
for s in servidores:
print s.id, ' - ', s.nome, ' - ' , s.descricao
except Exception as e:
print 'Falhou ao listar: ', e
async def get_user_by_telegram_id(telegram_id):
if type(telegram_id) != str:
telegram_id = str(telegram_id)
if not telegram_id:
return None
# return User.objects(telegram_id=telegram_id).first()
return session.query(User).filter_by(telegram_id=telegram_id).first()
async def get_bill_text(self, products_dict, cart_total, archived_date):
if not products_dict:
return ""
bill = f"""
ORDER TIME: {archived_date.strftime(BotService.datetime_fmt)}
TOTAL: {cart_total}
##########################"""
for product, count in products_dict.items():
product = session.query(Product).filter_by(id=product).first()
qty = session.query(CartProduct).filter_by(cart=products_dict[product.id].cart, product=product.id).all()
bill += f"""
TITLE: {product.title}
QTY: {len(qty)}
PRICE: {product.get_price_str()}
TOTAL: {product.get_total_str(len(qty))}
--------------------------"""
return bill
async def show_promo_products(self, message):
await self._bot.delete_message(message.chat.id, message.message_id)
# promo_products_query = Product.objects.filter(discount_price__exists=True)
promo_products_query = session.query(Product).filter(Product.discount_price.isnot(None))
if promo_products_query.count() == 0:
return await self._bot.send_message(message.chat.id, 'No discount products found')
promo_products = []
[promo_products.append(promo_product) for promo_product in promo_products_query]
await self.show_products(promo_products, message.chat.id)
def remove(self):
try:
user = session.query(UserModel) \
.filter(UserModel.nome == self.nome) \
.first()
session.delete(user)
session.commit()
except Exception as e:
session.rollback()
print 'Falhou ao remover usuario: ', e
async def process_inline(self, query):
data = query.query
if not data:
return
# query_set = Product.objects(title__contains=data)
data = Product.title.ilike('%' + str(data) + '%')
query_set = session.query(Product).filter(data)
if query_set.count() == 0:
return
products = [product for product in query_set]
await self.show_products_inline(products, query.id)
async def cart_actions(self, call):
action = call.data.split('_')[1]
if action == 'nothing':
return
user_id = str(call.message.chat.id)
user = await BotService.get_user_by_telegram_id(call.from_user.id)
cart = self.get_cart_by_user(user)
if cart.is_archived:
return await self._bot.answer_callback_query(call.id, show_alert=False,
text=f"This cart is already archived")
if action == 'drop':
cart.remove_all_from_cart()
return await self._bot.answer_callback_query(call.id, text=f"✔ All products removed from cart")
product_id = str(call.data.split('_')[2])
# product = Product.objects(id=product_id).get()
product = session.query(Product).filter_by(id=product_id).first()
if action == 'remove':
cart.remove_product_from_cart(product)
await self._bot.delete_message(user_id, message_id=call.message.message_id)
return
reply_markup = call.message['reply_markup']
rp_t = reply_markup['inline_keyboard'][0][1]['text']
if action == 'increase':
if product.in_stock == int(rp_t):
return await self._bot.answer_callback_query(call.id, show_alert=True,
text=f"MAX STOCK ITEMS REACHED for {product.title}")
cart.add_product_to_cart(product)
rp_t = str(int(rp_t) + 1)
if action == 'decrease':
if cart.get_product_qty(product) == 0:
return
cart.delete_product_from_cart(product)
rp_t = str(int(rp_t) - 1)
if rp_t == '0':
await self._bot.delete_message(user_id, message_id=call.message.message_id)
return
reply_markup['inline_keyboard'][0][1]['text'] = rp_t
cart_prod_text = f'{product.title}\n' \
f'Price: {product.get_price_str()}\n' \
f'Total: {product.get_total_str(int(rp_t))}\n'
await self._bot.edit_message_text(text=cart_prod_text, chat_id=user_id, message_id=call.message.message_id,
reply_markup=reply_markup)
async def view_root_categories(self, message):
cats = session.query(Category).filter_by(is_root=True)
kb = InlineKeyboardMarkup()
buttons = [InlineKeyboardButton(text=cat.title, callback_data=str(cat.id)) for cat in cats]
buttons.append(InlineKeyboardButton(text="Поиск товаров по названию", switch_inline_query_current_chat=''))
kb.add(*buttons)
if message.from_user.is_bot:
return await self._bot.edit_message_text('Выберите категорию',
message_id=message.message_id,
chat_id=message.chat.id,
reply_markup=kb)
await self._bot.send_message(message.chat.id, 'Выберите категорию', reply_markup=kb)
def get(self, login):
try:
user = session.query(UserModel) \
.filter(UserModel.nome==login) \
.first()
if user:
self.nome = user.nome
self.senha = user.senha
return self
else:
return None
except Exception as e:
print 'Falhou ao buscar usuario: ', e
def remove(self, nome):
try:
servidor = session.query(servermodel) \
.filter(servermodel.nome==nome) \
.first()
if servidor:
d = Docker()
d.removecontainer(nome)
session.delete(servidor)
session.commit()
print 'Servidor removido com sucesso.'
else:
print 'Servidor nao encontrado.'
except Exception as e:
session.rollback()
print 'Falhou ao remover: ', e
async def show_cart(self, message):
user_id = str(message.chat.id)
user = await BotService.get_user_by_telegram_id(message.from_user.id)
user_cart = self.get_cart_by_user(user)
if not user_cart or user_cart.get_size() == 0:
# if not user_cart:
return await self._bot.send_message(user_id, 'No articles yet in cart')
frequencies = user_cart.get_cart_products() #.item_frequencies('product')
frequencies = {fre.product: fre for fre in frequencies}
products_dict = {cart_product.product: cart_product for cart_product in user_cart.get_cart_products()}
# products_dict = {print(cart_product.product) for cart_product in user_cart.get_cart_products()}
for key, cart_product in products_dict.items():
# qty = frequencies[key]
qty =1 # fiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiix
product = session.query(Product).filter_by(id=key).first()
# cart_prod_text = f'{cart_product.product.title}\n' \
# f'Qty: {cart_product.product.in_stock}\n' \
# f'Price: {cart_product.product.get_price_str()}\n' \
# f'Total: {cart_product.product.get_total_str(qty)}\n'
cart_prod_text = f'{product.title}\n' \
f'Qty: {product.in_stock}\n' \
f'Price: {product.get_price_str()}\n' \
f'Total: {product.get_total_str(qty)}\n'
kb = InlineKeyboardMarkup()
buttons = [
InlineKeyboardButton(text=u'\U00002796', callback_data='cart_decrease_' + str(key)),
InlineKeyboardButton(text=str(qty), callback_data='cart_nothing'),
InlineKeyboardButton(text=u'\U00002795', callback_data='cart_increase_' + str(key)),
InlineKeyboardButton(text=u'\U0000274C', callback_data='cart_remove_' + str(key))
]
kb.add(*buttons) # 2795
await self._bot.send_message(user_id, cart_prod_text, reply_markup=kb)
kb = InlineKeyboardMarkup()
kb.add(InlineKeyboardButton(text=f'TOTAL: {user_cart.get_total_str()}', callback_data='total'))
kb.add(
InlineKeyboardButton(text='ORDER ' + u'\U00002714', callback_data='order'),
InlineKeyboardButton(text='REMOVE ALL ' + u'\U0000274C', callback_data='cart_drop'),
)
await self._bot.send_message(user_id, 'Order:', reply_markup=kb)
async def add_to_cart(self, call):
user_id = str(call.from_user.id)
# product = Product.objects.get(id=call.data.split('_')[1])
product = session.query(Product).filter_by(id=call.data.split('_')[1]).first()
# if stock = 0 we cannot add this prod to cart
if product.in_stock == 0:
return await self._bot.answer_callback_query(call.id, text=f"❌ Product is out of stock")
user = await BotService.get_user_by_telegram_id(call.from_user.id)
user_cart = self.get_cart_by_user(user)
if user_cart.is_archived:
return await self._bot.answer_callback_query(call.id, show_alert=False,
text=f"This cart is already archived")
if await self.check_cart_limit_reached(user_cart, product):
await self._bot.answer_callback_query(call.id, show_alert=True,
text=f"MAX STOCK ITEMS REACHED for {product.title}")
return
user_cart.add_product_to_cart(product)
await self._bot.answer_callback_query(call.id, text=f"✔ Added to cart: {product.title}")
async def show_archive(self, message):
user_id = str(message.chat.id)
# get carts with is_archived = True
user = await BotService.get_user_by_telegram_id(message.from_user.id)
# query = Cart.objects(user=user, is_archived=True)
query = session.query(Cart).filter_by(user=user.telegram_id, is_archived=True)
if not query:
return await self._bot.send_message(user_id, "No archived carts found")
carts = [cart for cart in query]
kb = InlineKeyboardMarkup()
for cart in carts:
button_text = f'DATE: {cart.archive_date.strftime(BotService.datetime_fmt)} ' \
f'TOTAL: {cart.get_total_str()}'
kb.add(InlineKeyboardButton(button_text, callback_data='archive_' + str(cart.id)))
if not kb:
return await self._bot.send_message(user_id, text='No archived orders yet')
await self._bot.send_message(user_id, text='Orders history:', reply_markup=kb)
def check_user_by_telegram_id(telegram_id, username):
if type(telegram_id) != str:
telegram_id = str(telegram_id)
if not telegram_id:
return None
# user = User.objects(telegram_id=telegram_id).first()
user = session.query(User).filter_by(telegram_id=telegram_id).first()
if not user:
# user = User.objects.create(
# telegram_id=telegram_id,
# username=username if username else 'No user name',
# total=0,
# creation_date=datetime.now()
# )
user = session.add(User(telegram_id=telegram_id,
username=username if username else 'No user name',
total=0,
creation_date=datetime.now()))
session.commit()
return user
async def check_cart_limit_reached(self, user_cart, product):
# count = CartProduct.objects(cart=user_cart, product=str(product.id)).count()
count = session.query(CartProduct).filter_by(cart=user_cart.id, product=str(product.id)).count()
if count == product.in_stock:
return True
return False
def listall(self):
try:
all_users = session.query(UserModel).all()
return all_users
except Exception as e:
print 'Falhou ao listar usuarios: ', e
async def subtract_qty(self, products_dict):
for product, qty in products_dict.items():
product = session.query(Product).filter_by(id=product).first()
qty = len(session.query(CartProduct).filter_by(cart=products_dict[product.id].cart, product=product.id).all())
product.in_stock -= qty
product.save()
