432 lines
19 KiB
Python
432 lines
19 KiB
Python
# routes.py
|
||
import os
|
||
import json
|
||
import shutil
|
||
from flask import (
|
||
Blueprint, render_template, request, redirect, url_for, flash, g, session, current_app
|
||
)
|
||
from flask_login import login_user, login_required, logout_user, current_user
|
||
from flask_babel import _
|
||
from werkzeug.utils import secure_filename
|
||
import gspread
|
||
|
||
# --- ИМПОРТ РАСШИРЕНИЙ И МОДЕЛЕЙ ---
|
||
# Импортируем экземпляры расширений, созданные в app.py
|
||
from extensions import db, login_manager
|
||
# Импортируем наши классы и утилиты
|
||
from models import User, UserConfig
|
||
from google_sheets import GoogleSheets
|
||
from request_module import ReqModule
|
||
from utils import get_dates, generate_template_from_preset, render_temp
|
||
|
||
|
||
# --- Создание блюпринта ---
|
||
main_bp = Blueprint('main', __name__)
|
||
|
||
|
||
# --- Регистрация обработчиков для расширений ---
|
||
|
||
@login_manager.user_loader
|
||
def load_user(user_id):
|
||
"""Загружает пользователя из БД для управления сессией."""
|
||
return db.session.get(User, int(user_id))
|
||
|
||
|
||
@main_bp.before_app_request
|
||
def load_user_specific_data():
|
||
"""Загружает конфигурацию пользователя в глобальный объект `g` для текущего запроса."""
|
||
g.user_config = None
|
||
if current_user.is_authenticated:
|
||
g.user_config = get_user_config()
|
||
|
||
|
||
# --- Вспомогательные функции, специфичные для маршрутов ---
|
||
|
||
def get_user_config():
|
||
"""Получает конфиг для текущего пользователя, создавая его при необходимости."""
|
||
if not current_user.is_authenticated:
|
||
return None
|
||
config = UserConfig.query.filter_by(user_id=current_user.id).first()
|
||
if not config:
|
||
config = UserConfig(user_id=current_user.id)
|
||
db.session.add(config)
|
||
return config
|
||
|
||
def get_user_upload_path(filename=""):
|
||
"""Возвращает путь для загрузки файлов для текущего пользователя."""
|
||
if not current_user.is_authenticated:
|
||
return None
|
||
user_dir = os.path.join(current_app.config['DATA_DIR'], str(current_user.id))
|
||
os.makedirs(user_dir, exist_ok=True)
|
||
return os.path.join(user_dir, secure_filename(filename))
|
||
|
||
|
||
# --- Маршруты ---
|
||
|
||
@main_bp.route('/language/<language>')
|
||
def set_language(language=None):
|
||
session['language'] = language
|
||
return redirect(request.referrer or url_for('.index'))
|
||
|
||
@main_bp.route('/login', methods=['GET', 'POST'])
|
||
def login():
|
||
if current_user.is_authenticated:
|
||
return redirect(url_for('.index'))
|
||
if request.method == 'POST':
|
||
username = request.form.get('username')
|
||
password = request.form.get('password')
|
||
user = User.query.filter_by(username=username).first()
|
||
if user is None or not user.check_password(password):
|
||
flash(_('Invalid username or password'), 'error')
|
||
return redirect(url_for('.login'))
|
||
login_user(user, remember=request.form.get('remember'))
|
||
flash(_('Login successful!'), 'success')
|
||
next_page = request.args.get('next')
|
||
return redirect(next_page or url_for('.index'))
|
||
return render_template('login.html')
|
||
|
||
@main_bp.route('/register', methods=['GET', 'POST'])
|
||
def register():
|
||
if current_user.is_authenticated:
|
||
return redirect(url_for('.index'))
|
||
if request.method == 'POST':
|
||
username = request.form.get('username')
|
||
password = request.form.get('password')
|
||
if not username or not password:
|
||
flash(_('Username and password are required.'), 'error')
|
||
return redirect(url_for('.register'))
|
||
if User.query.filter_by(username=username).first():
|
||
flash(_('Username already exists.'), 'error')
|
||
return redirect(url_for('.register'))
|
||
|
||
user = User(username=username)
|
||
user.set_password(password)
|
||
user.config = UserConfig()
|
||
db.session.add(user)
|
||
try:
|
||
db.session.commit()
|
||
flash(_('Registration successful! Please log in.'), 'success')
|
||
return redirect(url_for('.login'))
|
||
except Exception as e:
|
||
db.session.rollback()
|
||
flash(_('An error occurred during registration. Please try again.'), 'error')
|
||
return redirect(url_for('.register'))
|
||
|
||
return render_template('register.html')
|
||
|
||
@main_bp.route('/logout')
|
||
@login_required
|
||
def logout():
|
||
logout_user()
|
||
flash(_('You have been logged out.'), 'success')
|
||
return redirect(url_for('.index'))
|
||
|
||
@main_bp.route('/')
|
||
@login_required
|
||
def index():
|
||
config = g.user_config
|
||
return render_template(
|
||
'index.html',
|
||
rms_config=config.get_rms_dict(),
|
||
google_config=config.get_google_dict(),
|
||
presets=config.presets,
|
||
sheets=config.sheets,
|
||
mappings=config.mappings,
|
||
client_email=config.google_client_email
|
||
)
|
||
|
||
@main_bp.route('/configure_rms', methods=['POST'])
|
||
@login_required
|
||
def configure_rms():
|
||
config = g.user_config
|
||
try:
|
||
host = request.form.get('host', '').strip()
|
||
login = request.form.get('login', '').strip()
|
||
password = request.form.get('password', '')
|
||
|
||
if not config.rms_password and not password:
|
||
flash(_('Password is required for the first time.'), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
if not host or not login:
|
||
flash(_('Host and Login fields must be filled.'), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
effective_password = password if password else config.rms_password
|
||
|
||
req_module = ReqModule(host, login, effective_password)
|
||
if req_module.login():
|
||
presets_data = req_module.take_presets()
|
||
req_module.logout()
|
||
|
||
config.rms_host = host
|
||
config.rms_login = login
|
||
if password:
|
||
config.rms_password = password
|
||
config.presets = presets_data
|
||
|
||
db.session.commit()
|
||
flash(_('Successfully authorized on RMS server. Received %(num)s presets.', num=len(presets_data)), 'success')
|
||
else:
|
||
flash(_('Authorization error on RMS server. Check host, login or password.'), 'error')
|
||
|
||
except Exception as e:
|
||
db.session.rollback()
|
||
flash(_('Error configuring RMS: %(error)s', error=str(e)), 'error')
|
||
|
||
return redirect(url_for('.index'))
|
||
|
||
@main_bp.route('/upload_credentials', methods=['POST'])
|
||
@login_required
|
||
def upload_credentials():
|
||
config = g.user_config
|
||
if 'cred_file' not in request.files or request.files['cred_file'].filename == '':
|
||
flash(_('No file was selected.'), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
cred_file = request.files['cred_file']
|
||
filename = cred_file.filename
|
||
# Получаем путь для сохранения файла в папке пользователя
|
||
user_cred_path = get_user_upload_path(filename)
|
||
temp_path = None
|
||
|
||
try:
|
||
# Сначала сохраняем файл во временную директорию для проверки
|
||
temp_dir = os.path.join(current_app.config['DATA_DIR'], "temp")
|
||
os.makedirs(temp_dir, exist_ok=True)
|
||
temp_path = os.path.join(temp_dir, f"temp_{current_user.id}_{filename}")
|
||
cred_file.save(temp_path)
|
||
|
||
with open(temp_path, 'r', encoding='utf-8') as f:
|
||
cred_data = json.load(f)
|
||
client_email = cred_data.get('client_email')
|
||
|
||
if not client_email:
|
||
flash(_('Could not find client_email in the credentials file.'), 'error')
|
||
# Не забываем удалить временный файл при ошибке
|
||
if os.path.exists(temp_path):
|
||
os.remove(temp_path)
|
||
return redirect(url_for('.index'))
|
||
|
||
# Если все хорошо, перемещаем файл из временной папки в постоянную
|
||
shutil.move(temp_path, user_cred_path)
|
||
|
||
# Сохраняем путь к файлу и email в базу данных
|
||
config.google_cred_file_path = user_cred_path
|
||
config.google_client_email = client_email
|
||
config.sheets = [] # Сбрасываем список листов при смене credentials
|
||
|
||
db.session.commit()
|
||
flash(_('Credentials file successfully uploaded. Email: %(email)s', email=client_email), 'success')
|
||
|
||
except json.JSONDecodeError:
|
||
flash(_('Error: Uploaded file is not a valid JSON.'), 'error')
|
||
except Exception as e:
|
||
db.session.rollback()
|
||
flash(_('Error processing credentials: %(error)s', error=str(e)), 'error')
|
||
finally:
|
||
# Гарантированно удаляем временный файл, если он еще существует
|
||
if temp_path and os.path.exists(temp_path):
|
||
os.remove(temp_path)
|
||
|
||
return redirect(url_for('.index'))
|
||
|
||
@main_bp.route('/configure_google', methods=['POST'])
|
||
@login_required
|
||
def configure_google():
|
||
config = g.user_config
|
||
sheet_url = request.form.get('sheet_url', '').strip()
|
||
|
||
if not sheet_url:
|
||
flash(_('Sheet URL must be provided.'), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
config.google_sheet_url = sheet_url
|
||
|
||
cred_path = config.google_cred_file_path
|
||
if not cred_path or not os.path.isfile(cred_path):
|
||
flash(_('Please upload a valid credentials file first.'), 'warning')
|
||
config.sheets = []
|
||
db.session.commit()
|
||
return redirect(url_for('.index'))
|
||
|
||
try:
|
||
gs_client = GoogleSheets(cred_path, sheet_url)
|
||
sheets_data = gs_client.get_sheets()
|
||
config.sheets = sheets_data
|
||
|
||
db.session.commit()
|
||
flash(_('Successfully connected to Google Sheets. Found %(num)s sheets. Settings saved.', num=len(sheets_data)), 'success')
|
||
|
||
except Exception as e:
|
||
db.session.rollback()
|
||
config.sheets = []
|
||
flash(_('Error connecting to Google Sheets: %(error)s. Check the URL and service account permissions.', error=str(e)), 'error')
|
||
try:
|
||
db.session.commit()
|
||
except Exception:
|
||
db.session.rollback()
|
||
|
||
return redirect(url_for('.index'))
|
||
|
||
@main_bp.route('/mapping_set', methods=['POST'])
|
||
@login_required
|
||
def mapping_set():
|
||
config = g.user_config
|
||
try:
|
||
new_mappings = {}
|
||
for sheet in config.sheets:
|
||
report_key = f"sheet_{sheet['id']}"
|
||
selected_report_id = request.form.get(report_key)
|
||
if selected_report_id:
|
||
new_mappings[sheet['title']] = selected_report_id
|
||
|
||
config.mappings = new_mappings
|
||
db.session.commit()
|
||
|
||
flash(_('Mappings updated successfully.'), 'success')
|
||
except Exception as e:
|
||
db.session.rollback()
|
||
flash(_('Error updating mappings: %(error)s', error=str(e)), 'error')
|
||
|
||
return redirect(url_for('.index'))
|
||
|
||
@main_bp.route('/render_olap', methods=['POST'])
|
||
@login_required
|
||
def render_olap():
|
||
config = g.user_config
|
||
sheet_title = None
|
||
req_module = None
|
||
|
||
try:
|
||
from_date, to_date = get_dates(request.form.get('start_date'), request.form.get('end_date'))
|
||
sheet_title = next((key for key in request.form if key.startswith('render_')), '').replace('render_', '')
|
||
if not sheet_title:
|
||
flash(_('Error: Could not determine which sheet to render the report for.'), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
report_id = config.mappings.get(sheet_title)
|
||
if not report_id:
|
||
flash(_('Error: No report is assigned to sheet "%(sheet)s".', sheet=sheet_title), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
if not all([config.rms_host, config.rms_login, config.rms_password, config.google_cred_file_path, config.google_sheet_url]):
|
||
flash(_('Error: RMS or Google Sheets configuration is incomplete.'), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
preset = next((p for p in config.presets if p.get('id') == report_id), None)
|
||
if not preset:
|
||
flash(_('Error: Preset with ID "%(id)s" not found in saved configuration.', id=report_id), 'error')
|
||
return redirect(url_for('.index'))
|
||
|
||
template = generate_template_from_preset(preset)
|
||
json_body = render_temp(template, {"from_date": from_date, "to_date": to_date})
|
||
|
||
req_module = ReqModule(config.rms_host, config.rms_login, config.rms_password)
|
||
gs_client = GoogleSheets(config.google_cred_file_path, config.google_sheet_url)
|
||
|
||
if req_module.login():
|
||
result = req_module.take_olap(json_body)
|
||
|
||
# --- НАЧАЛО НОВОЙ УЛУЧШЕННОЙ ЛОГИКИ ОБРАБОТКИ ДАННЫХ ---
|
||
|
||
if 'data' not in result or not isinstance(result['data'], list):
|
||
flash(_('Error: Unexpected response format from RMS for report "%(name)s".', name=preset.get('name', report_id)), 'error')
|
||
current_app.logger.error(f"Unexpected API response for report {report_id} ('{preset.get('name')}'). Response: {result}")
|
||
return redirect(url_for('.index'))
|
||
|
||
report_data = result['data']
|
||
|
||
# Если отчет пуст, очищаем лист и уведомляем пользователя.
|
||
if not report_data:
|
||
gs_client.clear_and_write_data(sheet_title, [])
|
||
flash(_('Report "%(name)s" returned no data for the selected period. Sheet "%(sheet)s" has been cleared.', name=preset.get('name', report_id), sheet=sheet_title), 'warning')
|
||
return redirect(url_for('.index'))
|
||
|
||
# Здесь будет храниться наш итоговый "плоский" список словарей
|
||
processed_data = []
|
||
|
||
# Проверяем структуру отчета: сводный (pivoted) или простой (flat)
|
||
first_item = report_data[0]
|
||
is_pivoted = isinstance(first_item, dict) and 'row' in first_item and 'cells' in first_item
|
||
|
||
if is_pivoted:
|
||
current_app.logger.info(f"Processing a pivoted report: {preset.get('name', report_id)}")
|
||
# "Разворачиваем" (unpivot) данные в плоский список словарей
|
||
for row_item in report_data:
|
||
row_values = row_item.get('row', {})
|
||
cells = row_item.get('cells', [])
|
||
if not cells:
|
||
# Обрабатываем строки, у которых может не быть данных в ячейках
|
||
processed_data.append(row_values.copy())
|
||
else:
|
||
for cell in cells:
|
||
new_flat_row = row_values.copy()
|
||
new_flat_row.update(cell.get('col', {}))
|
||
new_flat_row.update(cell.get('values', {}))
|
||
processed_data.append(new_flat_row)
|
||
else:
|
||
current_app.logger.info(f"Processing a simple flat report: {preset.get('name', report_id)}")
|
||
# Данные уже в виде плоского списка, просто присваиваем
|
||
processed_data = [item for item in report_data if isinstance(item, dict)]
|
||
|
||
# --- Универсальное формирование заголовков и данных ---
|
||
|
||
# 1. Собираем все уникальные ключи из всех строк для гарантии целостности.
|
||
all_keys = set()
|
||
for row in processed_data:
|
||
all_keys.update(row.keys())
|
||
|
||
# 2. Создаем упорядоченный список заголовков для лучшей читаемости.
|
||
# Используем поля из пресета для определения логического порядка.
|
||
row_group_fields = preset.get('groupByRowFields', [])
|
||
col_group_fields = preset.get('groupByColFields', [])
|
||
agg_fields = preset.get('aggregateFields', [])
|
||
|
||
ordered_headers = []
|
||
# Сначала добавляем известные поля из пресета в логической последовательности.
|
||
for field in row_group_fields + col_group_fields + agg_fields:
|
||
if field in all_keys:
|
||
ordered_headers.append(field)
|
||
all_keys.remove(field)
|
||
# Добавляем любые другие (неожиданные) поля, отсортировав их по алфавиту.
|
||
ordered_headers.extend(sorted(list(all_keys)))
|
||
|
||
# 3. Собираем итоговый список списков для Google Sheets, приводя все значения к строкам.
|
||
data_to_insert = [ordered_headers]
|
||
for row in processed_data:
|
||
row_data = []
|
||
for header in ordered_headers:
|
||
value_str = str(row.get(header, ''))
|
||
if value_str.startswith(('=', '+', '-', '@')):
|
||
row_data.append("'" + value_str)
|
||
else:
|
||
row_data.append(value_str)
|
||
# Преобразуем None в пустую строку, а все остальное в строковое представление.
|
||
# Это предотвращает потенциальные ошибки типов со стороны Google Sheets API.
|
||
data_to_insert.append(row_data)
|
||
|
||
|
||
gs_client.clear_and_write_data(sheet_title, data_to_insert)
|
||
|
||
rows_count = len(data_to_insert) - 1
|
||
flash(_('Report "%(name)s" data (%(rows)s rows) successfully written to sheet "%(sheet)s".',
|
||
name=preset.get('name', report_id),
|
||
rows=rows_count,
|
||
sheet=sheet_title), 'success')
|
||
else:
|
||
flash(_('Error authorizing on RMS server when trying to get a report.'), 'error')
|
||
|
||
except ValueError as ve:
|
||
flash(_('Data Error: %(error)s', error=str(ve)), 'error')
|
||
except gspread.exceptions.APIError as api_err:
|
||
flash(_('Google API Error accessing sheet "%(sheet)s". Check service account permissions.', sheet=sheet_title or _('Unknown')), 'error')
|
||
current_app.logger.error(f"Google API Error for sheet '{sheet_title}': {api_err}", exc_info=True)
|
||
except Exception as e:
|
||
flash(_('An unexpected error occurred: %(error)s', error=str(e)), 'error')
|
||
current_app.logger.error(f"Unexpected error in render_olap: {e}", exc_info=True)
|
||
finally:
|
||
if req_module and req_module.token:
|
||
req_module.logout()
|
||
|
||
return redirect(url_for('.index')) |