436 lines
17 KiB
Python
436 lines
17 KiB
Python
# import logging
|
||
# import requests
|
||
# from datetime import datetime, timedelta
|
||
# from asgiref.sync import sync_to_async
|
||
# from pms_integration.models import PMSConfiguration
|
||
# from hotels.models import Hotel, Reservation
|
||
# from .base_plugin import BasePMSPlugin
|
||
|
||
|
||
# class ShelterPMSPlugin(BasePMSPlugin):
|
||
# """
|
||
# Плагин для интеграции с PMS Shelter.
|
||
# """
|
||
|
||
# def __init__(self, pms_config):
|
||
# super().__init__(pms_config)
|
||
|
||
# # Настройка логирования
|
||
# self.logger = logging.getLogger(self.__class__.__name__)
|
||
# handler = logging.StreamHandler()
|
||
# formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
|
||
# handler.setFormatter(formatter)
|
||
# self.logger.addHandler(handler)
|
||
# self.logger.setLevel(logging.DEBUG)
|
||
|
||
# # Инициализация параметров API
|
||
# self.api_url = pms_config.url
|
||
# self.token = pms_config.token
|
||
# self.username = pms_config.username
|
||
# self.password = pms_config.password
|
||
|
||
# def get_default_parser_settings(self):
|
||
# """
|
||
# Возвращает настройки парсера по умолчанию.
|
||
# """
|
||
# return {
|
||
# "field_mapping": {
|
||
# "check_in": "checkin",
|
||
# "check_out": "checkout",
|
||
# "room_number": "room_number",
|
||
# "room_type": "room_type",
|
||
# "status": "status",
|
||
# },
|
||
# "date_format": "%Y-%m-%dT%H:%M:%S"
|
||
# }
|
||
|
||
# async def _fetch_data(self):
|
||
# """
|
||
# Получает данные из Shelter PMS API и сохраняет их в базу данных.
|
||
# """
|
||
# now = datetime.now()
|
||
# start_date = (now - timedelta(days=1)).strftime('%Y-%m-%d')
|
||
# end_date = now.strftime('%Y-%m-%d')
|
||
|
||
# headers = {
|
||
# "Authorization": f"Bearer {self.token}",
|
||
# "Content-Type": "application/json",
|
||
# }
|
||
# params = {
|
||
# "start_date": start_date,
|
||
# "end_date": end_date,
|
||
# }
|
||
|
||
# try:
|
||
# response = await sync_to_async(requests.get)(f"{self.api_url}/reservations", headers=headers, params=params)
|
||
# response.raise_for_status()
|
||
# data = response.json()
|
||
# self.logger.debug(f"Получены данные с API: {data}")
|
||
# except requests.exceptions.RequestException as e:
|
||
# self.logger.error(f"Ошибка запроса к API Shelter: {e}")
|
||
# return []
|
||
|
||
# # Обработка и сохранение данных
|
||
# processed_data = []
|
||
# for item in data.get("reservations", []):
|
||
# processed_item = {
|
||
# "room_number": item.get("room_number"),
|
||
# "check_in": datetime.strptime(item.get("check_in"), '%Y-%m-%dT%H:%M:%S'),
|
||
# "check_out": datetime.strptime(item.get("check_out"), '%Y-%m-%dT%H:%M:%S'),
|
||
# "status": item.get("status"),
|
||
# "room_type": item.get("room_type"),
|
||
# }
|
||
# processed_data.append(processed_item)
|
||
# await self._save_to_db(processed_item)
|
||
|
||
# self.logger.debug("Все данные успешно сохранены в базу данных.")
|
||
# return processed_data
|
||
|
||
# async def _save_to_db(self, item):
|
||
# """
|
||
# Сохраняет данные в базу данных.
|
||
# """
|
||
# try:
|
||
# hotel = await sync_to_async(Hotel.objects.get)(pms=self.pms_config)
|
||
|
||
# reservation, created = await sync_to_async(Reservation.objects.update_or_create)(
|
||
# room_number=item["room_number"],
|
||
# check_in=item["check_in"],
|
||
# defaults={
|
||
# "check_out": item["check_out"],
|
||
# "status": item["status"],
|
||
# "hotel": hotel,
|
||
# "room_type": item["room_type"],
|
||
# },
|
||
# )
|
||
|
||
# if created:
|
||
# self.logger.debug(f"Создана новая запись бронирования: {reservation}")
|
||
# else:
|
||
# self.logger.debug(f"Обновлено существующее бронирование: {reservation}")
|
||
|
||
# except Exception as e:
|
||
# self.logger.error(f"Ошибка при сохранении данных в БД: {e}")
|
||
|
||
# async def fetch_and_process_data(self):
|
||
# """
|
||
# Загружает данные с API Shelter и сохраняет их в базу данных.
|
||
# """
|
||
# self.logger.info("Начало процесса загрузки данных из Shelter PMS.")
|
||
# try:
|
||
# data = await self._fetch_data()
|
||
# self.logger.info(f"Загрузка и обработка данных завершены. Обработано записей: {len(data)}")
|
||
# return data
|
||
# except Exception as e:
|
||
# self.logger.error(f"Ошибка в процессе загрузки данных: {e}")
|
||
# raise
|
||
|
||
import logging
|
||
import requests
|
||
import json
|
||
import os
|
||
from datetime import datetime, timedelta
|
||
from asgiref.sync import sync_to_async
|
||
from hotels.models import Hotel, Reservation
|
||
from .base_plugin import BasePMSPlugin
|
||
<<<<<<< HEAD
|
||
|
||
class ShelterPMSPlugin(BasePMSPlugin):
|
||
"""
|
||
Плагин для интеграции с PMS Shelter (интерфейс для получения данных об отеле).
|
||
"""
|
||
|
||
def __init__(self, pms_config):
|
||
super().__init__(pms_config)
|
||
self.logger = logging.getLogger(self.__class__.__name__)
|
||
handler = logging.StreamHandler()
|
||
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
|
||
handler.setFormatter(formatter)
|
||
self.logger.addHandler(handler)
|
||
self.logger.setLevel(logging.DEBUG)
|
||
|
||
self.api_url = "https://pms.frontdesk24.ru/sheltercloudapi/Reservations/"
|
||
self.access_token = "679CA9C5-9847-4151-883E-5F61181AA37E"
|
||
=======
|
||
from touchh.utils.log import CustomLogger
|
||
class ShelterPMSPlugin(BasePMSPlugin):
|
||
"""
|
||
Плагин для интеграции с PMS Shelter.
|
||
"""
|
||
|
||
def __init__(self, hotel):
|
||
super().__init__(hotel.pms) # Передаем PMS-конфигурацию в базовый класс
|
||
self.hotel = hotel # Сохраняем объект отеля
|
||
|
||
# Проверка PMS-конфигурации
|
||
if not self.hotel.pms:
|
||
raise ValueError(f"Отель {self.hotel.name} не имеет связанной PMS конфигурации.")
|
||
|
||
# Инициализация параметров API
|
||
self.api_url = self.hotel.pms.url
|
||
self.token = self.hotel.pms.token
|
||
|
||
# Настройка логгера
|
||
self.logger = CustomLogger(name="ShelterPMSPlugin", log_level="WARNING").get_logger()
|
||
handler_console = logging.StreamHandler()
|
||
handler_file = logging.FileHandler('var/log/shelter_pms_plugin.log')
|
||
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
|
||
handler_console.setFormatter(formatter)
|
||
handler_file.setFormatter(formatter)
|
||
self.logger.addHandler(handler_console)
|
||
self.logger.addHandler(handler_file)
|
||
self.logger.setLevel(logging.WARNING)
|
||
>>>>>>> PMSManager_refactor
|
||
|
||
def get_default_parser_settings(self):
|
||
"""
|
||
Возвращает настройки по умолчанию для обработки данных.
|
||
"""
|
||
return {
|
||
"field_mapping": {
|
||
<<<<<<< HEAD
|
||
"check_in": "check_in",
|
||
"check_out": "check_out",
|
||
"room_number": "room_number",
|
||
"status": "status",
|
||
=======
|
||
"check_in": "from",
|
||
"check_out": "until",
|
||
"room_number": "roomNumber",
|
||
"room_type_name": "roomTypeName",
|
||
"status": "checkInStatus",
|
||
>>>>>>> PMSManager_refactor
|
||
},
|
||
"date_format": "%Y-%m-%dT%H:%M:%S",
|
||
}
|
||
|
||
async def _fetch_data(self):
|
||
"""
|
||
<<<<<<< HEAD
|
||
Получает данные бронирований с API PMS Shelter.
|
||
"""
|
||
try:
|
||
# Формируем параметры запроса
|
||
now = datetime.now()
|
||
create_from = (now - timedelta(days=7)).strftime("%Y-%m-%d")
|
||
create_to = now.strftime("%Y-%m-%d")
|
||
|
||
data = {
|
||
"from": create_from,
|
||
"until": create_to,
|
||
"pagination": {
|
||
"from": 0,
|
||
"count": 100
|
||
}
|
||
}
|
||
|
||
headers = {
|
||
"Content-Type": "application/json",
|
||
"Accept": "text/plain",
|
||
"Authorization": f"Bearer {self.access_token}"
|
||
}
|
||
|
||
# Логирование запроса
|
||
self.logger.debug(f"Отправка запроса к API: {self.api_url}")
|
||
self.logger.debug(f"Тело запроса: {data}")
|
||
self.logger.debug(f"Заголовки: {headers}")
|
||
|
||
# Выполняем запрос
|
||
response = requests.post(self.api_url, json=data, headers=headers)
|
||
response.raise_for_status()
|
||
=======
|
||
Получает данные из PMS API и сохраняет их в базу.
|
||
"""
|
||
now = datetime.now()
|
||
start_date = (now - timedelta(days=60)).strftime('%Y-%m-%dT%H:%M:%SZ')
|
||
end_date = (now + timedelta(days=60)).strftime('%Y-%m-%dT%H:%M:%SZ')
|
||
|
||
headers = {
|
||
"Content-Type": "application/json",
|
||
"Accept": "text/plain",
|
||
"Authorization": f"Bearer {self.token}"
|
||
}
|
||
|
||
from_index = 0
|
||
count_per_request = 50
|
||
all_items = []
|
||
|
||
try:
|
||
while True:
|
||
data = {
|
||
"from": start_date,
|
||
"until": end_date,
|
||
"pagination": {
|
||
"from": from_index,
|
||
"count": count_per_request
|
||
}
|
||
}
|
||
|
||
response = await sync_to_async(requests.post)(self.api_url, headers=headers, data=json.dumps(data))
|
||
response.raise_for_status()
|
||
response_data = response.json()
|
||
|
||
items = response_data.get("items", [])
|
||
all_items.extend(items)
|
||
|
||
total_count = response_data.get("count", 0)
|
||
from_index += len(items)
|
||
|
||
if from_index >= total_count:
|
||
break
|
||
|
||
self.logger.info(f"Получено записей: {len(all_items)}")
|
||
|
||
# Сохранение данных во временный файл
|
||
temp_dir = os.path.join("temp", "shelter")
|
||
os.makedirs(temp_dir, exist_ok=True)
|
||
temp_file = os.path.join(temp_dir, f"shelter_data_{datetime.now().strftime('%Y%m%d%H%M%S')}.json")
|
||
|
||
with open(temp_file, 'w') as file:
|
||
json.dump(all_items, file)
|
||
|
||
self.logger.info(f"Данные сохранены во временный файл: {temp_file}")
|
||
|
||
return await self._process_data(all_items)
|
||
|
||
except requests.exceptions.RequestException as e:
|
||
self.logger.error(f"Ошибка API: {e}")
|
||
return {
|
||
"processed_intervals": 0,
|
||
"processed_items": 0,
|
||
"errors": [str(e)]
|
||
}
|
||
|
||
async def _process_data(self, data):
|
||
"""
|
||
Обрабатывает данные и сохраняет их в базу.
|
||
"""
|
||
processed_items = 0
|
||
errors = []
|
||
|
||
date_formats = ["%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S"] # Поддержка нескольких форматов даты
|
||
|
||
for item in data:
|
||
try:
|
||
# Парсинг даты с поддержкой нескольких форматов
|
||
checkin = self._parse_date(item['from'], date_formats)
|
||
checkout = self._parse_date(item['until'], date_formats)
|
||
|
||
reservation, created = await sync_to_async(Reservation.objects.update_or_create)(
|
||
reservation_id=item['id'],
|
||
defaults={
|
||
'room_number': item.get('roomNumber'),
|
||
'room_type': item.get('roomTypeName'),
|
||
'check_in': checkin,
|
||
'check_out': checkout,
|
||
'status': item.get('checkInStatus'),
|
||
'hotel': self.hotel,
|
||
}
|
||
)
|
||
|
||
if created:
|
||
self.logger.debug(f"Создана новая резервация: {reservation.reservation_id}")
|
||
else:
|
||
self.logger.debug(f"Обновлена существующая резервация: {reservation.reservation_id}")
|
||
|
||
processed_items += 1
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка обработки записи: {e}")
|
||
errors.append(str(e))
|
||
|
||
return {
|
||
"processed_intervals": 1,
|
||
"processed_items": processed_items,
|
||
"errors": errors
|
||
}
|
||
|
||
@staticmethod
|
||
def _parse_date(date_str, formats):
|
||
"""
|
||
Парсит дату, пытаясь использовать несколько форматов.
|
||
"""
|
||
for fmt in formats:
|
||
try:
|
||
return datetime.strptime(date_str, fmt)
|
||
except ValueError:
|
||
continue
|
||
raise ValueError(f"Дата '{date_str}' не соответствует ожидаемым форматам: {formats}")
|
||
|
||
def validate_plugin(self):
|
||
"""
|
||
Проверка корректности реализации плагина.
|
||
"""
|
||
required_methods = ["fetch_data", "get_default_parser_settings", "_fetch_data"]
|
||
for method in required_methods:
|
||
if not hasattr(self, method):
|
||
raise ValueError(f"Плагин {type(self).__name__} не реализует метод {method}.")
|
||
self.logger.debug(f"Плагин {self.__class__.__name__} прошел валидацию.")
|
||
return True
|
||
>>>>>>> PMSManager_refactor
|
||
|
||
# Обрабатываем ответ
|
||
bookings = response.json()
|
||
self.logger.info(f"Получено бронирований: {len(bookings)}")
|
||
return bookings
|
||
|
||
except requests.HTTPError as http_err:
|
||
self.logger.error(f"HTTP ошибка: {http_err}")
|
||
self.logger.error(f"Текст ответа: {response.text if 'response' in locals() else 'Нет данных'}")
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка получения данных PMS Shelter: {e}")
|
||
raise
|
||
|
||
async def fetch_and_process_data(self):
|
||
"""
|
||
Получение данных с API, обработка и сохранение в базу.
|
||
"""
|
||
self.logger.info("Начало загрузки данных с API Shelter")
|
||
try:
|
||
bookings = await self._fetch_data()
|
||
report = await self._process_and_save_bookings(bookings)
|
||
self.logger.info(f"Данные успешно обработаны. Отчет: {report}")
|
||
return report
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка загрузки и обработки данных: {e}")
|
||
raise
|
||
|
||
async def _process_and_save_bookings(self, bookings):
|
||
"""
|
||
Обрабатывает и сохраняет бронирования в базу данных.
|
||
"""
|
||
self.logger.info("Начало обработки данных о бронированиях для сохранения в базу.")
|
||
processed_items = 0
|
||
errors = []
|
||
|
||
for record in bookings:
|
||
try:
|
||
# Пример обработки данных бронирования
|
||
booking_id = record.get("id")
|
||
room_number = record.get("room_number")
|
||
check_in = record.get("check_in")
|
||
check_out = record.get("check_out")
|
||
status = record.get("status")
|
||
|
||
# Сохраняем или обновляем запись в базе данных
|
||
reservation, created = await sync_to_async(Reservation.objects.update_or_create)(
|
||
external_id=booking_id,
|
||
defaults={
|
||
"hotel": self.pms_config.hotel,
|
||
"room_number": room_number,
|
||
"check_in": check_in,
|
||
"check_out": check_out,
|
||
"status": status,
|
||
},
|
||
)
|
||
|
||
processed_items += 1
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка обработки бронирования {record.get('id')}: {e}")
|
||
errors.append(str(e))
|
||
|
||
self.logger.info(f"Обработано бронирований: {processed_items}, ошибок: {len(errors)}")
|
||
return {"processed_items": processed_items, "errors": errors}
|