648 lines
23 KiB
Python
648 lines
23 KiB
Python
from flask import Flask, render_template, request, redirect, url_for, jsonify
|
|
import mysql.connector
|
|
import json
|
|
|
|
app = Flask(__name__)
|
|
|
|
DB_CONFIG = {
|
|
'host': '192.168.60.150',
|
|
'user': 'user_92z0Kj',
|
|
'password': '5B3UXZV8vyrB',
|
|
'database': 'radius_NIaIuT'
|
|
}
|
|
|
|
def get_db():
|
|
try:
|
|
db = mysql.connector.connect(**DB_CONFIG)
|
|
return db
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Connection Error: {err}")
|
|
return None
|
|
|
|
@app.route('/', methods=['GET', 'POST'])
|
|
def index():
|
|
sql_results = None
|
|
sql_error = None
|
|
total_users = 0
|
|
total_groups = 0
|
|
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor(dictionary=True)
|
|
try:
|
|
# Count total users
|
|
cursor.execute("SELECT COUNT(DISTINCT username) as total FROM radcheck;")
|
|
total_users = cursor.fetchone()['total']
|
|
|
|
# Count total groups
|
|
cursor.execute("SELECT COUNT(DISTINCT groupname) as total FROM radgroupreply;")
|
|
total_groups = cursor.fetchone()['total']
|
|
|
|
except mysql.connector.Error as err:
|
|
print(f"Error fetching counts: {err}")
|
|
|
|
cursor.close()
|
|
db.close()
|
|
|
|
return render_template('index.html', total_users=total_users, total_groups=total_groups, sql_results=sql_results, sql_error=sql_error)
|
|
|
|
@app.route('/sql', methods=['POST'])
|
|
def sql():
|
|
sql_results = None
|
|
sql_error = None
|
|
sql_query = request.form['query']
|
|
|
|
db = get_db()
|
|
if db:
|
|
try:
|
|
cursor = db.cursor(dictionary=True)
|
|
cursor.execute(sql_query)
|
|
sql_results = cursor.fetchall()
|
|
cursor.close()
|
|
db.close()
|
|
except mysql.connector.Error as err:
|
|
sql_error = str(err)
|
|
except Exception as e:
|
|
sql_error = str(e)
|
|
|
|
total_users = 0
|
|
total_groups = 0
|
|
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor(dictionary=True)
|
|
try:
|
|
# Count total users
|
|
cursor.execute("SELECT COUNT(DISTINCT username) as total FROM radcheck;")
|
|
total_users = cursor.fetchone()['total']
|
|
|
|
# Count total groups
|
|
cursor.execute("SELECT COUNT(DISTINCT groupname) as total FROM radgroupreply;")
|
|
total_groups = cursor.fetchone()['total']
|
|
|
|
except mysql.connector.Error as err:
|
|
print(f"Error fetching counts: {err}")
|
|
|
|
cursor.close()
|
|
db.close()
|
|
|
|
return render_template('index.html', total_users=total_users, total_groups=total_groups, sql_results=sql_results, sql_error=sql_error)
|
|
|
|
@app.route('/user_list')
|
|
def user_list():
|
|
"""Displays the user list with VLAN IDs and descriptions from rad_description."""
|
|
db = get_db()
|
|
if db is None:
|
|
return "Database connection failed", 500
|
|
|
|
cursor = db.cursor(dictionary=True)
|
|
try:
|
|
# Fetch users, their group assignments, and descriptions from rad_description
|
|
cursor.execute("""
|
|
SELECT
|
|
r.username AS mac_address,
|
|
rd.description AS description,
|
|
ug.groupname AS vlan_id
|
|
FROM radcheck r
|
|
LEFT JOIN radusergroup ug ON r.username = ug.username
|
|
LEFT JOIN rad_description rd ON r.username = rd.username
|
|
""") #removed WHERE clause
|
|
results = cursor.fetchall()
|
|
print("Results:", results) #added print statement
|
|
|
|
# Fetch all group names for the dropdown
|
|
cursor.execute("SELECT groupname FROM radgroupcheck")
|
|
groups = cursor.fetchall()
|
|
groups = [{'groupname': row['groupname']} for row in groups]
|
|
print("Groups:", groups) #added print statement
|
|
|
|
cursor.close()
|
|
db.close()
|
|
return render_template('user_list_inline_edit.html', results=results, groups=groups)
|
|
except mysql.connector.Error as e:
|
|
print(f"Database error: {e}")
|
|
cursor.close()
|
|
db.close()
|
|
return "Database error", 500
|
|
|
|
@app.route('/update_user', methods=['POST'])
|
|
def update_user():
|
|
mac_address = request.form['mac_address']
|
|
description = request.form['description']
|
|
vlan_id = request.form['vlan_id']
|
|
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
db.autocommit = False
|
|
|
|
# Update rad_description table
|
|
cursor.execute("""
|
|
UPDATE rad_description
|
|
SET description = %s
|
|
WHERE username = %s
|
|
""", (description, mac_address))
|
|
|
|
# Update radgroupreply table for VLAN ID
|
|
cursor.execute("""
|
|
UPDATE radgroupreply rgr
|
|
SET value = %s
|
|
WHERE rgr.groupname = (SELECT groupname FROM radusergroup rug WHERE rug.username = %s LIMIT 1)
|
|
AND rgr.attribute = 'Tunnel-Private-Group-Id'
|
|
""", (vlan_id, mac_address))
|
|
|
|
db.commit()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
return "success"
|
|
except mysql.connector.Error as err:
|
|
db.rollback()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
return str(err)
|
|
except Exception as e:
|
|
db.rollback()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
return str(e)
|
|
finally:
|
|
db.close()
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/delete_user/<mac_address>')
|
|
def delete_user(mac_address):
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
db.autocommit = False #Start transaction
|
|
|
|
# Delete from rad_description
|
|
cursor.execute("DELETE FROM rad_description WHERE username = %s", (mac_address,))
|
|
|
|
# Delete from radcheck
|
|
cursor.execute("DELETE FROM radcheck WHERE username = %s", (mac_address,))
|
|
|
|
#Delete from radusergroup
|
|
cursor.execute("DELETE FROM radusergroup WHERE username = %s", (mac_address,))
|
|
|
|
db.commit() #Commit transaction
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('user_list'))
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback() #Roll back transaction on error
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('user_list'))
|
|
return "Database Connection Failed"
|
|
|
|
# @app.route('/edit_user/<mac_address>', methods=['GET', 'POST'])
|
|
# def edit_user(mac_address):
|
|
# db = get_db()
|
|
# if db:
|
|
# cursor = db.cursor(dictionary=True)
|
|
|
|
# if request.method == 'POST':
|
|
# description = request.form['description']
|
|
# vlan_id = request.form['vlan_id']
|
|
|
|
# cursor.execute("""
|
|
# UPDATE radcheck
|
|
# SET value = %s
|
|
# WHERE username = %s AND attribute = 'User-Description'
|
|
# """, (description, mac_address))
|
|
|
|
# cursor.execute("""
|
|
# UPDATE radgroupreply rgr
|
|
# SET value = %s
|
|
# WHERE rgr.groupname = (SELECT groupname FROM radusergroup rug WHERE rug.username = %s LIMIT 1)
|
|
# AND rgr.attribute = 'Tunnel-Private-Group-Id'
|
|
# """, (vlan_id, mac_address))
|
|
|
|
# db.commit()
|
|
# cursor.close()
|
|
# db.close()
|
|
# return redirect(url_for('user_list'))
|
|
|
|
# else:
|
|
# cursor.execute("""
|
|
# SELECT
|
|
# rc.username AS mac_address,
|
|
# IFNULL((SELECT value FROM radgroupreply rgr
|
|
# WHERE rgr.groupname = (SELECT groupname FROM radusergroup rug WHERE rug.username = rc.username LIMIT 1)
|
|
# AND rgr.attribute = 'Tunnel-Private-Group-Id' LIMIT 1), 'N/A') AS vlan_id,
|
|
# IFNULL((SELECT value FROM radcheck rch
|
|
# WHERE rch.username = rc.username AND rch.attribute = 'User-Description' LIMIT 1), 'N/A') AS description
|
|
# FROM radcheck rc
|
|
# WHERE rc.username = %s
|
|
# GROUP BY rc.username;
|
|
# """, (mac_address,))
|
|
# user = cursor.fetchone()
|
|
# cursor.close()
|
|
# db.close()
|
|
# return render_template('edit_user.html', user=user)
|
|
# return "Database Connection Failed"
|
|
|
|
@app.route('/groups')
|
|
def groups():
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
# Fetch group names from radgroupcheck
|
|
cursor.execute("SELECT DISTINCT groupname FROM radgroupcheck")
|
|
group_names = [row[0] for row in cursor.fetchall()]
|
|
|
|
grouped_results = {}
|
|
for groupname in group_names:
|
|
# Fetch attributes for each group from radgroupreply
|
|
cursor.execute("SELECT id, attribute, op, value FROM radgroupreply WHERE groupname = %s", (groupname,))
|
|
attributes = cursor.fetchall()
|
|
grouped_results[groupname] = [{'id': row[0], 'attribute': row[1], 'op': row[2], 'value': row[3]} for row in attributes]
|
|
|
|
cursor.close()
|
|
db.close()
|
|
return render_template('group_list_nested.html', grouped_results=grouped_results)
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
cursor.close()
|
|
db.close()
|
|
return render_template('group_list_nested.html', grouped_results={})
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/edit_groupname/<old_groupname>', methods=['GET', 'POST'])
|
|
def edit_groupname(old_groupname):
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor(dictionary=True)
|
|
|
|
if request.method == 'POST':
|
|
new_groupname = request.form['groupname']
|
|
try:
|
|
db.autocommit = False
|
|
cursor.execute("""
|
|
UPDATE radgroupreply
|
|
SET groupname = %s
|
|
WHERE groupname = %s
|
|
""", (new_groupname, old_groupname))
|
|
|
|
cursor.execute("""
|
|
UPDATE radusergroup
|
|
SET groupname = %s
|
|
WHERE groupname = %s
|
|
""", (new_groupname, old_groupname))
|
|
|
|
db.commit()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('groups'))
|
|
except mysql.connector.Error as err:
|
|
db.rollback()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return f"Database Error: {err}"
|
|
else:
|
|
return render_template('edit_groupname.html', old_groupname=old_groupname)
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/update_attribute', methods=['POST'])
|
|
def update_attribute():
|
|
group_id = request.form['group_id']
|
|
attribute = request.form['attribute']
|
|
op = request.form['op']
|
|
value = request.form['value']
|
|
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
db.autocommit = False
|
|
cursor.execute("""
|
|
UPDATE radgroupreply
|
|
SET attribute = %s, op = %s, value = %s
|
|
WHERE id = %s
|
|
""", (attribute, op, value, group_id))
|
|
db.commit()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
return "success"
|
|
except mysql.connector.Error as err:
|
|
db.rollback()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
return str(err)
|
|
except Exception as e:
|
|
db.rollback()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
return str(e)
|
|
finally:
|
|
db.close()
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/add_attribute', methods=['POST'])
|
|
def add_attribute():
|
|
groupname = request.form['groupname']
|
|
attribute = request.form['attribute']
|
|
op = request.form['op']
|
|
value = request.form['value']
|
|
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
cursor.execute("""
|
|
INSERT INTO radgroupreply (groupname, attribute, op, value)
|
|
VALUES (%s, %s, %s, %s)
|
|
""", (groupname, attribute, op, value))
|
|
db.commit()
|
|
cursor.close()
|
|
db.close()
|
|
return "success"
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback()
|
|
cursor.close()
|
|
db.close()
|
|
return str(err)
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/edit_attribute/<group_id>', methods=['GET', 'POST'])
|
|
def edit_attribute(group_id):
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor(dictionary=True)
|
|
|
|
if request.method == 'POST':
|
|
attribute = request.form['attribute']
|
|
op = request.form['op']
|
|
value = request.form['value']
|
|
|
|
try:
|
|
db.autocommit = False
|
|
cursor.execute("""
|
|
UPDATE radgroupreply
|
|
SET attribute = %s, op = %s, value = %s
|
|
WHERE id = %s
|
|
""", (attribute, op, value, group_id))
|
|
db.commit()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('groups'))
|
|
except mysql.connector.Error as err:
|
|
db.rollback()
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return f"Database Error: {err}"
|
|
|
|
else:
|
|
cursor.execute("SELECT * FROM radgroupreply WHERE id = %s", (group_id,))
|
|
attribute_data = cursor.fetchone()
|
|
cursor.close()
|
|
db.close()
|
|
return render_template('edit_attribute.html', attribute_data=attribute_data)
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/add_group', methods=['POST'])
|
|
def add_group():
|
|
groupname = request.form['groupname']
|
|
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
cursor.execute("INSERT INTO radgroupreply (groupname, attribute, op, value) VALUES (%s, '', '', '')", (groupname,))
|
|
cursor.execute("INSERT INTO radusergroup (groupname, username) VALUES (%s, '')", (groupname,))
|
|
# Add default values for radgroupcheck
|
|
cursor.execute("INSERT INTO radgroupcheck (groupname, attribute, op, value) VALUES (%s, 'Auth-Type', ':=', 'Accept')", (groupname,))
|
|
db.commit()
|
|
cursor.close()
|
|
db.close()
|
|
return "success"
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback()
|
|
cursor.close()
|
|
db.close()
|
|
return str(err)
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/delete_group_rows/<groupname>')
|
|
def delete_group_rows(groupname):
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
cursor.execute("DELETE FROM radgroupreply WHERE groupname = %s", (groupname,))
|
|
cursor.execute("DELETE FROM radusergroup WHERE groupname = %s", (groupname,))
|
|
cursor.execute("DELETE FROM radgroupcheck WHERE groupname = %s", (groupname,))
|
|
db.commit()
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('groups'))
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback()
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('groups'))
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/delete_group/<int:group_id>')
|
|
def delete_group(group_id):
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
cursor.execute("DELETE FROM radgroupreply WHERE id = %s", (group_id,))
|
|
cursor.execute("DELETE FROM radgroupcheck WHERE id = %s", (group_id,)) # Delete from radgroupcheck
|
|
db.commit()
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('groups'))
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback()
|
|
cursor.close()
|
|
db.close()
|
|
return redirect(url_for('groups'))
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/duplicate_group', methods=['POST'])
|
|
def duplicate_group():
|
|
groupname = request.form['groupname']
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
cursor.execute("SELECT attribute, op, value FROM radgroupreply WHERE groupname = %s", (groupname,))
|
|
attributes = [{'attribute': row[0], 'op': row[1], 'value': row[2]} for row in cursor.fetchall()]
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify(attributes)
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify([])
|
|
return jsonify([])
|
|
|
|
@app.route('/save_duplicated_group', methods=['POST'])
|
|
def save_duplicated_group():
|
|
data = json.loads(request.data)
|
|
groupname = data['groupname']
|
|
attributes = data['attributes']
|
|
db = get_db()
|
|
if db:
|
|
cursor = db.cursor()
|
|
try:
|
|
cursor.execute("INSERT INTO radgroupcheck (groupname, attribute, op, value) VALUES (%s, 'Auth-Type', ':=', 'Accept')", (groupname,))
|
|
cursor.execute("INSERT INTO radusergroup (groupname, username) VALUES (%s, '')", (groupname,))
|
|
for attribute in attributes:
|
|
cursor.execute("INSERT INTO radgroupreply (groupname, attribute, op, value) VALUES (%s, %s, %s, %s)", (groupname, attribute['attribute'], attribute['op'], attribute['value']))
|
|
db.commit()
|
|
cursor.close()
|
|
db.close()
|
|
return "success"
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback()
|
|
cursor.close()
|
|
db.close()
|
|
return str(err)
|
|
return "Database Connection Failed"
|
|
|
|
@app.route('/add_user', methods=['POST'])
|
|
def add_user():
|
|
"""Adds a new user to the database."""
|
|
try:
|
|
data = request.get_json() # Get the JSON data from the request
|
|
mac_address = data.get('mac_address')
|
|
description = data.get('description')
|
|
vlan_id = data.get('vlan_id')
|
|
|
|
if not mac_address:
|
|
return jsonify({'success': False, 'message': 'MAC Address is required'}), 400
|
|
|
|
db = get_db()
|
|
if db is None:
|
|
return jsonify({'success': False, 'message': 'Database connection failed'}), 500
|
|
|
|
cursor = db.cursor()
|
|
try:
|
|
db.autocommit = False #Start Transaction
|
|
|
|
# Check if user already exists
|
|
cursor.execute("SELECT username FROM radcheck WHERE username = %s", (mac_address,))
|
|
if cursor.fetchone():
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify({'success': False, 'message': 'User with this MAC Address already exists'}), 400
|
|
|
|
# Insert into radcheck, setting password to MAC address
|
|
cursor.execute("""
|
|
INSERT INTO radcheck (username, attribute, op, value)
|
|
VALUES (%s, 'Cleartext-Password', ':=', %s)
|
|
""", (mac_address, mac_address)) # Use mac_address for both username and password
|
|
|
|
# Insert description into rad_description
|
|
cursor.execute("""
|
|
INSERT INTO rad_description (username, description)
|
|
VALUES (%s, %s)
|
|
""", (mac_address, description))
|
|
|
|
# Insert into radusergroup with the selected group
|
|
cursor.execute("""
|
|
INSERT INTO radusergroup (username, groupname)
|
|
VALUES (%s, %s)
|
|
""", (mac_address, vlan_id)) # Use vlan_id
|
|
|
|
db.commit() #Commit transaction
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify({'success': True, 'message': 'User added successfully'})
|
|
|
|
except mysql.connector.Error as err:
|
|
print(f"Database Error: {err}")
|
|
db.rollback() #Rollback transaction on error.
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify({'success': False, 'message': f"Database error: {err}"}), 500
|
|
|
|
except Exception as e:
|
|
print(f"Error adding user: {e}")
|
|
db.rollback() #Rollback transaction on error.
|
|
db.autocommit = True
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify({'success': False, 'message': str(e)}), 500
|
|
finally:
|
|
db.close()
|
|
except Exception as e:
|
|
return jsonify({'success': False, 'message': 'Unknown error'}), 500
|
|
|
|
@app.route('/duplicate_user', methods=['POST'])
|
|
def duplicate_user():
|
|
"""
|
|
Retrieves user data (MAC address, description, VLAN ID) from the database
|
|
based on the provided MAC address. This data is intended to be used to
|
|
pre-populate a "duplicate user" form in the frontend.
|
|
"""
|
|
mac_address = request.form['mac_address'] # Get the MAC address from the POST request.
|
|
|
|
db = get_db() # Get a database connection.
|
|
if db:
|
|
cursor = db.cursor(dictionary=True) # Create a cursor that returns results as dictionaries.
|
|
try:
|
|
# Construct the SQL query. This query retrieves the MAC address,
|
|
# description, and VLAN ID for the specified user.
|
|
cursor.execute("""
|
|
SELECT
|
|
rc.username AS mac_address,
|
|
IFNULL((SELECT value FROM radgroupreply rgr
|
|
WHERE rgr.groupname = (SELECT groupname FROM radusergroup rug WHERE rug.username = rc.username LIMIT 1)
|
|
AND rgr.attribute = 'Tunnel-Private-Group-Id' LIMIT 1), 'N/A') AS vlan_id,
|
|
IFNULL((SELECT value FROM radcheck rch
|
|
WHERE rch.username = rc.username AND rch.attribute = 'User-Description' LIMIT 1), 'N/A') AS description
|
|
FROM radcheck rc
|
|
WHERE rc.username = %s /* %s is a placeholder for the MAC address */
|
|
GROUP BY rc.username;
|
|
""", (mac_address,)) # Execute the query with the MAC address as a parameter.
|
|
|
|
user_data = cursor.fetchone() # Fetch the first (and should be only) result.
|
|
cursor.close() # Close the cursor.
|
|
db.close() # Close the database connection.
|
|
|
|
if user_data:
|
|
# If user data was found, return it as a JSON response.
|
|
return jsonify(user_data)
|
|
else:
|
|
# If no user data was found (e.g., invalid MAC address), return an empty JSON object.
|
|
return jsonify({})
|
|
|
|
except mysql.connector.Error as err:
|
|
# Handle database errors. Log the error and return an error message.
|
|
print(f"Database Error: {err}")
|
|
cursor.close()
|
|
db.close()
|
|
return jsonify({}) # Return an empty JSON object on error, to avoid crashing.
|
|
|
|
else:
|
|
# Handle the case where the database connection could not be established.
|
|
return jsonify({}) # Return empty JSON object
|
|
|
|
|
|
if __name__ == '__main__':
|
|
app.run(debug=True, host='0.0.0.0', port=8080)
|