def bus_info_response(self, query):
self.logger.info(f'Bus info query: "{query}"')
response = self.cds.load_codd_buses(parse_routes(query)[1])
response = {'q': query, 'result': [x._asdict() for x in response]}
self.write(json.dumps(response))
self.caching()
def settings(self, _, update, args):
user_id = update.message.from_user.id
settings = self.user_settings.get(user_id, {})
route_settings = settings.get('route_settings', [])
input_routes = parse_routes(args)[1]
if input_routes:
cmd = input_routes[0].lower()
change_routes = [
y for x in input_routes for y in self.cds.bus_routes.keys()
if x.upper() == y.upper()
]
if len(input_routes) == 1 and cmd in ('all', 'none', 'все'):
route_settings = []
elif cmd in ('del', '-'):
route_settings = [
x for x in route_settings if x not in change_routes
]
elif cmd in ('add', '+'):
route_settings = list(set(route_settings + change_routes))
else:
route_settings = change_routes
settings['route_settings'] = sorted(route_settings,
key=natural_sort_key)
self.user_settings[user_id] = settings
update.message.reply_text(
f"Текущие маршруты для вывода: {' '.join(route_settings)}")
return
keyboard = self.get_buttons_routes(route_settings)
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text('Укажите маршруты для вывода:',
reply_markup=reply_markup)
def user_input(self, bot, update):
self.ping_prod()
message = update.message
user = message.from_user
text = message.text
self.track(TgEvent.USER_INPUT, update, text[:30])
if not text or text == 'Отмена':
message.reply_text(text=f"Попробуйте воспользоваться справкой /help",
reply_markup=ReplyKeyboardRemove())
return
if text.lower() == 'на рефакторинг!':
message.reply_text('Тогда срочно сюда @deeprefactoring!')
return
match = re.search('https://maps\.google\.com/maps\?.*&ll=(?P<lat>[-?\d.]*),(?P<lon>[-?\d.]*)', text)
if match:
(lat, lon) = (match.group('lat'), match.group('lon'))
self.show_arrival(update, float(lat), float(lon))
else:
user_loc = self.user_settings.get(user.id, {}).get('user_loc', None)
self.logger.info(f"User: {user} '{text}' {user_loc}")
response = self.cds.bus_request(parse_routes(text), user_loc=user_loc)
self.logger.debug(f'"{text}" User: {user}; Response: {response[:5]} from {len(response)}')
reply_text = response[0]
if len(reply_text) > 4000:
message.reply_text("Слишком длинный запрос, показаны первые 4000 символов:\n" +
response[0][:4000],
reply_markup=ReplyKeyboardRemove())
else:
message.reply_text(reply_text, reply_markup=ReplyKeyboardRemove())
def test_speed_businfo(self):
query = 'про'
search_request = parse_routes(query)
start = datetime.datetime.now()
result = self.cds.bus_request(search_request, short_format=True)
finish = datetime.datetime.now()
logger.info(f"{finish - start}")
def test_speed_businfo(self):
query = 'про 1КВ 1КС 3 3В 5 5А 6 6М 8 9КА 9КС 10А 11 13 14В 15 15А 16В 17 18 23К 25А 26А 27 33К Тр.7 Тр.8 Тр.11 Тр.17'
search_request = parse_routes(query)
start = datetime.datetime.now()
result = self.cds.bus_request(search_request, short_format=True)
logger.info("PING")
finish = datetime.datetime.now()
logger.info(f"{finish - start}")
def get_arrival_by_name(self, query, station_query):
result_tuple = self.cds.next_bus(station_query, parse_routes(query))
response = {
'text': result_tuple[0],
'header': result_tuple[1],
'bus_stops': result_tuple[2]
}
return response
def next_bus_for_bus_stop(self, update, bus_stop, params):
user = update.message.from_user
search_params = parse_routes(params)
self.track(TgEvent.NEXT, update, bus_stop, params)
response = self.cds.next_bus_for_matches((bus_stop, ), search_params)
update.message.reply_text(self.get_text_from_arrival_info(response), parse_mode='Markdown')
def get_arrival_by_id(self, query, busstop_id):
bus_stop = self.cds.get_bus_stop_from_id(busstop_id)
if bus_stop:
search_params = parse_routes(query)
arrival_info = self.cds.next_bus_for_matches((bus_stop,), search_params)
result_text = self.get_text_from_arrival_info(arrival_info)
response = {'result': result_text, 'server_time': datetime.datetime.now(),
'arrival_info': unpack_namedtuples(arrival_info)}
return response
def get_arrival(self, query, lat, lon):
matches = self.cds.matches_bus_stops(lat, lon)
self.logger.info(f'{lat};{lon} {";".join([str(i) for i in matches])}')
result_tuple = self.cds.next_bus_for_matches(tuple(matches), parse_routes(query))
response = {'lat': lat, 'lon': lon,
'text': result_tuple[0], 'header': result_tuple[1],
'server_time': datetime.datetime.now(),
'bus_stops': {v.bus_stop_name: v.text for v in result_tuple.arrival_details}}
return response
def last_buses(self, _, update, args):
"""Send a message when the command /last is issued."""
self.ping_prod()
user = update.message.from_user
self.logger.info(f"last_buses. User: {user}; {args}")
user_loc = self.user_settings.get(user.id, {}).get('user_loc', None)
response = self.cds.bus_request(parse_routes(args), user_loc=user_loc)
text = response[0]
self.logger.info(f"last_buses. User: {user}; Response {text}")
update.message.reply_text(text)
def _response(self):
query = self.get_argument('q')
station_query = self.get_argument('station')
new_version = self.get_argument('old', '') != 'true'
result = self.cds.next_bus(station_query, parse_routes(query), new_version)
response = {'text': result}
self.write(json.dumps(response))
self.caching()
def bus_info_response(self, query, lat, lon):
self.logger.info(f'Bus info query: "{query}"')
user_loc = None
if lat and lon:
user_loc = UserLoc(float(lat), float(lon))
result = self.cds.bus_request(parse_routes(query), user_loc=user_loc, short_format=True)
response = {'q': query, 'text': result[0],
'buses': [(x[0]._asdict(), x[1]._asdict() if x[1] else {}) for x in result[1]]}
self.write(json.dumps(response, cls=DateTimeEncoder))
self.caching()
def last_buses(self, _, update, args):
"""Send a message when the command /last is issued."""
self.ping_prod()
user = update.message.from_user
self.track(TgEvent.LAST, update, args)
user_loc = self.user_settings.get(user.id, {}).get('user_loc', None)
response = self.cds.bus_request(parse_routes(args), user_loc=user_loc)
text = response[0]
self.track(TgEvent.LAST, update, args)
self.logger.debug(f"last_buses. User: {user}; Response {' '.join(text.split())}")
update.message.reply_text(text)
def arrival_response(self):
(lat, lon) = (float(self.get_argument(x)) for x in ('lat', 'lon'))
query = self.get_argument('q')
new_version = self.get_argument('old', '') != 'true'
matches = self.cds.matches_bus_stops(lat, lon)
self.logger.info(f'{lat};{lon} {";".join([str(i) for i in matches])}')
func = self.cds.next_bus_for_matches_alt if new_version else self.cds.next_bus_for_matches
result = func(tuple(matches), parse_routes(query))
response = {'lat': lat, 'lon': lon, 'text': result[0], 'routes': result[1]}
self.write(json.dumps(response))
self.caching()
def get_arrival_by_name(self, query, station_query):
result_tuple = self.cds.next_bus(station_query, parse_routes(query))
if result_tuple.found:
response = {'text': result_tuple[0], 'header': result_tuple[1],
'server_time': datetime.datetime.now(),
'bus_stops': {v.bus_stop_name: v.text for v in
result_tuple.arrival_details}}
else:
response = {'text': result_tuple[0], 'header': result_tuple[1],
'server_time': datetime.datetime.now(),
'bus_stops': {k: '' for k in
result_tuple.bus_stops}}
return response
def get_arrival(self, query, lat, lon):
matches = self.cds.matches_bus_stops(lat, lon)
self.logger.info(f'{lat};{lon} {";".join([str(i) for i in matches])}')
result = self.cds.next_bus_for_matches(tuple(matches),
parse_routes(query))
response = {
'lat': lat,
'lon': lon,
'text': result[0],
'header': result[1],
'bus_stops': result[2]
}
return response
def user_input(self, bot, update):
message = update.message
user = message.from_user
text = message.text
l_text = text.lower()
self.track(TgEvent.USER_INPUT, update, text[:30])
if not text or text == 'Отмена':
message.reply_text(
text=f"Попробуйте воспользоваться справкой /help",
reply_markup=ReplyKeyboardRemove())
return
if l_text == 'на рефакторинг!':
message.reply_text('Тогда срочно сюда @deeprefactoring!')
return
if self.cds.is_bus_stop_name(text):
self.next_bus_general(update, text.split(' '))
return
if l_text.startswith("ост") or l_text.startswith("аст"):
args = text.lower().split(' ')[1:]
self.next_bus_general(update, args)
return
match = re.search(
'https://maps\.google\.com/maps\?.*&ll=(?P<lat>[-?\d.]*),(?P<lon>[-?\d.]*)',
text)
if match:
(lat, lon) = (match.group('lat'), match.group('lon'))
self.show_arrival(update, float(lat), float(lon))
else:
user_loc = self.user_settings.get(user.id,
{}).get('user_loc', None)
self.logger.info(f"User: {user} '{text}' {user_loc}")
route_params = parse_routes(text)
if route_params.all_buses:
update.message.reply_text('Укажите маршруты для вывода')
return
response = self.cds.bus_request(route_params, user_loc=user_loc)
self.logger.debug(
f'"{text}" User: {user}; Response: {response[:5]} from {len(response)}'
)
reply_text = response[0]
for part in textwrap.wrap(reply_text,
4000,
replace_whitespace=False):
update.message.reply_text(part,
reply_markup=ReplyKeyboardRemove())
def get_bus_info(self, query, lat, lon, full_info, hide_text=True):
user_loc = None
if lat and lon:
user_loc = UserLoc(float(lat), float(lon))
routes_info = parse_routes(query)
is_fraud = not full_info and len(routes_info.bus_routes) > 25
result = self.cds.bus_request(routes_info, user_loc=user_loc, short_format=True)
return {'q': query,
'server_time': datetime.datetime.now(),
'text': '' if hide_text else result[0],
'buses': [(eliminate_numbers(x[0]._asdict(), full_info, is_fraud),
x[1]._asdict() if x[1] and not is_fraud else {}) for x
in result[1]]}
def get_bus_info(self, query, lat, lon):
user_loc = None
if lat and lon:
user_loc = UserLoc(float(lat), float(lon))
result = self.cds.bus_request(parse_routes(query),
user_loc=user_loc,
short_format=True)
return {
'q':
query,
'text':
result[0],
'buses': [(x[0]._asdict(), x[1]._asdict() if x[1] else {})
for x in result[1]]
}
def last_buses(self, _, update, args):
"""Send a message when the command /last is issued."""
user = update.message.from_user
self.track(TgEvent.LAST, update, args)
user_loc = self.user_settings.get(user.id, {}).get('user_loc', None)
route_params = parse_routes(args)
if route_params.all_buses:
update.message.reply_text('Укажите маршруты для вывода')
return
response = self.cds.bus_request(route_params, user_loc=user_loc)
text = response[0]
self.track(TgEvent.LAST, update, args)
self.logger.debug(
f"last_buses. User: {user}; Response {' '.join(text.split())}")
self.send_text(text, update)
def get_email_complain(self, query):
routes_info = parse_routes(" pro \ " + query, )
result = self.cds.bus_request(routes_info)
buses = result[1]
self.logger.info(f"{query} {result=}")
if not buses:
return None
bus:CdsRouteBus = buses[0][0]
self.logger.info(f"{bus=}")
subject = f'Жалоба на автобус маршрута {bus.route_name_} бортовой номер {bus.bort_name} {datetime.date.today()} '
br = '%0D%0A'
body = f"""Жалоба на автобус маршрута {bus.route_name_} бортовой номер {bus.bort_name}, госномер {bus.name_}
Дата и время обращения: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}
Примерное время и место (уточните, если значительно отличается): {bus.last_station_time_:%Y-%m-%d %H:%M}, {bus.bus_station_}
Жалоба: опишите свою жалобу/пожелание/благодарность, при необходимости прикрепите фото/видео, ссылки и т.д.
""".replace("\n", br)
email_complains = f'mailto:{COMPLAINS_EMAIL}?subject={subject}&body={body}'
return email_complains
