def burning_notify():
reports = Report.objects.filter(tag='Burning').exclude(status='Closed')
output = reports.count()
if output > 0:
for user in notify_users:
send_message(
token, user,
f'Внимание! Сейчас в работе {output} срочных кейсов!')
def send_beat_notify():
reports = Report.objects.all().exclude(status='Closed')
refunds = MoneyBack.objects.all().exclude(status='Closed')
output = report_count(reports, refunds)
for user in notify_users:
send_message(
token,
user,
output,
parse_mode='HTML',
)
def requst_finish(req_id, req_data, auto=False):
markup = telebot.types.InlineKeyboardMarkup()
if req_data['accepted']:
status = 'Accepted ✅'
else:
status = 'Rejected ❌'
cmds_string = '\n'.join(['{} {}'.format(cmd_name, cmd_count) for cmd_name, cmd_count in req_data['items'].items()])
text = '''{}:
{}
Amount: {} ₽.
{}
({})'''.format(req_data['user_inf'], cmds_string, req_data['amount'], req_id, status)
try:
if not auto:
apihelper.edit_message_text(CONFIG.TG_BOT_TOKEN, text, TG_MY_ID, req_data['msg_id'], reply_markup=markup)
else:
# storage = CurrentUse.storage('', name='uses_requests')
apihelper.send_message(CONFIG.TG_BOT_TOKEN, TG_MY_ID, text)
except:
pass
if req_data['accepted']:
text = 'Your request has been accepted ✅.\n'
else:
text = 'Your request has been rejected ❌.\n'
text += '{}\n{}\n\n{}'.format(cmds_string, req_data['comment'], req_id)
contact = req_data['contact']
# todo notify user func
if contact['where'] == 'VK':
try:
payload = {
'peer_id': contact['id'],
'random_id': random.randint(0, 10000000),
'message': text
}
vk_session = vk_api.VkApi(token=CONFIG.VK_GROUP_TOKEN)
resp = vk_session.method('messages.send', payload)
except:
pass
elif contact['where'] == 'TG':
try:
apihelper.send_message(CONFIG.TG_BOT_TOKEN, contact['id'], text)
except:
pass
return 1
def chat(message):
chat_id = message.chat.id
try:
tg_user = get_tg_user(chat_id)
if message.text == reply_keyboard[1]['name']:
bot.send_message(message.chat.id,
'Позвони тебе помогут\n' + '8-(776)-168-87-60')
elif message.text == reply_keyboard[0]['name']:
bot.send_message(
message.chat.id,
f'Напиши что угодно я обязательно тебе помогу {tg_user.name}')
else:
send_message(tg_user, message.text)
except:
bot.send_message(message.chat.id, f'ERROR[chat]: {str(e)}')
def send_message(self,
chat_id,
text,
disable_web_page_preview=None,
reply_to_message_id=None,
reply_markup=None,
parse_mode=None):
"""
Use this method to send text messages.
Warning: Do not send more than about 5000 characters each message, otherwise you'll risk an HTTP 414 error.
If you must send more than 5000 characters, use the split_string function in apihelper.py.
:param chat_id:
:param text:
:param disable_web_page_preview:
:param reply_to_message_id:
:param reply_markup:
:param parse_mode:
:return: API reply.
"""
return types.Message.de_json(
apihelper.send_message(self.token, chat_id, text,
disable_web_page_preview,
reply_to_message_id, reply_markup,
parse_mode))
def notify_user(contact, text):
if contact['where'] == 'VK':
try:
payload = {
'peer_id': contact['id'],
'random_id': random.randint(0, 10000000),
'message': text
}
vk_session = vk_api.VkApi(token=CONFIG.VK_GROUP_TOKEN)
resp = vk_session.method('messages.send', payload)
return 1
except:
return 0
elif contact['where'] == 'TG':
try:
apihelper.send_message(CONFIG.TG_BOT_TOKEN, contact['id'], text)
return 1
except:
return 0
def send_message(self, chat_id, text, disable_web_page_preview=None, reply_to_message_id=None, reply_markup=None):
"""
Use this method to send text messages.
:param chat_id:
:param text:
:param disable_web_page_preview:
:param reply_to_message_id:
:param reply_markup:
:return:
"""
return apihelper.send_message(self.token, chat_id, text, disable_web_page_preview, reply_to_message_id,
reply_markup)
def send_message(self, chat_id, text, disable_web_page_preview=None, reply_to_message_id=None, reply_markup=None,
parse_mode=None):
"""
Use this method to send text messages.
Warning: Do not send more than about 5000 characters each message, otherwise you'll risk an HTTP 414 error.
If you must send more than 5000 characters, use the split_string function in apihelper.py.
:param chat_id:
:param text:
:param disable_web_page_preview:
:param reply_to_message_id:
:param reply_markup:
:param parse_mode:
:return: API reply.
"""
return types.Message.de_json(
apihelper.send_message(self.token, chat_id, text, disable_web_page_preview, reply_to_message_id,
reply_markup, parse_mode))
def send_message(self,
chat_id,
text,
disable_web_page_preview=None,
reply_to_message_id=None,
reply_markup=None):
"""
Use this method to send text messages.
:param chat_id:
:param text:
:param disable_web_page_preview:
:param reply_to_message_id:
:param reply_markup:
:return: API reply.
"""
return types.Message.de_json(
apihelper.send_message(self.token, chat_id, text,
disable_web_page_preview,
reply_to_message_id, reply_markup))
def _send_msg(self, msg1, markup):
try:
apihelper.send_message(self.token, self.chat_id, msg1, reply_markup=markup, parse_mode='HTML')
except Exception, e:
self.bot.log_error({'func': '_send_msg', 'token': self.token, 'chat_id': self.chat_id, 'message': msg1, 'error': str(e)})
def request_uses(CurrentUse):
if CurrentUse.parser_p.a:
cur_mode = 'a'
else:
cur_mode = 'm'
result_price = 0
result_cmds = {}
for item in CurrentUse.parser_p.items:
item_info = re.match('([а-яА-Яa-zA-Z\-_]+)([0-9]+)', item)
if not item_info:
CurrentUse.cancel_use()
return 'Wrong item <{}>'.format(item)
name = item_info[1]
count = int(item_info[2])
if count < 1:
CurrentUse.cancel_use()
return 'Wrong item <{}> (<0)'.format(item)
if name not in PRICES.keys():
CurrentUse.cancel_use()
return "Unknown item <{}>".format(name)
if 'mode' in PRICES[name]:
if cur_mode not in PRICES[name]['mode']:
cur_modes_strs = ', '.join(['"{}"'.format(MODES_STRS[mm]) for mm in PRICES[name]['mode']])
CurrentUse.cancel_use()
return '<{}> can be requested only in {} mode'.format(name, cur_modes_strs)
result_price += PRICES[name]['price'] * count
for cmd_name, cmd_count in PRICES[name]['contains']:
if cmd_name not in result_cmds:
result_cmds[cmd_name] = 0
result_cmds[cmd_name] += cmd_count * count
if not result_cmds:
CurrentUse.cancel_use()
return 'Эм а кто будет команды писать и всё такое'
request_id = str(uuid.uuid4())
if CurrentUse.user.vk_id:
payload = {
'user_ids': CurrentUse.user.vk_id,
'fields': '',
'name_case': 'Nom'
}
try:
resp = CurrentUse.vk_group.api.method('users.get', payload)[0]
user_inf = '{} {}'.format(resp['first_name'], resp['last_name'])
except:
user_inf = 'TG{}'.format(CurrentUse.user.tg_id)
else:
user_inf = 'TG{}'.format(CurrentUse.user.tg_id)
comment = ' '.join(CurrentUse.parser_p.comment)
cmds_string = '\n'.join(['{} {}'.format(cmd_name, cmd_count) for cmd_name, cmd_count in result_cmds.items()])
text = '''{}:
{}
{}
Amount: {} ₽.
{}'''.format(user_inf, cmds_string, comment, result_price, request_id)
cur_request = {
'user': CurrentUse.user.id,
'items': result_cmds,
'user_inf': user_inf,
'contact': {'where': CurrentUse.messenger.name, 'id': CurrentUse.peer_id},
'comment': comment,
'amount': result_price,
'auto': False,
}
if CurrentUse.parser_p.a:
cur_request['auto'] = True
cur_amount = result_price
u_storage = CurrentUse.storage('u', name='sberb_user')
if ('cards' not in u_storage) or (not u_storage['cards']):
return 'У тя не привязано ни одной карты. Для привязки юзай /реквест.п'
cards = u_storage['cards']
g_storage = CurrentUse.storage('', name='sberb_global')
CurrentUse.send_msg('Погоди немного...')
operation = sberb.check_transaction(g_storage, cur_amount, minuts=PAYMENT_VALID_TIME, cards=cards)
if operation is None:
return 'Не найдено(Если сделалб все всерно, подожди пару минут и попробуй еще раз. Если трабл не пофиксился, кидай обычный реквест)'
else:
cur_request['accepted'] = 1
used_transactions = g_storage['used_transactions']
used_transactions.append(operation['id'])
g_storage.save()
for cmd_name, cmd_cnt in result_cmds.items():
status = CurrentUse.user.change_executions(cmd_name, cmd_cnt)
requst_finish(request_id, cur_request, auto=True)
return None
accept_payload = json.dumps({"cmd_str": "/req.r {} {}".format(request_id, 1)})
reject_payload = json.dumps({"cmd_str": "/req.r {} {}".format(request_id, 0)})
markup = telebot.types.InlineKeyboardMarkup(row_width=1)
accept_btn = telebot.types.InlineKeyboardButton('Accept', callback_data=accept_payload)
reject_btn = telebot.types.InlineKeyboardButton('Reject', callback_data=reject_payload)
markup.add(accept_btn, reject_btn)
resp = apihelper.send_message(CONFIG.TG_BOT_TOKEN, TG_MY_ID, text, reply_markup=markup)
msg_id = resp['message_id']
cur_request['msg_id'] = msg_id
storage = CurrentUse.storage('', name='uses_requests')
if 'actual' not in storage:
storage['actual'] = {}
storage['actual'][request_id] = cur_request
storage.save()
return 'Request has been sent.\n\n{}'.format(request_id)
def _send_message(self, receiver: str, message: Message) -> str:
if message.buttons:
kb = types.ReplyKeyboardMarkup()
kb.add(*[x.text for x in message.buttons])
else:
kb = None
reply_to_id = (message.reply_to_id.split('_')[1]
if message.reply_to_id else None)
# TODO implement chat work. now only tet-a-tet
receiver = receiver.split('_')[0]
if isinstance(message, Text):
msg_id = apihelper.send_message(
self.token, receiver, message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, Sticker):
method_name = 'sendSticker'
data = {'chat_id': receiver, 'sticker': message.file_id}
if reply_to_id:
data.update(reply_to_message_id=reply_to_id)
msg_id = apihelper._make_request(
self.token, method_name,
params=data, method='post'
)
elif isinstance(message, Picture):
picture = message.file_id or message.file_url
msg_id = apihelper.send_photo(
self.token, receiver, picture,
caption=message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, Audio):
audio = message.file_id or message.file_url
if message.is_voice:
msg_id = apihelper.send_voice(
self.token, receiver, audio,
duration=message.file_duration,
caption=message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
else:
msg_id = apihelper.send_audio(
self.token, receiver, audio,
title=message.file_name,
duration=message.file_duration,
caption=message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, Video):
video = message.file_id or message.file_url
if message.is_video_note:
msg_id = apihelper.send_video_note(
self.token, receiver, video,
duration=message.file_duration,
# length=message.file_length,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
else:
msg_id = apihelper.send_video(
self.token, receiver, video,
duration=message.file_duration,
caption=message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, File):
data = message.file_id or message.file_url
data_type = 'document'
msg_id = apihelper.send_data(
self.token, receiver, data, data_type,
caption=message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, Contact):
contact = message.contact
msg_id = apihelper.send_contact(
self.token, receiver,
contact.get('phone'),
contact.get('first_name'),
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, Url):
msg_id = apihelper.send_message(
self.token, receiver, message.text,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, Location):
location = message.location
msg_id = apihelper.send_location(
self.token, receiver,
location.get('latitude'),
location.get('longitude'),
reply_to_message_id=reply_to_id,
reply_markup=kb
)
elif isinstance(message, RichMedia):
msg_id = apihelper.send_message(
self.token, receiver, message.text,
parse_mode=message.rich_media,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
else:
msg_id = apihelper.send_message(
self.token, receiver, message.context,
reply_to_message_id=reply_to_id,
reply_markup=kb
)
return f'{receiver}_{msg_id}'
return
elif command == 'end':
end_action(call)
return
func = util.classes.callback_commands[command]
func(call=call)
return
def main():
logger.info("Bot started.")
try:
bot.polling(none_stop=True)
finally:
logger.info("Bot stopped.")
if __name__ == '__main__':
try:
main()
print('Bot finished.')
except KeyboardInterrupt:
quit()
except Exception as e:
content = "The FrichtleOrganiser Bot crashed.\n\nError:\n\n{}".format(
traceback.format_exc())
send_message(token=meta.bot_token,
chat_id=meta.lucas_chat_id,
text=content)
