python

from flask import Flask, render_template, request, redirect, session, url_for, jsonify
from flask_login import LoginManager
import mysql.connector
from mysql.connector import pooling
import base64
from datetime import datetime
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import secrets
import io
from flask_caching import Cache

app = Flask(__name__)
app.config["SECRET_KEY"] = secrets.token_hex(64)
app.config['CACHE_TYPE'] = 'simple'
cache = Cache(app)


def count():
    cnx = mysql.connector.connect(user='flask', password='flask', host='127.0.0.1', database='accesslogs')
    cursor = cnx.cursor()
    query = ("SELECT COUNT(*) FROM accesslog")
    cursor.execute(query)
    row_count = cursor.fetchone()[0]
    cursor.close()
    cnx.close()
    return row_count

def count2():
    cnx = mysql.connector.connect(user='flask', password='flask', host='127.0.0.1', database='accesslogs')
    cursor = cnx.cursor()
    query = ("SELECT COUNT(*) FROM dataset")
    cursor.execute(query)
    row_count = cursor.fetchone()[0]
    cursor.close()
    cnx.close()
    return row_count

def cachedb():
    current_row_count = count()
    cached_row_count = cache.get('dashboard_row_count')

    if cached_row_count is None or cached_row_count < current_row_count:
        cache.set('dashboard_row_count', current_row_count)
        cache.delete('dashboardcache')

    current_row_count2 = count2()
    cached_row_count2 = cache.get('dashboard_row_count2')

    if cached_row_count2 is None or cached_row_count2 < current_row_count2:
        cache.set('dashboard_row_count2', current_row_count2)
        cache.delete('dashboardcache')

pooling1 = mysql.connector.pooling.MySQLConnectionPool(pool_name="mypool", pool_size=2, user='flask', password='flask', host='127.0.0.1', database='accesslogs')

def pooling():
    return pooling1.get_connection()

@app.route("/dashboard")
@cache.cached(timeout=1440, key_prefix='dashboardcache')
def dashboard():
    cachedb()

    if session.get('Role_ID') == 2:
        cnx = pooling()
        cursor = cnx.cursor(dictionary=True)
        cursor.execute("SELECT date, ip_address, os, log FROM accesslog")
        data = cursor.fetchall()
        cursor.close()
        cnx.close()

        cnx2 = pooling()
        cursor2 = cnx2.cursor(dictionary=True)
        cursor2.execute("SELECT ip, date, method, status, size, request, referer, user_agent FROM dataset")
        data2 = cursor2.fetchall()
        cursor2.close()
        cnx2.close()

        dates = []
        for entry in data:
            date_value = entry['date']
            if isinstance(date_value, str):
                dates.append(datetime.strptime(date_value, '%Y-%m-%d %H:%M:%S'))
            elif isinstance(date_value, datetime):
                dates.append(date_value)

        size_counts = {}
        for entry in data2:
            size_counts[entry['size']] = size_counts.get(entry['size'], 0) + 1

        method_counts = {}
        for entry in data2:
            method_counts[entry['method']] = method_counts.get(entry['method'], 0) + 1

        os_counts = {}
        for entry in data:
            os_counts[entry['os']] = os_counts.get(entry['os'], 0) + 1

        daily_counts = {}
        for date in dates:
            day = date.date()
            daily_counts[day] = daily_counts.get(day, 0) + 1

        plt.figure(figsize=(10, 10))

        plt.subplot(2, 2, 1)
        plt.bar(method_counts.keys(), method_counts.values())
        plt.yscale('log')
        plt.title('HTTP Method')
        plt.xlabel('HTTP Method')
        plt.ylabel('Requests (log scale)')
        plt.xticks(rotation=45)

        plt.subplot(2, 2, 2)
        plt.bar(os_counts.keys(), os_counts.values())
        plt.title('OS Distribution')
        plt.xlabel('Operating System')
        plt.ylabel('Requests')
        plt.xticks(rotation=45)

        plt.subplot(2, 2, 3)
        plt.bar(daily_counts.keys(), daily_counts.values())
        plt.title('Daily Requests')
        plt.xlabel('Date')
        plt.ylabel('Requests')
        plt.xticks(rotation=45)

        plt.subplot(2, 2, 4)
        plt.bar(list(size_counts.keys()), list(size_counts.values()), color='skyblue')
        plt.title('Status codes')
        plt.xlabel('Status')
        plt.ylabel('Requests')
        plt.xticks(rotation=45)

        plt.tight_layout()

        img = io.BytesIO()
        plt.tight_layout()
        plt.savefig(img, format='png', bbox_inches='tight')
        img.seek(0)
        plt.close()

        plot_url = base64.b64encode(img.getvalue()).decode()

        return render_template('duplicate/dashboard.html', plot_url=plot_url)
    else:
        return redirect(url_for('login'))

