import os
import http.server
import socketserver
import urllib.parse
import zipfile
import io
import shutil
import json
from datetime import datetime
# --- Função auxiliar para formatar o tamanho do arquivo ---
def format_file_size(size_bytes):
"""Converte bytes em um formato legível (KB, MB, GB)."""
if size_bytes < 1024:
return f"{size_bytes} B"
elif size_bytes < 1024**2:
return f"{size_bytes/1024:.1f} KB"
elif size_bytes < 1024**3:
return f"{size_bytes/1024**2:.1f} MB"
else:
return f"{size_bytes/1024**3:.1f} GB"
# --- Sua função original para carregar JSON ---
def load_file_content(filename):
try:
folder = "oplaboptionvols"
file_path = os.path.join(folder, f"{filename}.json")
if os.path.exists(file_path):
with open(file_path, 'r', encoding='utf-8') as file: return file.read()
return None
except Exception: return None
# --- Handler do Servidor Aprimorado ---
class MyAdvancedHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
# --- MÉTODO GET: Lida com visualização, download e sua rota JSON ---
def do_GET(self):
parsed_url = urllib.parse.urlparse(self.path)
query_params = urllib.parse.parse_qs(parsed_url.query)
# 1. ROTA PARA LISTAGEM EM JSON (Para o Delphi)
if 'list' in query_params and query_params['list'][0] == 'json':
path_to_list = self.translate_path(parsed_url.path)
if os.path.isdir(path_to_list):
self.serve_json_directory_list(path_to_list)
else:
self.send_error(404, "Diretorio nao encontrado")
return
# 2. Sua rota original de JSON por nome de arquivo
if 'filename' in query_params:
self.handle_json_request(query_params['filename'][0])
return
# 3. Sua rota original de Download ZIP
if 'download' in query_params and query_params['download'][0] == 'zip':
path_to_zip = self.translate_path(parsed_url.path)
if os.path.isdir(path_to_zip):
self.serve_directory_as_zip(path_to_zip)
else:
self.send_error(404, "Diretório não encontrado")
return
super().do_GET()
# --- NOVO MÉTODO PARA O DELPHI ---
def serve_json_directory_list(self, path):
"""Retorna uma lista JSON com caminhos limpos."""
try:
# CORREÇÃO: Pegamos apenas a parte do diretório, sem os "?list=json"
parsed_url = urllib.parse.urlparse(self.path)
clean_base_path = parsed_url.path
raw_list = os.listdir(path)
items = []
for name in raw_list:
fullname = os.path.join(path, name)
is_dir = os.path.isdir(fullname)
# Montamos o path relativo de forma limpa
# Ex: /oplaboptions/2026_02_03__11_00
relative_path = clean_base_path.rstrip('/') + '/' + name
info = {
"name": name,
"is_dir": is_dir,
"path": relative_path,
"size_bytes": os.path.getsize(fullname) if not is_dir else 0,
"mtime": datetime.fromtimestamp(os.path.getmtime(fullname)).isoformat()
}
items.append(info)
items.sort(key=lambda x: (not x['is_dir'], x['name'].lower()))
response_json = json.dumps(items, indent=4).encode('utf-8')
self.send_response(200)
self.send_header("Content-type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(response_json)))
self.end_headers()
self.wfile.write(response_json)
except Exception as e:
self.send_error(500, f"Erro ao listar: {e}")
# --- MÉTODO POST: Lida com ações, como deletar ---
def do_POST(self):
try:
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
params = urllib.parse.parse_qs(post_data.decode('utf-8'))
if params.get('action', [None])[0] == 'delete':
path_to_delete_str = params.get('path', [None])[0]
if not path_to_delete_str: raise ValueError("Caminho para deletar não especificado.")
path_to_delete = self.translate_path(path_to_delete_str)
print(f"Tentando deletar: {path_to_delete}")
if os.path.isdir(path_to_delete): shutil.rmtree(path_to_delete)
elif os.path.isfile(path_to_delete): os.remove(path_to_delete)
else:
self.send_error(404, "Arquivo ou diretório não encontrado para deletar.")
return
parent_dir = os.path.dirname(path_to_delete_str)
if not parent_dir.endswith('/'): parent_dir += '/'
self.send_response(303)
self.send_header('Location', parent_dir)
self.end_headers()
else:
self.send_error(400, "Ação POST inválida.")
except Exception as e:
print(f"Erro no POST: {e}")
self.send_error(500, f"Erro interno do servidor: {e}")
# --- Métodos auxiliares para GET ---
def handle_json_request(self, filename):
json_content = load_file_content(filename)
if json_content:
response_bytes = json_content.encode('utf-8')
self.send_response(200); self.send_header("Content-type", "application/json")
else:
error_msg = '{"error": "File not found"}'
response_bytes = error_msg.encode('utf-8')
self.send_response(404); self.send_header("Content-type", "application/json")
self.send_header("Content-Length", str(len(response_bytes)))
self.end_headers()
self.wfile.write(response_bytes)
def serve_directory_as_zip(self, dir_path):
"""
Compacta um diretório e seu conteúdo em um arquivo .zip e o serve para download.
Esta versão foi corrigida e aprimorada para garantir a funcionalidade.
"""
# Pega o nome do diretório que será o nome do arquivo .zip
dir_name = os.path.basename(os.path.normpath(dir_path))
zip_filename = f"{dir_name}.zip"
# Usa um arquivo em memória (BytesIO) para não criar arquivos temporários no disco
memory_file = io.BytesIO()
print(f"Iniciando compactação do diretório '{dir_name}' para '{zip_filename}'...")
# Cria o arquivo zip em modo de escrita
with zipfile.ZipFile(memory_file, 'w', zipfile.ZIP_DEFLATED) as zf:
# os.walk percorre o diretório e todos os seus subdiretórios
for root, dirs, files in os.walk(dir_path):
# Adiciona todos os arquivos encontrados
for file in files:
# Cria o caminho completo para o arquivo
file_path = os.path.join(root, file)
# Cria o caminho relativo que será usado dentro do .zip
# Isso preserva a estrutura de pastas
archive_name = os.path.relpath(file_path, start=dir_path)
print(f" Adicionando arquivo: {archive_name}")
zf.write(file_path, archive_name)
# Adiciona diretórios vazios, se houver
if not files and not dirs:
archive_name = os.path.relpath(root, start=dir_path)
print(f" Adicionando diretório vazio: {archive_name}/")
zf.writestr(archive_name + '/', '')
# Retorna ao início do arquivo em memória para que possa ser lido e enviado
memory_file.seek(0)
print(f"Compactação concluída. Tamanho final: {format_file_size(memory_file.getbuffer().nbytes)}")
# Envia os cabeçalhos HTTP para o navegador iniciar o download
self.send_response(200)
self.send_header('Content-Type', 'application/zip')
self.send_header('Content-Disposition', f'attachment; filename="{zip_filename}"')
self.send_header('Content-Length', str(memory_file.getbuffer().nbytes))
self.end_headers()
# Envia o conteúdo do arquivo .zip para o cliente
self.wfile.write(memory_file.getvalue())
# --- MÉTODO PRINCIPAL DA INTERFACE ---
def list_directory(self, path):
try:
raw_list = os.listdir(path)
except OSError:
self.send_error(404, "Permissão negada para listar o diretório")
return None
display_path = urllib.parse.unquote(self.path, errors='surrogatepass')
directories, files = [], []
for name in raw_list:
if os.path.isdir(os.path.join(path, name)): directories.append(name)
else: files.append(name)
directories.sort(key=str.lower)
files.sort(key=str.lower)
sorted_list = directories + files
download_icon = ''
delete_icon = ''
folder_icon = ''
file_icon = ''
html_parts = [
'', '', f'Índice de {display_path}',
'',
'', '',
f'