1st restructure
This commit is contained in:
Michael Beck
470
app/app.py
Normal file
470
app/app.py
Normal file
@@ -0,0 +1,470 @@
|
||||
from flask import Flask, request, render_template, Response, jsonify, url_for
|
||||
from flask_bootstrap import Bootstrap5 # from package boostrap_flask
|
||||
from app.forms import ScrapingForm
|
||||
import requests
|
||||
import pandas as pd
|
||||
import time
|
||||
from datetime import datetime, timedelta
|
||||
import threading
|
||||
import logging
|
||||
from logging.handlers import QueueHandler
|
||||
from queue import Queue
|
||||
import os
|
||||
import glob
|
||||
from datetime import datetime
|
||||
from flask import send_from_directory
|
||||
import configparser
|
||||
|
||||
import zipfile
|
||||
import os
|
||||
from datetime import timedelta
|
||||
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
# Load configuration
|
||||
config = configparser.ConfigParser()
|
||||
config.read('config.ini')
|
||||
|
||||
app.config['SECRET_KEY'] = config['DEFAULT']['SECRET_KEY']
|
||||
API_KEY = config['DEFAULT']['API_KEY']
|
||||
|
||||
bootstrap = Bootstrap5(app)
|
||||
|
||||
# Move every setting from config['BOOTSTRAP'] to the root level of config
|
||||
for key in config['BOOTSTRAP']:
|
||||
key = key.upper()
|
||||
app.config[key] = config['BOOTSTRAP'][key]
|
||||
if key == 'SECRET_KEY':
|
||||
continue
|
||||
elif key == 'API_KEY':
|
||||
continue
|
||||
print(f"Loaded config: {key} = {app.config[key]}")
|
||||
|
||||
# Global state
|
||||
scraping_active = False
|
||||
scraping_thread = None
|
||||
data_file_name = None
|
||||
log_file_name = "log/" + datetime.now().strftime('%Y-%m-%d-%H-%M') + '.log'
|
||||
|
||||
# Initialize the logger
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.setLevel(logging.DEBUG) # Adjust as needed
|
||||
|
||||
# Make any logger.info() call go to both the log file and the queue.
|
||||
# 1) FILE HANDLER
|
||||
file_handler = logging.FileHandler(log_file_name, mode='w')
|
||||
file_handler.setLevel(logging.DEBUG) # or INFO, WARNING, etc.
|
||||
formatter = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s',
|
||||
datefmt='%m/%d/%Y %I:%M:%S %p')
|
||||
file_handler.setFormatter(formatter)
|
||||
|
||||
logger.addHandler(file_handler)
|
||||
|
||||
# 2) QUEUE HANDLER
|
||||
log_queue = Queue()
|
||||
queue_handler = QueueHandler(log_queue)
|
||||
queue_handler.setLevel(logging.DEBUG)
|
||||
logger.addHandler(queue_handler)
|
||||
|
||||
|
||||
|
||||
def create_zip(file_paths, zip_name):
|
||||
zip_path = os.path.join(app.root_path, 'temp', zip_name)
|
||||
with zipfile.ZipFile(zip_path, 'w') as zipf:
|
||||
for file_path in file_paths:
|
||||
arcname = os.path.basename(file_path)
|
||||
zipf.write(file_path, arcname)
|
||||
return zip_path
|
||||
|
||||
def delete_old_zips():
|
||||
temp_dir = os.path.join(app.root_path, 'temp')
|
||||
now = datetime.now()
|
||||
for filename in os.listdir(temp_dir):
|
||||
if filename.endswith('.zip'):
|
||||
file_path = os.path.join(temp_dir, filename)
|
||||
file_time = datetime.fromtimestamp(os.path.getmtime(file_path))
|
||||
if now - file_time > timedelta(hours=1):
|
||||
os.remove(file_path)
|
||||
logger.info(f"Deleted old zip file: {filename}")
|
||||
|
||||
def fetch_faction_data(faction_id):
|
||||
url = f"https://api.torn.com/faction/{faction_id}?selections=&key={API_KEY}"
|
||||
response = requests.get(url)
|
||||
if response.status_code == 200:
|
||||
logger.info(f"Fetched data for faction ID {faction_id}")
|
||||
return response.json()
|
||||
else:
|
||||
logger.warning(f"Failed to fetch faction data for faction ID {faction_id}")
|
||||
return None
|
||||
|
||||
def fetch_user_activity(user_id):
|
||||
url = f"https://api.torn.com/user/{user_id}?selections=basic,profile&key={API_KEY}"
|
||||
response = requests.get(url)
|
||||
if response.status_code == 200:
|
||||
return response.json()
|
||||
else:
|
||||
logger.error(f"Failed to fetch user activity for user ID {user_id}")
|
||||
return None
|
||||
|
||||
def scrape_data(faction_id, fetch_interval, run_interval):
|
||||
global scraping_active
|
||||
global data_file_name
|
||||
|
||||
end_time = datetime.now() + timedelta(days=run_interval)
|
||||
data_file_name = f"data/{faction_id}-{datetime.now().strftime('%Y-%m-%d-%H-%M')}.csv"
|
||||
|
||||
while datetime.now() < end_time and scraping_active:
|
||||
logger.info(f"Fetching data at {datetime.now()}")
|
||||
faction_data = fetch_faction_data(faction_id)
|
||||
if faction_data and 'members' in faction_data:
|
||||
user_activity_data = []
|
||||
for user_id, user_info in faction_data['members'].items():
|
||||
user_activity = fetch_user_activity(user_id)
|
||||
if user_activity:
|
||||
user_activity_data.append({
|
||||
'user_id': user_id,
|
||||
'name': user_activity.get('name', ''),
|
||||
'last_action': user_activity.get('last_action', {}).get('timestamp', 0),
|
||||
'stadata_file_nametus': user_activity.get('status', {}).get('state', ''),
|
||||
'timestamp': datetime.now().timestamp()
|
||||
})
|
||||
logger.info(f"Fetched data for user {user_id} ({user_activity.get('name', '')})")
|
||||
|
||||
# Append data to the file
|
||||
df = pd.DataFrame(user_activity_data)
|
||||
df['last_action'] = pd.to_datetime(df['last_action'], unit='s')
|
||||
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='s')
|
||||
|
||||
if not os.path.isfile(data_file_name):
|
||||
df.to_csv(data_file_name, index=False)
|
||||
else:
|
||||
df.to_csv(data_file_name, mode='a', header=False, index=False)
|
||||
|
||||
logger.info(f"Data appended to {data_file_name}")
|
||||
|
||||
time.sleep(fetch_interval)
|
||||
else:
|
||||
if datetime.now() < end_time:
|
||||
logger.warning(f"Scraping stopped at {datetime.now()}")
|
||||
elif scraping_active == False:
|
||||
logger.warning(f"Scraping stopped at {datetime.now()} due to user request")
|
||||
else:
|
||||
logger.error(f"Scraping stopped due to timeout at {datetime.now()}")
|
||||
logger.info("Scraping completed.")
|
||||
scraping_active = False
|
||||
|
||||
def generate_statistics(df):
|
||||
df['hour'] = df['timestamp'].dt.hour
|
||||
activity_by_hour = df.groupby('hour').size()
|
||||
return activity_by_hour
|
||||
|
||||
# Taken from:
|
||||
# https://gist.github.com/amitsaha/5990310?permalink_comment_id=3017951#gistcomment-3017951
|
||||
def tail(filename, n):
|
||||
stat = os.stat(filename)
|
||||
n = int(n)
|
||||
if stat.st_size == 0 or n == 0:
|
||||
yield ''
|
||||
return
|
||||
|
||||
page_size = int(config['LOGGING']['TAIL_PAGE_SIZE'])
|
||||
offsets = []
|
||||
count = _n = n if n >= 0 else -n
|
||||
|
||||
last_byte_read = last_nl_byte = starting_offset = stat.st_size - 1
|
||||
|
||||
with open(filename, 'r') as f:
|
||||
while count > 0:
|
||||
starting_byte = last_byte_read - page_size
|
||||
if last_byte_read == 0:
|
||||
offsets.append(0)
|
||||
break
|
||||
elif starting_byte < 0:
|
||||
f.seek(0)
|
||||
text = f.read(last_byte_read)
|
||||
else:
|
||||
f.seek(starting_byte)
|
||||
text = f.read(page_size)
|
||||
|
||||
for i in range(-1, -1*len(text)-1, -1):
|
||||
last_byte_read -= 1
|
||||
if text[i] == '\n':
|
||||
last_nl_byte = last_byte_read
|
||||
starting_offset = last_nl_byte + 1
|
||||
offsets.append(starting_offset)
|
||||
count -= 1
|
||||
|
||||
offsets = offsets[len(offsets)-_n:]
|
||||
offsets.reverse()
|
||||
|
||||
with open(filename, 'r') as f:
|
||||
for i, offset in enumerate(offsets):
|
||||
f.seek(offset)
|
||||
|
||||
if i == len(offsets) - 1:
|
||||
yield f.read()
|
||||
else:
|
||||
bytes_to_read = offsets[i+1] - offset
|
||||
yield f.read(bytes_to_read)
|
||||
|
||||
def is_data_file_in_use(filename):
|
||||
if(data_file_name == None):
|
||||
return False
|
||||
if os.path.join(app.root_path, filename.lstrip('/')) == os.path.join(app.root_path, data_file_name.lstrip('/')) and scraping_active:
|
||||
return True
|
||||
return False
|
||||
|
||||
@app.route('/is_data_file_in_use/<path:filename>')
|
||||
def is_data_file_in_use_json(filename):
|
||||
return jsonify(is_data_file_in_use(filename))
|
||||
|
||||
def is_log_file_in_use(filename):
|
||||
if(log_file_name == None):
|
||||
return False
|
||||
if os.path.join(app.root_path, filename.lstrip('/')) == os.path.join(app.root_path, log_file_name.lstrip('/')):
|
||||
return True
|
||||
return False
|
||||
|
||||
@app.route('/is_log_file_in_use/<path:filename>')
|
||||
def is_log_file_in_use_json(filename):
|
||||
print(filename)
|
||||
return jsonify(is_log_file_in_use(filename))
|
||||
|
||||
@app.route('/')
|
||||
def index():
|
||||
form = ScrapingForm()
|
||||
return render_template('index.html', form=form)
|
||||
|
||||
@app.route('/start_scraping', methods=['POST'])
|
||||
def start_scraping():
|
||||
global scraping_active, scraping_thread
|
||||
form = ScrapingForm()
|
||||
if form.validate_on_submit():
|
||||
if scraping_active:
|
||||
logger.warning("Can't start scraping process: scraping already in progress")
|
||||
return jsonify({"status": "Scraping already in progress"})
|
||||
|
||||
scraping_active = True
|
||||
|
||||
faction_id = form.faction_id.data
|
||||
fetch_interval = form.fetch_interval.data
|
||||
run_interval = form.run_interval.data
|
||||
|
||||
# Start scraping in a separate thread
|
||||
scraping_thread = threading.Thread(target=scrape_data, args=(faction_id, fetch_interval, run_interval))
|
||||
scraping_thread.daemon = True
|
||||
scraping_thread.start()
|
||||
|
||||
return jsonify({"status": "Scraping started"})
|
||||
return jsonify({"status": "Invalid form data"})
|
||||
|
||||
@app.route('/stop_scraping', methods=['POST'])
|
||||
def stop_scraping():
|
||||
global scraping_active
|
||||
if not scraping_active:
|
||||
return jsonify({"status": "No scraping in progress"})
|
||||
|
||||
scraping_active = False
|
||||
logger.debug("scraping_active set to False")
|
||||
return jsonify({"status": "Scraping stopped"})
|
||||
|
||||
@app.route('/scraping_status', methods=['GET'])
|
||||
def scraping_status():
|
||||
global scraping_active
|
||||
logger.debug(f"scraping_status called: scraping_active = {scraping_active}")
|
||||
return jsonify({"scraping_active": scraping_active})
|
||||
|
||||
@app.route('/logs')
|
||||
def logs():
|
||||
def generate():
|
||||
while True:
|
||||
if not log_queue.empty():
|
||||
log = log_queue.get().getMessage()
|
||||
yield f"data: {log}\n\n"
|
||||
time.sleep(0.1)
|
||||
return Response(generate(), mimetype='text/event-stream')
|
||||
|
||||
@app.route('/logfile', methods=['GET'])
|
||||
def logfile():
|
||||
page = int(request.args.get('page', 0)) # Page number
|
||||
lines_per_page = int(request.args.get('lines_per_page', config['LOGGING']['VIEW_PAGE_LINES'])) # Lines per page
|
||||
log_file_path = log_file_name # Path to the current log file
|
||||
|
||||
if not os.path.isfile(log_file_path):
|
||||
logging.error("Log file not found")
|
||||
return jsonify({"error": "Log file not found"}), 404
|
||||
|
||||
log_lines = list(tail(log_file_path, config['LOGGING']['VIEW_MAX_LINES']))
|
||||
|
||||
log_lines = log_lines[::-1] # Reverse the list
|
||||
|
||||
start = page * lines_per_page
|
||||
end = start + lines_per_page
|
||||
paginated_lines = log_lines[start:end] if start < len(log_lines) else []
|
||||
|
||||
return jsonify({
|
||||
"log": paginated_lines,
|
||||
"total_lines": len(log_lines),
|
||||
"pages": (len(log_lines) + lines_per_page - 1) // lines_per_page,
|
||||
"start_line": len(log_lines) - start # Starting line number for the current page
|
||||
})
|
||||
|
||||
@app.route('/results')
|
||||
def results():
|
||||
# Assuming the scraping is done and data is saved somewhere
|
||||
faction_id = request.args.get('faction_id')
|
||||
filename = f"data/{faction_id}-{datetime.now().strftime('%Y-%m-%d-%H-%M')}.csv"
|
||||
if os.path.isfile(filename):
|
||||
df = pd.read_csv(filename)
|
||||
stats = generate_statistics(df)
|
||||
return render_template('results.html', stats=stats.to_dict())
|
||||
else:
|
||||
return "No data found."
|
||||
|
||||
@app.route('/analyze')
|
||||
def analyze():
|
||||
return render_template('analyze.html');
|
||||
|
||||
@app.route('/log_viewer')
|
||||
def log_viewer():
|
||||
return render_template('log_viewer.html');
|
||||
|
||||
@app.route('/download_results')
|
||||
def download_results():
|
||||
data_files = glob.glob("data/*.csv")
|
||||
log_files = glob.glob("log/*.log")
|
||||
|
||||
def get_file_info(file_path):
|
||||
return {
|
||||
"name": file_path,
|
||||
"name_display": os.path.basename(file_path),
|
||||
"last_modified": os.path.getmtime(file_path),
|
||||
"created": os.path.getctime(file_path),
|
||||
"size": get_size(file_path)
|
||||
}
|
||||
|
||||
data_files_info = [get_file_info(file) for file in data_files]
|
||||
log_files_info = [get_file_info(file) for file in log_files]
|
||||
|
||||
for data_file in data_files_info:
|
||||
if is_data_file_in_use(data_file['name']):
|
||||
data_file['active'] = True
|
||||
else:
|
||||
data_file['active'] = False
|
||||
|
||||
for log_file in log_files_info:
|
||||
if is_log_file_in_use(log_file['name']):
|
||||
log_file['active'] = True
|
||||
else:
|
||||
log_file['active'] = False
|
||||
|
||||
files = {"data": data_files_info, "log": log_files_info}
|
||||
|
||||
return render_template('download_results.html', files=files)
|
||||
|
||||
@app.route('/download_files', methods=['POST'])
|
||||
def download_files():
|
||||
delete_old_zips() # Clean up old zip files
|
||||
|
||||
file_paths = request.json.get('file_paths', [])
|
||||
|
||||
if not file_paths:
|
||||
return jsonify({"error": "No files specified"}), 400
|
||||
|
||||
# Validate and correct file paths
|
||||
valid_file_paths = []
|
||||
for file_path in file_paths:
|
||||
if file_path.startswith('/data/'):
|
||||
corrected_path = file_path.lstrip('/')
|
||||
full_path = os.path.join(app.root_path, corrected_path)
|
||||
if os.path.isfile(full_path):
|
||||
valid_file_paths.append(full_path)
|
||||
elif file_path.startswith('/log/'):
|
||||
corrected_path = file_path.lstrip('/')
|
||||
full_path = os.path.join(app.root_path, corrected_path)
|
||||
if os.path.isfile(full_path):
|
||||
valid_file_paths.append(full_path)
|
||||
|
||||
if not valid_file_paths:
|
||||
return jsonify({"error": "No valid files specified"}), 400
|
||||
|
||||
# Create a unique zip file name
|
||||
zip_name = f"files_{datetime.now().strftime('%Y%m%d%H%M%S')}.zip"
|
||||
zip_path = create_zip(valid_file_paths, zip_name)
|
||||
|
||||
return send_from_directory(directory='temp', path=zip_name, as_attachment=True)
|
||||
|
||||
@app.route('/delete_files', methods=['POST'])
|
||||
def delete_files():
|
||||
file_paths = request.json.get('file_paths', [])
|
||||
|
||||
if not file_paths:
|
||||
return jsonify({"error": "No files specified"}), 400
|
||||
|
||||
errors = []
|
||||
for file_path in file_paths:
|
||||
full_file_path = os.path.join(app.root_path, file_path.lstrip('/'))
|
||||
print(f"Attempting to delete: {file_path}") # Debugging line
|
||||
print(f"Full path: {full_file_path}") # Debugging line
|
||||
print(f"file_path: {file_path}") # Debugging line
|
||||
|
||||
# Check if the file is in either the logs or the data files folder
|
||||
if not (full_file_path.startswith(os.path.join(app.root_path, 'log')) or
|
||||
full_file_path.startswith(os.path.join(app.root_path, 'data'))):
|
||||
errors.append({"file": file_path, "error": "File not in allowed directory"})
|
||||
continue
|
||||
|
||||
# Check if it's the currently active log file
|
||||
if is_log_file_in_use(file_path):
|
||||
errors.append({"file": file_path, "error": "Cannot delete active log file."})
|
||||
continue
|
||||
|
||||
# Check if it's an active data file
|
||||
if is_data_file_in_use(file_path):
|
||||
errors.append({"file": file_path, "error": "Cannot delete active data file."})
|
||||
continue
|
||||
|
||||
if not os.path.isfile(full_file_path):
|
||||
errors.append({"file": file_path, "error": "File not found"})
|
||||
continue
|
||||
|
||||
try:
|
||||
os.remove(full_file_path)
|
||||
except Exception as e:
|
||||
errors.append({"file": file_path, "error": str(e)})
|
||||
|
||||
if errors:
|
||||
return jsonify({"errors": errors}), 207 # Multi-Status response
|
||||
return jsonify({"success": True}), 200
|
||||
|
||||
@app.template_filter('datetimeformat')
|
||||
def datetimeformat(value):
|
||||
return datetime.fromtimestamp(value).strftime('%Y-%m-%d %H:%M:%S')
|
||||
|
||||
def get_size(path):
|
||||
size = os.path.getsize(path)
|
||||
if size < 1024:
|
||||
return f"{size} bytes"
|
||||
elif size < pow(1024,2):
|
||||
return f"{round(size/1024, 2)} KB"
|
||||
elif size < pow(1024,3):
|
||||
return f"{round(size/(pow(1024,2)), 2)} MB"
|
||||
elif size < pow(1024,4):
|
||||
return f"{round(size/(pow(1024,3)), 2)} GB"
|
||||
|
||||
@app.route('/data/<path:filename>')
|
||||
def download_data_file(filename):
|
||||
return send_from_directory('data', filename)
|
||||
|
||||
@app.route('/log/<path:filename>')
|
||||
def download_log_file(filename):
|
||||
return send_from_directory('log', filename)
|
||||
|
||||
@app.route('/config/lines_per_page')
|
||||
def get_lines_per_page():
|
||||
lines_per_page = config['LOGGING']['VIEW_PAGE_LINES']
|
||||
return jsonify({"lines_per_page": lines_per_page})
|
||||
|
||||
if __name__ == '__main__':
|
||||
app.run(debug=True, threaded=True)
|
||||
Reference in New Issue
Block a user