@app.route("/")
def index():
    return render_template("index.html")

@app.route("/login", methods=['GET', 'POST']) # <--- Hier maak je de url aan die je in je browser typt (of redirect)
def login():         # <--- Hier maak je de functie naam aan
    gebruikersnaam = None
    wachtwoord = None

    if request.method == 'POST':
        gebruikersnaam = request.form['gebruikersnaam']
        wachtwoord = request.form['wachtwoord']

        cnx = mysql.connector.connect(user='flask', password='flask', host='127.0.0.1', database='mydb')
        cursor = cnx.cursor()
        query = ("SELECT Role_ID FROM user WHERE gebruikersnaam = %s AND wachtwoord = %s")
        cursor.execute(query, (gebruikersnaam, wachtwoord))
        result = cursor.fetchone()
        cursor.close()
        cnx.close()

        if result:
            session['logged_in'] = True
            session['gebruikersnaam'] = gebruikersnaam
            session['Role_ID'] = result[0]

            if session['Role_ID'] == 2:
                return redirect(url_for('dashboard'))
            elif session['Role_ID'] == 1:
                return redirect(url_for('manager'))

    return render_template("duplicate/login.html") # <--- Hier geef je aan welke html pagina je wilt laten zien

@app.route('/logout')
def logout():
    cache.delete('dashboardcache')
    session.clear()
    return redirect(url_for('login'))

@app.route("/manager", methods=["GET", "POST"])
def manager():
    if request.method == "POST":
            gebruikersnaam = request.form['gebruikersnaam']
            wachtwoord = request.form['wachtwoord']
            role = request.form['role']

            cnx = mysql.connector.connect(user='flask', password='flask', host='127.0.0.1', database='mydb')
            cursor = cnx.cursor()
            query = ("INSERT INTO user (gebruikersnaam, wachtwoord, Role_ID) VALUES (%s, %s, %s)")
            cursor.execute(query, (gebruikersnaam, wachtwoord, role))
            cnx.commit()
            cursor.close()
            cnx.close()

    if session.get('Role_ID') == 1:
        return render_template("duplicate/manager.html")
    else:
        return redirect(url_for('login'))


if __name__ == '__main__':
    app.run(debug=True)

import csv
import mysql.connector

logfile = '../logs/dataset.csv'
BATCH_SIZE = 100000

rows = []
with open(logfile, newline='', encoding='utf-8') as csvfile:
    reader = csv.reader(csvfile, delimiter=';')
    next(reader)
    rows = list(reader)

try:
    db = mysql.connector.connect(
        host="127.0.0.1",
        user="flask",
        password="flask",
        database="accesslogs"
    )
    cursor = db.cursor()

    insert_query = """
    INSERT INTO dataset (data_id, ip, date, method, status, size, request, referer, user_agent)
    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
    """

    rowscount = len(rows)
    for i in range(0, rowscount, BATCH_SIZE):
        batch = rows[i:i + BATCH_SIZE]
        cursor.executemany(insert_query, batch)
        db.commit()

finally:
    if db.is_connected():
        cursor.close()
        db.close()

OOP

(Dit is hoe ik het zie/uitleg dus dit zal niet 100% correct zijn)

Encapsulation: Bundelen van Data

Inheritance Gebruik van een al bestaande class

Abstraction Issoleren van code van andere code

Polymorphism Methods die op alle objecten kunt gebruijken

Function: Een functie schrijf je meestal als je wilt dat de code een taak wil doen zoals bijvoorbeeld de code die de database cache checkt.