flask_backend.py

from flask import Flask, request, abort, jsonify, make_response
from flask_cors import CORS
from database_api import CrisisEventsDatabase
#from database_implementation import sqlite_api
from runtime_import import runtime_import
import hashlib
from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity,create_refresh_token
import os 
import zipfile
import glob

#summarizers
import summarizer_implementations.t5 as t5
import summarizer_implementations.nltk_summarizer as nltk
import summarizer_implementations.bert as bert

app = Flask(__name__)
app.config['JWT_SECRET_KEY'] = 'PI'
jwt = JWTManager(app)
#pip install flask-cors
#pip install Flask-JWT-Extended
CORS(app) 


database:CrisisEventsDatabase = None

#this function is terrible, oh well!
def database_debug_view():
    db_html = ""
    user_db_html = ""
    for collection in database.get_sample_of_collections():
        db_html += f"<br/><code>{collection}</code>"

    for collection in database.get_sample_of_users():
        user_db_html += f"<br/><code>{collection}</code>"

    return f"""
    <html>
    <head></head>
    <body>
        <p>This service uses {database.get_info()} as its database</p>
        <p>Warning: if there are any '<'  or '>' or '/' or '\\' in the database: this will break! </p>
        <code>CollectionID, UserID, CollectionData, CollectionSummary, CollectionName</code>
        {db_html}
        <br/><br/><br/>
        <code>UserID, UserName, Hash</code>
        {user_db_html}
    </body>
    </html>
    """
@app.route('/login', methods = ['POST'])
def login():
     
    data = request.json  # Retrieve JSON data from the request
    print(f'The login data: {data}')

    if "authenticate" not in data:
        abort(400)

    data = data["authenticate"]
    if 'username' not in data or 'password' not in data:
        abort(400)

    username = data['username']
    password = data ['password']

    user_hash = hashlib.md5(password.encode()).digest().hex()

    user_data = database.get_user_by_username(username)

    if user_data is None:
        #abort(401)  # Unauthorized if user does not exist
        print(f'Username or password is incorrect: {data}')
        return {"status":"User does not exist"}, 401
        
    stored_hash = user_data[2]

    if user_hash != stored_hash:
        print(f'Password is incorrect: {data}')
        return {"status":"Incorrect Password"}, 401
  
    access_token = create_access_token(username)
    refresh_token = create_refresh_token(username)
    print(f'Login Successful!\n')
    return jsonify({"status":"success", "access_token": access_token, "refresh_token": refresh_token}), 200  # Return a response to indicate success

@app.route('/refresh', methods = ['POST'])
@jwt_required(refresh = True)
def refresh():
    current_user = get_jwt_identity()
    new_access_token = create_access_token(identity = current_user)
    return make_response(jsonify({"access_token": new_access_token}), 200)

@app.route('/database_service', methods=['POST','GET'])
def database_service():
    """
    POST Commands:
        create_collection
            - creates a collection under the logged in user

        get_collections
            - gets the title and id of every collection under the logged user
    """
    if request.method == 'POST':
        # print("request body: ",request.json)

        
        result = ''
        try:
            command = request.json["command"]
            if command == "create_collection":
                database.create_collection(0,request.json["data"]["collection_name"])
            elif command == "get_collection":
                result = str(database.get_collection(0,0))
            elif command == "get_collections":
                result = str(database.get_collection(0,0))
            else:
                print("Invalid command")
                abort(400)
        except KeyError:
            print("Got poorly formatted request")
            abort(400)

        return result, 200
    elif request.method == 'GET':
        return database_debug_view(), 200
    else:
        abort(400)

@app.route('/api/v1/get_collections', methods=['GET'])
def get_collections():
    "http://127.0.0.1:5000//api/v1/get_collections?user=0"
    user_id = request.args.get("user")

    if not user_id:
        abort(400)

    collections = database.get_collections(user_id)

    # print(collections)
    return {
        "status":"success",
        "collections": collections
    }, 200

@app.route('/api/v1/get_collection', methods=['GET'])
def get_collection():
    "http://127.0.0.1:5000//api/v1/get_collection?collection=0"
    collection_id = request.args.get("collection")

    if not collection_id:
        abort(400)

    collection = database.get_collection(collection_id)
    # print("get_collection:",collection)

    if collection:
        return {"status":"success","collection":collection}, 200
    else:
        return {"status":"failure"}, 200
    
@app.route('/api/v1/create_collection', methods=['POST'])
def v1_create_collection():

    data = request.json

    if "collection_info" not in data:
        abort(400)

    collection_info = data["collection_info"]

    if "collection_name" not in collection_info:
        abort(400)

    if "type" not in collection_info:
        abort(400)

    id = database.create_collection(0,collection_info["collection_name"],collection_info["type"])

    return {
        "status":"success",
        "collection_id":id
        }, 200

@app.route('/api/v1/update_collection_glob', methods=['POST'])
def v1_update_collection_glob():

    data = request.json

    if "collection_info" not in data:
        abort(400)

    collection_info = data["collection_info"]

    if "collection_id" not in collection_info:
        print("Missing ID")
        abort(400)
    
    if "glob" not in collection_info:
        print("Missing Glob")
        abort(400)

    database.update_collection_glob(collection_info["collection_id"],collection_info["glob"])
    return {
        "status":"success",
        }, 200

@app.route('/api/v1/summarize/t5', methods=['POST'])
def v1_summarize_t5():
    data = request.json

    if "collection_info" not in data:
        abort(400)

    collection_info = data["collection_info"]

    if "collection_id" not in collection_info:
        print("Missing ID")
        abort(400)

    # collection = database.get_collection(collection_info["collection_id"])

    files = database.get_raw_text_files(collection_info["collection_id"])
    
    glob = ""
    for file_data in files:
        with open(file_data["path"], "r", encoding="utf8") as f:
            glob += f.read()

    # summary = t5.summarize(collection["collection_data"]["glob"])
    summary = t5.summarize(glob)
    
    if summary:
        database.update_collection_summary(collection_info["collection_id"],summary)

        return {
            "status":"success",
            }, 200
    else:
        return {
            "status":"failure",
            }, 500
    
@app.route('/api/v1/summarize/nltk', methods=['POST'])
def v1_summarize_nltk():
    data = request.json

    if "collection_info" not in data:
        abort(400)

    collection_info = data["collection_info"]

    if "collection_id" not in collection_info:
        print("Missing ID")
        abort(400)

    # collection = database.get_collection(collection_info["collection_id"])

    files = database.get_raw_text_files(collection_info["collection_id"])
    
    glob = ""
    for file_data in files:
        with open(file_data["path"], "r", encoding="utf8") as f:
            glob += f.read()

    # summary = t5.summarize(collection["collection_data"]["glob"])
    summary = nltk.summarize(glob)
    
    if summary:
        database.update_collection_summary(collection_info["collection_id"],summary)

        return {
            "status":"success",
            }, 200
    else:
        return {
            "status":"failure",
            }, 500
    
@app.route('/api/v1/summarize/bert', methods=['POST'])
def v1_summarize_bert():
    data = request.json

    if "collection_info" not in data:
        abort(400)

    collection_info = data["collection_info"]

    if "collection_id" not in collection_info:
        print("Missing ID")
        abort(400)

    # collection = database.get_collection(collection_info["collection_id"])

    files = database.get_raw_text_files(collection_info["collection_id"])
    
    glob = ""
    for file_data in files:
        with open(file_data["path"], "r", encoding="utf8") as f:
            glob += f.read()

    # summary = t5.summarize(collection["collection_data"]["glob"])
    summary = bert.summarize(glob)
    
    if summary:
        database.update_collection_summary(collection_info["collection_id"],summary)

        return {
            "status":"success",
            }, 200
    else:
        return {
            "status":"failure",
            }, 500
    

@app.route('/api/v1/upload_raw_text', methods=['POST'])
def v1_upload_raw_text():
    "http://127.0.0.1:5000//api/v1/upload_raw_text?collection=0"
    collection_id = request.args.get("collection")

    if not collection_id:
        abort(400)

    # collection = database.get_collection(collection_id)

    os.makedirs(f"./backend/storage/{collection_id}",exist_ok=True)

    for zip_file in request.files.keys():
        path = f"./backend/storage/{collection_id}/{zip_file}"
        request.files[zip_file].save(path)

        with zipfile.ZipFile(path, 'r') as zip_ref:
            zip_ref.extractall(f"./backend/storage/{collection_id}")

        glob_path = r'./backend/storage/' + collection_id + r'/*.txt'

        for file_path in glob.glob(glob_path):
            database.create_raw_text_file(collection_id, file_path)


    return {"status":"success"}, 200

@app.route('/api/v1/upload_url_file', methods=['POST'])
def v1_upload_url_file():
    "http://127.0.0.1:5000//api/v1/upload_url_file?collection=0"
    collection_id = request.args.get("collection")

    if not collection_id:
        abort(400)

    # collection = database.get_collection(collection_id)

    os.makedirs(f"./backend/storage/{collection_id}",exist_ok=True)

    for url_file in request.files.keys():
        path = f"./backend/storage/{collection_id}/{url_file}"
        request.files[url_file].save(path)
        print(f"Saved: {path}")


    return {"status":"success"}, 200
  
@app.route('/api/v1/get_items', methods=['GET'])
def v1_get_items():
    "http://127.0.0.1:5000//api/v1/get_items?collection=0"
    collection_id = request.args.get("collection")
    file_type = request.args.get("type")

    if not collection_id:
        abort(400)

    collection = database.get_collection(collection_id)

    c_type = collection["type"]

    items = []
    if c_type == "text":
        glob_path = r'./backend/storage/' + collection_id + r'/*.txt'
        for file_path in glob.glob(glob_path):
            items.append(file_path)
    elif c_type == "url":
        glob_path = r'./backend/storage/' + collection_id + r'/*.txt'
        for file_path in glob.glob(glob_path):
            with open(file_path) as file:
                items = [line.rstrip() for line in file]

    print(items)

    return {"status":"success","files":items}, 200


@app.route('/testing', methods=['POST','GET'])
def testing():
    if request.method == 'POST':
        return ["Success Post request"], 200

    elif request.method == 'GET':
        print("get request: ",request.args)
        return [{"test":"hello"}], 200

    abort(400)

 
if __name__ == '__main__':
    database = runtime_import("database_implementation/")[0].IMPLEMENTATION()
    database.initialize()
    database.create_user("test_user","12345")
    database.create_user("test_user2","12345")
    

    app.run()