init

Bl0g/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10
+
+COPY requirements.txt /
+
+RUN pip3 install --no-cache-dir -r /requirements.txt
+
+COPY . /app
+VOLUME ["/data"]
+WORKDIR /data
+
+CMD ["python3", "/app/app.py"]

Bl0g/app.py

@@ -0,0 +1,385 @@
+import collections
+import datetime
+import hashlib
+import hmac
+import os
+import secrets
+from pathlib import Path
+from typing import Dict, Optional
+from uuid import uuid4
+
+import bcrypt
+from flask import (
+    Flask,
+    Response,
+    abort,
+    flash,
+    make_response,
+    redirect,
+    render_template,
+    request,
+    url_for,
+)
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.exc import IntegrityError
+from werkzeug.urls import url_decode
+
+storage_dir = Path.cwd()
+database_path = storage_dir / "database.db"
+sign_secret_path = storage_dir / "sign.key"
+flask_secret_path = storage_dir / "flask-secret.key"
+
+app = Flask(__name__)
+if flask_secret_path.exists():
+    app.config["SECRET_KEY"] = flask_secret_path.read_text()
+else:
+    temp = secrets.token_hex()
+    flask_secret_path.write_text(temp)
+    app.config["SECRET_KEY"] = temp
+
+app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{database_path}"
+app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+db = SQLAlchemy(app)
+
+UTC = datetime.timezone.utc
+
+def utcnow() -> datetime.datetime:
+    """Get the current time/date as a UTC timezone-aware datetime object."""
+    return datetime.datetime.now(UTC)
+
+
+@app.template_filter('as_utc')
+def as_utc(dattim: datetime.datetime) -> datetime.datetime:
+    if dattim.tzinfo == UTC:
+        return dattim
+    if dattim.tzinfo is None:
+        dattim = dattim.replace(tzinfo=UTC)
+    return dattim.astimezone(UTC)
+
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(), unique=True, nullable=False, index=True)
+    password_digest = db.Column(db.String(), nullable=False)
+    last_login = db.Column(db.DateTime(timezone=True), nullable=False)
+    created_at = db.Column(db.DateTime(timezone=True), nullable=False)
+    session_cookie = db.Column(db.String(), nullable=True, index=True)
+
+    comments = db.relationship("Comment", back_populates="author", lazy=True)
+
+
+class ContactRequest(db.Model):
+    uuid = db.Column(db.String(), primary_key=True, nullable=False)
+    title = db.Column(db.String(), nullable=False)
+    content = db.Column(db.String(), nullable=False)
+    created_at = db.Column(db.DateTime(timezone=True), nullable=False)
+
+
+class Post(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String(), nullable=False)
+    content = db.Column(db.String(), nullable=False)
+    date_posted = db.Column(db.Date(), nullable=False)
+
+    comments = db.relationship("Comment", back_populates="post", lazy=True)
+
+
+class Comment(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    post_id = db.Column(db.Integer, db.ForeignKey("post.id"), nullable=False)
+    author_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
+    content = db.Column(db.String(), nullable=False)
+    created_at = db.Column(db.DateTime(timezone=True), nullable=False)
+
+    post = db.relationship("Post", back_populates="comments", lazy=True)
+    author = db.relationship("User", back_populates="comments", lazy=True)
+
+    __table_args__ = (db.Index("comment_post_author_index", post_id, author_id),)
+
+
+def set_session_cookie(response: Response, user: User):
+    λ = hashlib.new("sha256")
+    λ.update(user.username.encode())
+    now = utcnow()
+    λ.update(str(int(now.timestamp())).encode())
+    cookie = λ.hexdigest()
+
+    user.session_cookie = cookie
+    user.last_login = now
+    response.set_cookie("sessionID", cookie)
+    db.session.commit()
+
+
+def get_user() -> Optional[User]:
+    sess_id = request.cookies.get("sessionID")
+    return db.session.query(User).filter(User.session_cookie == sess_id).first()
+
+
+@app.context_processor
+def inject_current_user():
+    # Inject current_user variable into all templates
+    return {"current_user": get_user()}
+
+
+@app.route("/")
+def index():
+    posts = db.session.query(Post).order_by(Post.id).all()
+
+    post_comment_usernames: Dict[int, str] = collections.defaultdict(list)
+    for post_id, username in (
+        db.session.query(Post.id, User.username)
+        .filter(Comment.author_id == User.id)
+        .filter(Comment.post_id == Post.id)
+        .distinct(User.username)
+    ):
+        post_comment_usernames[post_id].append(username)
+
+    current_user = get_user()
+
+    post_my_comments: Dict[int, str] = collections.defaultdict(list)
+    if current_user:
+        for post_id, content in (
+            db.session.query(Post.id, Comment.content)
+            .filter(Comment.post_id == Post.id)
+            .filter(Comment.author_id == current_user.id)
+        ):
+            post_my_comments[post_id].append(content)
+
+    return render_template(
+        "index.html",
+        posts=posts,
+        post_comment_usernames=post_comment_usernames,
+        post_my_comments=post_my_comments,
+    )
+
+
+@app.route("/register", methods=["GET", "POST"])
+def register():
+    if request.method == "POST":
+        username = request.form["username"]
+        password = request.form["password"]
+
+        if username.isspace() or not username:
+            flash("username can't be empty")
+            return render_template("register.html")
+
+        if not username.isalnum():
+            flash("usernames can only consist of alphanumeric symbols")
+            return render_template("register.html")
+
+        if len(username) > 50:
+            flash("usernames can't be longer than 50 characters")
+            return render_template("register.html")
+
+        password_digest = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
+        now = utcnow()
+        user = User(username=username, password_digest=password_digest, last_login=now, created_at=now)
+        try:
+            db.session.add(user)
+            db.session.commit()
+        except IntegrityError:
+            db.session.rollback()
+            flash("username already in use", "error")
+            return render_template("register.html"), 409
+        else:
+            response = redirect("/")
+            set_session_cookie(response, user)
+            return response
+
+    return render_template("register.html")
+
+
+@app.route("/login", methods=["GET", "POST"])
+def login():
+    if request.method == "POST":
+        username = request.form["username"]
+        password = request.form["password"]
+
+        user = db.session.query(User).filter(User.username == username).first()
+        if user is not None and bcrypt.checkpw(password.encode(), user.password_digest):
+            response = redirect("/")
+            set_session_cookie(response, user)
+            return response
+
+        flash("wrong username or password")
+
+    return render_template("login.html")
+
+
+@app.route("/logout", methods=["POST"])
+def logout():
+    resp = make_response(redirect("/"))
+    resp.set_cookie("sessionID", "", expires=0)
+    return resp
+
+
+@app.route("/user/<string:username>", methods=["GET"])
+def user(username: str):
+    user = db.session.query(User).filter(User.username == username).first()
+    if user is None:
+        abort(404)
+
+    flash("This page is still WIP!")
+    return render_template("user.html", user=user)
+
+
+@app.route("/comment", methods=["POST"])
+def comment():
+    user = get_user()
+    if user is None:
+        flash("You need to login to comment.")
+        return redirect("/"), 401
+
+    content = request.form["content"]
+    post_id = request.form["post_id"]
+    post = db.session.query(Post).filter(Post.id == int(post_id)).first()
+    if post is None:
+        abort(404)
+
+    db.session.add(
+        Comment(
+            post=post,
+            author=user,
+            content=content,
+            created_at=utcnow(),
+        )
+    )
+    db.session.commit()
+    return redirect("/")
+
+
+j = 16
+if sign_secret_path.exists():
+    sign_secret = sign_secret_path.read_bytes()
+else:
+    sign_secret = secrets.token_bytes(j)
+    sign_secret_path.write_bytes(sign_secret)
+assert len(sign_secret) == j
+
+
+def sign(payload: bytes) -> bytes:
+    ϳ = len(payload)
+    base = sign_secret + j.to_bytes(4, byteorder="big") + payload
+    h = hashlib.new("md5")
+    h.update(base)
+    return h.digest()
+
+
+@app.route("/contact", methods=["GET", "POST"])
+def contact():
+    if request.method == "POST":
+        req = ContactRequest(
+            uuid=str(uuid4()),
+            title=request.form["title"],
+            content=request.form["content"],
+            created_at=datetime.datetime.now(datetime.timezone.utc)
+        )
+        db.session.add(req)
+        db.session.commit()
+
+        sig = sign(f"uuid={req.uuid}".encode())
+        return redirect(url_for("contact_view", sig=sig.hex(), uuid=req.uuid))
+
+    return render_template("contact.html")
+
+
+@app.route("/contact_list")
+def contact_list():
+    min_created = utcnow() - datetime.timedelta(minutes=30)
+    recent_requests = (
+        db.session.query(ContactRequest)
+        .filter(ContactRequest.created_at >= min_created)
+        .order_by(ContactRequest.created_at.desc())
+        .all()
+    )
+    return render_template("contact_list.html", recent_requests=recent_requests)
+
+
+@app.route("/contact_view")
+def contact_view():
+    # verify signature
+    uuid = None
+    sig = None
+    sigbase = []
+    ud = url_decode(request.query_string, charset=None)
+    for k, v in ud.items(True):
+        if k == b"sig":
+            try:
+                sig = bytes.fromhex(v.decode())
+            except ValueError:
+                sig = b""
+            continue
+        if k == b"uuid":
+            uuid = v
+        sigbase.append(k + b"=" + v)
+
+    if uuid is None:
+        abort(400)
+
+    if sig is None:
+        return render_template("contact_view_form.html", uuid=uuid.decode())
+
+    sigcheck = sign(b"&".join(sigbase))
+    if not hmac.compare_digest(sig, sigcheck):
+        flash("Invalid access key")
+        return render_template("contact_view_form.html", uuid=uuid.decode()), 403
+
+    creq = (
+        db.session.query(ContactRequest)
+        .filter(ContactRequest.uuid == uuid.decode())
+        .first()
+    )
+    if creq is None:
+        abort(404)
+
+    created_at = as_utc(creq.created_at)
+    now = utcnow()
+    if now - created_at >= datetime.timedelta(minutes=15):
+        response = "Thanks for the feedback!"
+    else:
+        response = ""
+
+    return render_template(
+        "contact_view.html",
+        contact_request=creq,
+        response=response,
+        sig=sig.hex(),
+    )
+
+
+def main():
+    db.create_all()
+
+    if db.session.query(Post).count() == 0:
+        db.session.add(
+            Post(
+                id=0,
+                title="My First Blog!",
+                content="I programmed it myself! You can even comment (but i haven't implemented approving them yet)!",
+                date_posted=datetime.date(2022, 1, 1),
+            )
+        )
+        db.session.add(
+            Post(
+                id=1,
+                title="Suggestions",
+                content="Added a feature to submit suggestions for the blog!",
+                date_posted=datetime.date(2022, 1, 2),
+            )
+        )
+        db.session.add(
+            Post(
+                id=2,
+                title="Too Early",
+                content="I may have made this site public too early...",
+                date_posted=datetime.date(2022, 1, 4),
+            )
+        )
+        db.session.commit()
+
+    port = int(os.environ.get("APP_PORT", 51131))
+    app.run(debug=False, host="0.0.0.0", port=port)
+
+
+if __name__ == "__main__":
+    main()

Bl0g/docker-compose.yml

@@ -0,0 +1,12 @@
+version: '2'
+services:
+    service:
+        build: .
+        restart: always
+        volumes:
+          - data:/data:rw
+        ports:
+          - 51131:51131
+
+volumes:
+  data:

Bl0g/requirements.txt

@@ -0,0 +1,3 @@
+Flask==2.0.2
+bcrypt==3.2.0
+Flask-SQLAlchemy==2.5.1

Bl0g/templates/base.html

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html lang="en" class="h-100">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{% block title %}{% endblock %}</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
+    <style>
+      main > .container {
+        padding: 60px 15px 0;
+      }
+      body {
+        font-family: monospace;
+        font-size: 20px;
+      }
+      .post {
+        background-color: lightblue;
+        margin-bottom: 15px;
+        padding: 10px;
+      }
+      nav li {
+        display: inline;
+      }
+      nav ul {
+        padding: 0;
+        list-style-type: none;
+      }
+      .date {
+        font-size: 14px;
+      }
+      .unapproved {
+        font-size: 14px;
+      }
+      .comment {
+        font-size: 16px;
+      }
+      h2 {
+        margin-top: 5px;
+      }
+      .footer {
+        font-size: 14px;
+      }
+      a {
+        color: darkgreen;
+        text-decoration: none;
+      }
+      a:hover {
+        text-decoration: underline;
+      }
+      .content {
+        padding: 3px;
+        background-color: rgb(139, 203, 224);
+      }
+    </style>
+  </head>
+  <body class="d-flex flex-column h-100">
+    <header>
+      <nav class="navbar navbar-expand-md navbar-light fixed-top bg-light">
+        <div class="container-fluid">
+          <a class="navbar-brand" href="/">My first Blog</a>
+          <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarCollapse" aria-controls="navbarCollapse" aria-expanded="false" aria-label="Toggle navigation">
+            <span class="navbar-toggler-icon"></span>
+          </button>
+          <div class="collapse navbar-collapse" id="navbarCollapse">
+            <ul class="navbar-nav me-auto mb-2 mb-md-0">
+              <li class="nav-item">
+                <a class="nav-link active" aria-current="page" href="/">Home</a>
+              </li>
+              <li class="nav-item">
+                <a class="nav-link" href="/contact">Contact</a>
+              </li>
+            </ul>
+            <div class="d-flex">
+              {% if current_user %}
+                <form method="POST" action="/logout">
+                  <button class="btn btn-outline-success" type="submit">Logout</a>
+                </form>
+              {% else %}
+                <a class="btn btn-outline-success me-1" href="/register">Register</a>
+                <a class="btn btn-success" href="/login">Login</a>
+              {% endif %}
+            </div>
+          </div>
+        </div>
+      </nav>
+    </header>
+      
+    <main class="flex-shrink-0">
+      <div class="container">
+        {% with messages = get_flashed_messages() %}
+          {% for message in messages %}
+            <div class="alert alert-warning" role="alert">
+              {{ message }}
+            </div>              
+          {% endfor %}
+        {% endwith %}
+
+        {% block body %}
+        {% endblock %}
+      </div>
+    </main>
+      
+    <footer class="footer mt-auto py-3 bg-light">
+      <div class="container">
+        <span class="text-muted">© 2021 ADCS</span>
+      </div>
+    </footer>
+  </body>
+</html>

Bl0g/templates/contact.html

@@ -0,0 +1,26 @@
+{% extends "base.html" %}
+{% block title %}Contact{% endblock %}
+
+{% block body %}
+
+<h1 class="mt-5">Contact</h1>
+<form method="POST">
+    <div class="mb-3">
+      <label for="title" class="form-label">Title</label>
+      <input type="text" class="form-control" id="title" name="title">
+    </div>
+    <div class="mb-3">
+      <label for="content" class="form-label">Content</label>
+      <textarea class="form-control" id="content" name="content" row="5"></textarea>
+    </div>
+
+    <button type="submit" class="btn btn-primary">Submit</button>
+
+    <div class="form-text">Note: only the site's author and you will be able to see the message after it's been sent.</div>
+</form>
+
+<hr>
+
+<a href="{{ url_for('contact_list') }}">View recent contact requests</a>
+
+{% endblock %}

Bl0g/templates/contact_list.html

@@ -0,0 +1,18 @@
+{% extends "base.html" %}
+{% block title %}Contact List{% endblock %}
+
+{% block body %}
+
+<h1 class="mt-5">Recent Contact Requests</h1>
+
+<ul>
+    {% for creq in recent_requests %}
+        <li>
+            <a href="{{ url_for('contact_view', uuid=creq.uuid) }}">
+                {{ creq.uuid }}
+            </a> at {{ creq.created_at.isoformat() }}
+        </li>
+    {% endfor %}
+</ul>
+
+{% endblock %}

Bl0g/templates/contact_view.html

@@ -0,0 +1,23 @@
+{% extends "base.html" %}
+{% block title %}View Contact Request{% endblock %}
+
+{% block body %}
+
+<h1 class="mt-5">See status for <span id="req-title">{{ contact_request.title }}</span></h1>
+<p id="req-content">
+    {{ contact_request.content }}
+</p>
+
+<hr></hr>
+
+{% if not response %}
+    Status: Not answered yet
+{% else %}
+    Response: {{ response }}
+{% endif %}
+
+<hr class="mt-5"></hr>
+
+Your Access Key: {{ sig }}
+
+{% endblock %}

Bl0g/templates/contact_view_form.html

@@ -0,0 +1,18 @@
+{% extends "base.html" %}
+{% block title %}Access Contact Request{% endblock %}
+
+{% block body %}
+
+<h1 class="mt-5">Access contact request {{ uuid }}</h1>
+
+<form method="get">
+    <input value="{{ uuid }}" name="uuid" hidden>
+    <div class="mb-2">
+        <label for="sig" class="form-label">Access Key</label>
+        <input type="text" class="form-control" id="sig" name="sig">
+    </div>
+
+    <button type="submit" class="btn btn-primary">Open</button>
+</form>
+
+{% endblock %}

Bl0g/templates/index.html

@@ -0,0 +1,39 @@
+{% extends "base.html" %}
+{% block title %}Home{% endblock %}
+{% block body %}
+
+{% for post in posts %}
+    <div class="post" data-post-id="{{ post.id }}">
+        <h2>{{ post.title }}</h2>
+        <p class="date">Date: {{ post.date_posted }}</p>
+        <p class="content">{{ post.content }}</p>
+        {% set usernames = post_comment_usernames[post.id] %}
+        {% if post.comments %}
+            <p class="unapproved">Unapproved comments from:
+                {% for username in usernames %}
+                    <a class="unapproved-user" href={{ url_for("user", username=username) }}>{{ username }}</a>
+                {% endfor %}
+            </p>
+        {% endif %}
+        {% if current_user %}
+            {% set my_comments = post_my_comments[post.id] %}
+            {% if my_comments %}
+                <p class="comment">
+                    Your comment:
+                    {% for content in my_comments %}
+                        <br><small class="user">{{ content }}</small>
+                    {% endfor %}
+                </p>
+            {% endif %}
+            <form method="POST" action="/comment">
+                <textarea name="content" rows=3 cols=40 type="longtext"></textarea>
+                <input name="post_id" value="{{ post.id }}" hidden><br/>
+                <button type="submit">Submit</button>
+            </form>
+        {% else %}
+            <small>Register to comment on this post.</small>
+        {% endif %}
+    </div>
+{% endfor %}
+
+{% endblock %}

Bl0g/templates/login.html

@@ -0,0 +1,19 @@
+{% extends "base.html" %}
+{% block title %}Login{% endblock %}
+{% block body %}
+
+<h1 class="mt-5">Login</h1>
+<form method="POST">
+    <div class="mb-3">
+      <label for="username" class="form-label">Username</label>
+      <input type="text" class="form-control" id="username" name="username">
+    </div>
+    <div class="mb-3">
+      <label for="password" class="form-label">Password</label>
+      <input type="password" class="form-control" id="password" name="password">
+    </div>
+
+    <button type="submit" class="btn btn-primary">Login</button>
+</form>
+
+{% endblock %}

Bl0g/templates/register.html

@@ -0,0 +1,17 @@
+{% extends "base.html" %}
+{% block title %}Register{% endblock %}
+{% block body %}
+<h1 class="mt-5">Register</h1>
+<form method="POST">
+    <div class="mb-3">
+      <label for="username" class="form-label">Username</label>
+      <input type="text" class="form-control" id="username" name="username">
+    </div>
+    <div class="mb-3">
+      <label for="password" class="form-label">Password</label>
+      <input type="password" class="form-control" id="password" name="password">
+    </div>
+
+    <button type="submit" class="btn btn-primary">Register</button>
+</form>
+{% endblock %}

Bl0g/templates/user.html

@@ -0,0 +1,15 @@
+{% extends "base.html" %}
+{% block title %}User{% endblock %}
+{% block body %}
+<h1 class="mt-3">{{ user.username }}</h1>
+<p>
+    Last login: 
+    <span id="last-login">{{ (user.last_login | as_utc).isoformat() }}</span>
+</p>
+<p>
+    Registered:
+    <span id="registered">{{ (user.created_at | as_utc).isoformat() }}</span>
+</p>
+<p>Number of Approved Comments: 0</p>
+
+{% endblock %}

GUEST_BOOK/app/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.15)
+project(root)
+set(CMAKE_CXX_STANDARD 20)
+
+include(${CMAKE_BINARY_DIR}/conan_paths.cmake)
+enable_testing()
+
+add_subdirectory(app)
+add_subdirectory(lib)
+

GUEST_BOOK/app/Dockerfile

@@ -0,0 +1,49 @@
+# build stage
+FROM conanio/clang13-ubuntu16.04 as build-stage
+
+USER 0
+
+RUN mkdir -p /opt/build
+RUN chown -R conan /opt
+
+USER conan
+
+WORKDIR /opt
+
+COPY conan_config conan_config
+RUN conan config install conan_config
+RUN conan config install
+
+COPY conanfile.txt  ./
+WORKDIR /opt/build
+RUN conan install .. --build=missing --profile Guestbook24
+
+WORKDIR /opt/
+COPY CMakeLists.txt ./
+
+COPY app app
+COPY lib lib
+COPY data data
+
+WORKDIR /opt/build
+RUN cmake ..
+RUN cmake --build . -j 8
+# RUN ctest .
+
+# run stage
+FROM ubuntu:21.10 as production-stage
+
+RUN apt update
+RUN apt-get install -y socat libunwind-12
+RUN useradd -ms /bin/bash ctf
+RUN ln -s /lib/llvm-12/lib/libunwind.so.1 /lib/libllvm-unwind.so.1
+
+WORKDIR /home/ctf
+
+COPY --from=build-stage /opt/build/app/Application Application
+COPY data data
+COPY run.sh run.sh
+
+RUN chmod +x ./run.sh
+
+CMD socat tcp-listen:4444,reuseaddr,fork exec:./run.sh,rawer,pty,echo=0,su=ctf

GUEST_BOOK/app/app/CMakeLists.txt

@@ -0,0 +1,9 @@
+project(Application)
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_executable(Application src/main.cpp)
+target_link_libraries(Application PRIVATE ApplicationLib)
+
+file(COPY ${CMAKE_SOURCE_DIR}/data
+        DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)

GUEST_BOOK/app/app/src/main.cpp

@@ -0,0 +1,8 @@
+#include "Lib.h"
+#include <iostream>
+
+
+int main() {
+    Application app{std::cin, std::cout};
+    app.Run();
+}

GUEST_BOOK/app/conan_config/profiles/Guestbook24

@@ -0,0 +1,13 @@
+[settings]
+os=Linux
+os_build=Linux
+arch=x86_64
+arch_build=x86_64
+compiler=clang
+compiler.version=13
+compiler.libcxx=libstdc++11
+build_type=Release
+[options]
+[conf]
+[build_requires]
+[env]

GUEST_BOOK/app/conan_config/settings.yml

@@ -0,0 +1,98 @@
+
+# Only for cross building, 'os_build/arch_build' is the system that runs Conan
+os_build: [Windows, WindowsStore, Linux, Macos, FreeBSD, SunOS, AIX]
+arch_build: [x86, x86_64, ppc32be, ppc32, ppc64le, ppc64, armv5el, armv5hf, armv6, armv7, armv7hf, armv7s, armv7k, armv8, armv8_32, armv8.3, sparc, sparcv9, mips, mips64, avr, s390, s390x, sh4le]
+
+# Only for building cross compilation tools, 'os_target/arch_target' is the system for
+# which the tools generate code
+os_target: [Windows, Linux, Macos, Android, iOS, watchOS, tvOS, FreeBSD, SunOS, AIX, Arduino, Neutrino]
+arch_target: [x86, x86_64, ppc32be, ppc32, ppc64le, ppc64, armv5el, armv5hf, armv6, armv7, armv7hf, armv7s, armv7k, armv8, armv8_32, armv8.3, sparc, sparcv9, mips, mips64, avr, s390, s390x, asm.js, wasm, sh4le]
+
+# Rest of the settings are "host" settings:
+# - For native building/cross building: Where the library/program will run.
+# - For building cross compilation tools: Where the cross compiler will run.
+os:
+    Windows:
+        subsystem: [None, cygwin, msys, msys2, wsl]
+    WindowsStore:
+        version: ["8.1", "10.0"]
+    WindowsCE:
+        platform: ANY
+        version: ["5.0", "6.0", "7.0", "8.0"]
+    Linux:
+    Macos:
+        version: [None, "10.6", "10.7", "10.8", "10.9", "10.10", "10.11", "10.12", "10.13", "10.14", "10.15", "11.0"]
+    Android:
+        api_level: ANY
+    iOS:
+        version: ["7.0", "7.1", "8.0", "8.1", "8.2", "8.3", "9.0", "9.1", "9.2", "9.3", "10.0", "10.1", "10.2", "10.3", "11.0", "11.1", "11.2", "11.3", "11.4", "12.0", "12.1", "12.2", "12.3", "12.4", "13.0", "13.1", "13.2", "13.3", "13.4", "13.5", "13.6"]
+    watchOS:
+        version: ["4.0", "4.1", "4.2", "4.3", "5.0", "5.1", "5.2", "5.3", "6.0", "6.1"]
+    tvOS:
+        version: ["11.0", "11.1", "11.2", "11.3", "11.4", "12.0", "12.1", "12.2", "12.3", "12.4", "13.0"]
+    FreeBSD:
+    SunOS:
+    AIX:
+    Arduino:
+        board: ANY
+    Emscripten:
+    Neutrino:
+        version: ["6.4", "6.5", "6.6", "7.0", "7.1"]
+arch: [x86, x86_64, ppc32be, ppc32, ppc64le, ppc64, armv4, armv4i, armv5el, armv5hf, armv6, armv7, armv7hf, armv7s, armv7k, armv8, armv8_32, armv8.3, sparc, sparcv9, mips, mips64, avr, s390, s390x, asm.js, wasm, sh4le]
+compiler:
+    sun-cc:
+        version: ["5.10", "5.11", "5.12", "5.13", "5.14", "5.15"]
+        threads: [None, posix]
+        libcxx: [libCstd, libstdcxx, libstlport, libstdc++]
+    gcc: &gcc
+        version: ["4.1", "4.4", "4.5", "4.6", "4.7", "4.8", "4.9",
+                  "5", "5.1", "5.2", "5.3", "5.4", "5.5",
+                  "6", "6.1", "6.2", "6.3", "6.4", "6.5",
+                  "7", "7.1", "7.2", "7.3", "7.4", "7.5",
+                  "8", "8.1", "8.2", "8.3", "8.4",
+                  "9", "9.1", "9.2", "9.3",
+                  "10", "10.1"]
+        libcxx: [libstdc++, libstdc++11]
+        threads: [None, posix, win32] #  Windows MinGW
+        exception: [None, dwarf2, sjlj, seh] # Windows MinGW
+        cppstd: [None, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17, 20, gnu20]
+    Visual Studio: &visual_studio
+        runtime: [MD, MT, MTd, MDd]
+        version: ["8", "9", "10", "11", "12", "14", "15", "16"]
+        toolset: [None, v90, v100, v110, v110_xp, v120, v120_xp,
+                  v140, v140_xp, v140_clang_c2, LLVM-vs2012, LLVM-vs2012_xp,
+                  LLVM-vs2013, LLVM-vs2013_xp, LLVM-vs2014, LLVM-vs2014_xp,
+                  LLVM-vs2017, LLVM-vs2017_xp, v141, v141_xp, v141_clang_c2, v142,
+                  llvm, ClangCL]
+        cppstd: [None, 14, 17, 20]
+    clang:
+        version: ["3.3", "3.4", "3.5", "3.6", "3.7", "3.8", "3.9", "4.0",
+                  "5.0", "6.0", "7.0", "7.1",
+                  "8", "9", "10", "11","12","13"]
+        libcxx: [None, libstdc++, libstdc++11, libc++, c++_shared, c++_static]
+        cppstd: [None, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17, 20, gnu20]
+        runtime: [None, MD, MT, MTd, MDd]
+    apple-clang: &apple_clang
+        version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.3", "8.0", "8.1", "9.0", "9.1", "10.0", "11.0", "12.0"]
+        libcxx: [libstdc++, libc++]
+        cppstd: [None, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17, 20, gnu20]
+    intel:
+        version: ["11", "12", "13", "14", "15", "16", "17", "18", "19", "19.1"]
+        base:
+            gcc:
+                <<: *gcc
+                threads: [None]
+                exception: [None]
+            Visual Studio:
+                <<: *visual_studio
+            apple-clang:
+                <<: *apple_clang
+    qcc:
+        version: ["4.4", "5.4", "8.3"]
+        libcxx: [cxx, gpp, cpp, cpp-ne, accp, acpp-ne, ecpp, ecpp-ne]
+        cppstd: [None, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17]
+
+build_type: [None, Debug, Release, RelWithDebInfo, MinSizeRel]
+
+
+cppstd: [None, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17, 20, gnu20]  # Deprecated, use compiler.cppstd

GUEST_BOOK/app/conanfile.txt

@@ -0,0 +1,12 @@
+[requires]
+spdlog/1.8.1
+catch2/2.13.6
+abseil/20211102.0
+libpqxx/7.5.2
+cryptopp/8.5.0
+
+[generators]
+cmake_find_package
+cmake_paths
+
+

GUEST_BOOK/app/data/drop.sql

@@ -0,0 +1,7 @@
+drop table if exists users;
+drop table if exists user_messages;
+drop table if exists message;
+drop table if exists quote;
+drop SEQUENCE if exists UsersId;
+drop SEQUENCE if exists MessageId;
+drop SEQUENCE if exists QuoteId;

GUEST_BOOK/app/data/init.sql

@@ -0,0 +1,36 @@
+create sequence if not exists usersid;
+create sequence if not exists messageid;
+create sequence if not exists quoteid;
+
+create table if not exists users
+(
+    id                          integer not null default nextval('usersid'),
+    username                    bytea   not null unique,
+    password                    bytea   not null,
+    firstname                   bytea   not null default '',
+    lastname                    bytea   not null default '',
+    top_secret_user_information bytea   not null default ''
+);
+
+create table if not exists user_messages
+(
+    username   bytea not null,
+    message_id bytea not null
+);
+
+create table if not exists message
+(
+    db_id   integer not null default nextval('messageid'),
+    id      bytea   not null,
+    title   bytea   not null,
+    message bytea            default '',
+    public  boolean          default true
+);
+
+create table if not exists quote
+(
+    db_id      integer not null        default nextval('quoteid'),
+    id         bytea   not null,
+    message_id bytea   not null,
+    quote      bytea   not null unique default ''
+);

GUEST_BOOK/app/lib/CMakeLists.txt

@@ -0,0 +1,25 @@
+project(ApplicationLib VERSION 0.0.1 DESCRIPTION "")
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_library(ApplicationLib STATIC src/Application.cpp src/Logger.cpp src/Commands.cpp src/LoadMyEntriesCommand.cpp src/RegisterCommand.cpp src/PostCommand.cpp src/LoadEntriesCommand.cpp src/QuoteCommand.cpp src/LoginCommand.cpp src/EditCommand.cpp src/PostCommand.cpp src/ViewCommand.cpp src/Database.cpp src/Util.cpp src/DbModel.cpp)
+
+find_package(spdlog REQUIRED)
+find_package(absl REQUIRED)
+find_package(libpqxx REQUIRED)
+find_package(cryptopp REQUIRED)
+target_link_libraries(ApplicationLib PUBLIC spdlog::spdlog)
+target_link_libraries(ApplicationLib PUBLIC absl::absl)
+target_link_libraries(ApplicationLib PUBLIC libpqxx::libpqxx)
+target_link_libraries(ApplicationLib PUBLIC cryptopp::cryptopp)
+
+
+set_target_properties(ApplicationLib PROPERTIES VERSION ${PROJECT_VERSION})
+set_target_properties(ApplicationLib PROPERTIES SOVERSION 0)
+set_target_properties(ApplicationLib PROPERTIES PUBLIC_HEADER include/Lib.h)
+
+# https://github.com/pabloariasal/modern-cmake-sample/blob/master/libjsonutils/CMakeLists.txt
+target_include_directories(ApplicationLib
+        PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+)

GUEST_BOOK/app/lib/include/Application.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <absl/strings/str_split.h>
+#include <functional>
+#include <istream>
+#include <ostream>
+#include <vector>
+
+class Application {
+private:
+    std::basic_istream<char> &istream;
+    std::basic_ostream<char> &ostream;
+
+public:
+    explicit Application(std::basic_istream<char> &istream, std::basic_ostream<char> &ostream) : istream{istream}, ostream{ostream} {}
+
+    void Run() noexcept;
+    Application& Drop() noexcept;
+};

GUEST_BOOK/app/lib/include/Command.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "Context.h"
+#include <string>
+
+class Command {
+public:
+    Command() = default;
+    virtual ~Command() = default;
+    virtual void Execute(Context&, std::basic_ostream<char>&, std::string) const = 0;
+};

GUEST_BOOK/app/lib/include/Commands.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <Command.h>
+#include <functional>
+#include <memory>
+#include <string>
+
+
+class Commands {
+    std::unordered_map<std::string, std::function<std::shared_ptr<Command>()>> commands;
+
+public:
+    void Execute(Context& c, std::basic_ostream<char>& s, const std::string &line);
+
+    static Commands *Get();
+
+    void Register(const std::string &string, const std::function<std::shared_ptr<Command>()> &);
+};

GUEST_BOOK/app/lib/include/Context.h

@@ -0,0 +1,6 @@
+#pragma once
+#include <string>
+class Context {
+public:
+    std::string user{};
+};

GUEST_BOOK/app/lib/include/DBHelper.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <pqxx/connection>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <variant>
+
+
+
+using FieldType = std::variant<std::string,bool>;
+
+template<typename T>
+concept Insertable = requires(T a) {
+    { a.GetTableName() } -> std::convertible_to<std::string>;
+    { T::GetTableName() } -> std::convertible_to<std::string>;
+    { a.GetFields() } -> std::convertible_to<std::unordered_map<std::string, FieldType>>;
+};
+
+template<typename T>
+concept Queryable = requires(T a, pqxx::result result) {
+    { a.GetTableName() } -> std::convertible_to<std::string>;
+    { T::GetTableName() } -> std::convertible_to<std::string>;
+    { a.GetFields() } -> std::convertible_to<std::unordered_map<std::string, FieldType>>;
+    { T::FromResult(result) } -> std::convertible_to<std::vector<T>>;
+};
+
+#define TableName(X) \
+    static std::string GetTableName() { return #X; }
+
+
+#define Fields(...)                                            \
+    std::unordered_map<std::string, FieldType> GetFields() { \
+        return {__VA_ARGS__};                                  \
+    }
+
+
+#define Field(X, Y) \
+    { #X, Y }

GUEST_BOOK/app/lib/include/Database.h

@@ -0,0 +1,258 @@
+#pragma once
+
+#include "DBHelper.h"
+#include "Logger.h"
+#include <absl/strings/str_cat.h>
+#include <absl/strings/str_join.h>
+#include <functional>
+#include <iostream>
+#include <libpq-fe.h>
+#include <memory>
+#include <pqxx/pqxx>
+#include <string>
+#include <utility>
+
+class Condition {
+private:
+    using value_t = std::variant<pqxx::binarystring, std::vector<pqxx::binarystring>, bool>;
+    explicit Condition(std::string condition, std::string field, value_t value) : condition{std::move(condition)}, field{std::move(field)}, value{std::move(value)} {};
+    std::string condition;
+    std::string field;
+    value_t value;
+
+public:
+    static Condition Eq(const std::string &field, const std::string &value) {
+        return Condition{"{} = ${}", field, pqxx::binarystring(value)};
+    }
+
+    static Condition In(const std::string &field, const std::vector<std::string> &values) {
+        std::vector<pqxx::binarystring> vector;
+        std::transform(values.begin(), values.end(), std::back_inserter(vector), [](auto &v) {
+            return pqxx::binarystring(v);
+        });
+
+        return Condition{"{} = ANY(${})", field, vector};
+    }
+
+    std::string ToString(int i) {
+        return fmt::format(condition, field, i + 1);
+    }
+
+    value_t &GetParam() {
+        return value;
+    }
+
+    const std::string &GetField() {
+        return field;
+    }
+};
+
+class Updates {
+private:
+    explicit Updates(std::string field, std::string value) : field{std::move(field)}, value{std::move(value)} {};
+    std::string field;
+    std::string value;
+
+public:
+    static Updates Set(const std::string &field, const std::string &value) {
+        return Updates{field, value};
+    }
+
+    std::string ToString(int i) {
+        return fmt::format("{} = ${}", field, i + 1);
+    }
+
+    std::string GetParam() {
+        return value;
+    }
+
+    const std::string &GetField() {
+        return field;
+    }
+};
+
+
+class Database {
+private:
+    explicit Database(pqxx::connection connection);
+    static Database Create();
+    pqxx::connection connection;
+
+public:
+    static Database &Get();
+    template<Insertable T>
+    void Insert(T insertable) {
+        auto fields = insertable.GetFields();
+
+        pqxx::work w(connection);
+
+        std::string names = "";
+        std::string valuesPlaceholder = "";
+        pqxx::params values;
+        int i = 0;
+        for (auto &[fieldName, value] : fields) {
+            absl::StrAppend(&names, fieldName, ",");
+            absl::StrAppend(&valuesPlaceholder, "$", i + 1, ",");
+
+            std::visit([&values, &w](auto a) {
+                using U = std::decay_t<decltype(a)>;
+                if constexpr (std::is_same<U, std::string>()) {
+                    values.append(w.esc_raw(a));
+                } else if constexpr (std::is_same<U, bool>()) {
+                    values.append(std::to_string(a));
+                } else {
+                    values.append(a);
+                }
+            },
+                       value);
+
+            i++;
+        }
+        names.resize(names.size() - 1);
+        valuesPlaceholder.resize(valuesPlaceholder.size() - 1);
+
+        auto command = fmt::format("INSERT INTO {}({}) VALUES({})", insertable.GetTableName(), names, valuesPlaceholder);
+        console->info("{}", command);
+
+
+        //statement template
+        connection.prepare("", command);
+        //invocation as in varible binding
+        pqxx::result r = w.exec_prepared("", values);
+
+        w.commit();
+    }
+
+
+    template<Queryable T>
+    std::vector<T> Query(std::vector<Condition> conditions) {
+        pqxx::work w(connection);
+        auto command = fmt::format("SELECT * FROM {}", T::GetTableName());
+        pqxx::params values;
+        if (conditions.size() > 0) {
+            absl::StrAppend(&command, " WHERE ", conditions.at(0).ToString(0));
+            auto &param = conditions.at(0).GetParam();
+            std::visit([&values, &w](auto a) {
+                using U = std::decay_t<decltype(a)>;
+                if constexpr (std::is_same<U, pqxx::binarystring>()) {
+                    values.append(w.esc_raw(a.data(), a.size()));
+                } else {
+                    values.append(a);
+                }
+            },
+                       param);
+        }
+
+        for (int i = 1; i < conditions.size(); ++i) {
+            absl::StrAppend(&command, " AND ", conditions.at(i).ToString(i));
+            auto &param = conditions.at(i).GetParam();
+
+            std::visit([&values, &w](auto a) {
+                using U = std::decay_t<decltype(a)>;
+                if constexpr (std::is_same<U, pqxx::binarystring>()) {
+                    values.append(w.esc_raw(a.data(), a.size()));
+                } else {
+                    values.append(a);
+                }
+            },
+                       param);
+        }
+        console->info("{}", command);
+
+
+        connection.prepare("", command);
+        pqxx::result r = w.exec_prepared("", values);
+
+        w.commit();
+
+        return T::FromResult(r);
+    }
+
+
+    pqxx::result QueryResult(const std::string &command, const std::vector<std::string> &params) {
+        pqxx::work w(connection);
+
+        pqxx::params values;
+        for (auto &param : params) {
+            values.append(param);
+            //            std::visit([&values, &w](auto a) {
+            //                using U = std::decay_t<decltype(a)>;
+            //                if constexpr (std::is_same<U, pqxx::binarystring>()) {
+            //                    values.append(w.esc_raw(a.data(), a.size()));
+            //                } else {
+            //                    values.append(a);
+            //                }
+            //            },
+            //                       param);
+        }
+        console->info("{}", command);
+
+        connection.prepare("", command);
+        pqxx::result r = w.exec_prepared("", values);
+
+        w.commit();
+
+        return r;
+    }
+
+
+    std::vector<std::unordered_map<std::string, std::string>> Query(const std::string &command, const std::vector<std::string> &params) {
+        auto r = QueryResult(command, params);
+        std::vector<std::unordered_map<std::string, std::string>> v;
+        for (auto const &row : r) {
+            auto &map = v.emplace_back();
+            for (int i = 0; i < row.size(); i++) {
+
+                if(r.column_type(i) == 17) {
+                    map[r.column_name(i)] = row.at(i).as<pqxx::binarystring>().str();
+                } else {
+                    map[r.column_name(i)] = row.at(i).as<std::string>();
+                }
+
+            }
+        }
+        return v;
+    }
+
+    template<Queryable T>
+    std::vector<T> Update(std::vector<Condition> conditions, std::vector<Updates> updates) {
+        auto command = fmt::format("update {}", T::GetTableName());
+
+        pqxx::params values;
+
+
+        if (updates.size() > 0) {
+            absl::StrAppend(&command, " SET ", updates.at(0).ToString(+0));
+            values.append(updates.at(0).GetParam());
+        }
+        for (int i = 1; i < updates.size(); ++i) {
+            absl::StrAppend(&command, ", ", updates.at(i).ToString(i));
+            values.append(updates.at(i).GetParam());
+        }
+
+        if (conditions.size() > 0) {
+            absl::StrAppend(&command, " WHERE ", conditions.at(0).ToString(updates.size() + 0));
+            values.append(conditions.at(0).GetParam());
+        }
+        for (int i = 1; i < conditions.size(); ++i) {
+            absl::StrAppend(&command, " AND ", conditions.at(i).ToString(updates.size() + i));
+            values.append(conditions.at(i).GetParam());
+        }
+
+        console->info("{}", command);
+
+
+        pqxx::work w(connection);
+
+        connection.prepare("", command);
+        pqxx::result r = w.exec_prepared("", values);
+
+        w.commit();
+
+        return T::FromResult(r);
+    }
+
+
+    void Init();
+    void Drop();
+};

GUEST_BOOK/app/lib/include/DbModel.h

@@ -0,0 +1,174 @@
+#pragma once
+#include "DBHelper.h"
+#include "Util.h"
+#include <pqxx/result>
+#include <string>
+#include <utility>
+
+struct User {
+private:
+    User() = default;
+
+public:
+    std::string username;
+    std::string password;
+    std::string firstname;
+    std::string lastname;
+    std::string top_secret_user_information;
+
+    User(std::string username, const std::string &password) : username(std::move(username)), password(Hash(password)) {}
+
+    TableName(Users);
+    Fields(Field(username, username),
+           Field(password, password),
+           Field(firstname, firstname),
+           Field(lastname, lastname),
+           Field(top_secret_user_information, top_secret_user_information), );
+
+    static std::vector<User> FromResult(const pqxx::result &result) {
+        std::vector<User> v;
+        for (auto const &row : result) {
+            User &user = v.emplace_back<User>({});
+            for (int i = 0; i < row.size(); i++) {
+                auto field = row.at(i);
+                if (std::string_view(result.column_name(i)) == "username") {
+                    user.username = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "password") {
+                    user.password = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "firstname") {
+                    user.firstname = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "lastname") {
+                    user.lastname = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "top_secret_user_information") {
+                    user.top_secret_user_information = field.as<pqxx::binarystring>().str();
+                }
+            }
+        }
+        return v;
+    }
+};
+
+struct Message {
+private:
+    Message() = default;
+
+public:
+    //    int db_id{};
+    std::string id;
+    std::string text;
+    std::string title;
+    bool pub{};
+
+    Message(/*int dbId,*/ std::string ids, std::string title, std::string text, bool pub);
+
+
+    TableName(Message);
+    Fields(
+            /*Field(db_id, std::to_string(db_id)),*/
+            Field(id, id),
+            Field(message, text),
+            Field(title, title),
+            Field(public, pub));
+
+    static std::vector<Message> FromResult(const pqxx::result &result) {
+        std::vector<Message> v;
+        for (auto const &row : result) {
+            Message &msg = v.emplace_back<Message>({});
+            for (int i = 0; i < row.size(); i++) {
+                auto field = row.at(i);
+                /*                if (std::string_view(result.column_name(i)) == "db_id") {
+                    msg.db_id = field.as<int>();
+                }*/
+                if (std::string_view(result.column_name(i)) == "id") {
+                    msg.id = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "message") {
+                    msg.text = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "title") {
+                    msg.title = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "public") {
+                    msg.pub = field.as<bool>();
+                }
+            }
+        }
+        return v;
+    }
+};
+
+
+struct Quote {
+private:
+    Quote() = default;
+
+public:
+    std::string id;
+    std::string messageId;
+    std::string text;
+
+    Quote(std::string id, std::string messageId, std::string text) : id(std::move(id)), messageId(std::move(messageId)), text(std::move(text)) {}
+
+    TableName(Quote);
+    Fields(
+            Field(id, id),
+            Field(message_id, messageId),
+            Field(quote, text));
+
+    static std::vector<Quote> FromResult(const pqxx::result &result) {
+        std::vector<Quote> v;
+        for (auto const &row : result) {
+            Quote &msg = v.emplace_back<Quote>({});
+            for (int i = 0; i < row.size(); i++) {
+                auto field = row.at(i);
+                if (std::string_view(result.column_name(i)) == "id") {
+                    msg.id = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "message_id") {
+                    msg.messageId = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "quote") {
+                    msg.text = field.as<pqxx::binarystring>().str();
+                }
+            }
+        }
+        return v;
+    }
+};
+
+
+struct UserMessage {
+private:
+    UserMessage() = default;
+
+public:
+    std::string username;
+    std::string messageId;
+
+    UserMessage(std::string username, std::string messageId) : username(std::move(username)), messageId(std::move(messageId)) {}
+
+    TableName(user_messages)
+            Fields(Field(message_id, messageId),
+                   Field(username, username));
+
+    static std::vector<UserMessage> FromResult(const pqxx::result &result) {
+        std::vector<UserMessage> v;
+        for (auto const &row : result) {
+            UserMessage &msg = v.emplace_back<UserMessage>({});
+            for (int i = 0; i < row.size(); i++) {
+                auto field = row.at(i);
+                if (std::string_view(result.column_name(i)) == "message_id") {
+                    msg.messageId = field.as<pqxx::binarystring>().str();
+                }
+                if (std::string_view(result.column_name(i)) == "user_id") {
+                    msg.username = field.as<pqxx::binarystring>().str();
+                }
+            }
+        }
+        return v;
+    }
+};

GUEST_BOOK/app/lib/include/EditCommand.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Command.h"
+
+class EditCommand : public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};

GUEST_BOOK/app/lib/include/Lib.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Application.h"
+#include "Command.h"
+#include "Commands.h"
+#include "Logger.h"
+#include "RegisterCommand.h"
+#include "Database.h"
+#include "DBHelper.h"
+#include "Util.h"

GUEST_BOOK/app/lib/include/LoadEntriesCommand.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Command.h"
+
+class LoadEntriesCommand : public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};

GUEST_BOOK/app/lib/include/LoadMyEntriesCommand.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Command.h"
+
+class LoadMyEntriesCommand : public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};

GUEST_BOOK/app/lib/include/Logger.h

@@ -0,0 +1,5 @@
+#pragma once
+#include "spdlog/spdlog.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+
+extern std::shared_ptr<spdlog::logger> console;

GUEST_BOOK/app/lib/include/LoginCommand.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Command.h"
+
+class LoginCommand: public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};
+
+

GUEST_BOOK/app/lib/include/PostCommand.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Command.h"
+
+class PostCommand : public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};

GUEST_BOOK/app/lib/include/QuoteCommand.h

@@ -0,0 +1,7 @@
+#pragma once
+#include "Command.h"
+
+class QuoteCommand : public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};

GUEST_BOOK/app/lib/include/RegisterCommand.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Command.h"
+
+class RegisterCommand: public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};
+
+

GUEST_BOOK/app/lib/include/Util.h

@@ -0,0 +1,28 @@
+#pragma once
+#include <exception>
+#include <string>
+#include <absl/strings/str_split.h>
+std::string Hash(const std::string &s);
+std::string HashMD5(const std::string &s);
+
+template<typename T>
+concept Container = requires(T v, std::string key) {
+    { std::find(v.begin(), v.end(), key) != v.end() } -> std::convertible_to<bool>;
+};
+
+
+template<Container T>
+bool Contains(T v, std::string key) {
+    if (std::find(v.begin(), v.end(), key) != v.end()) {
+        return true;
+    }
+    return false;
+}
+
+
+#define APP_ASSERT(cond, msg)          \
+    if (!(cond)) {                     \
+        throw std::runtime_error(msg); \
+    }
+
+std::vector<std::string> SplitAndVerify(const std::string &line, size_t number);

GUEST_BOOK/app/lib/include/ViewCommand.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Command.h"
+
+class ViewCommand: public Command {
+public:
+    void Execute(Context&, std::basic_ostream<char>&, std::string) const override;
+};
+
+

GUEST_BOOK/app/lib/src/Application.cpp

@@ -0,0 +1,54 @@
+#include "Application.h"
+#include "Logger.h"
+#include <Commands.h>
+#include <DBHelper.h>
+#include <Database.h>
+#include <RegisterCommand.h>
+#include <Util.h>
+
+#include <DbModel.h>
+#include <EditCommand.h>
+#include <LoadEntriesCommand.h>
+#include <LoadMyEntriesCommand.h>
+#include <LoginCommand.h>
+#include <PostCommand.h>
+#include <QuoteCommand.h>
+#include <ViewCommand.h>
+#include <utility>
+
+void Application::Run() noexcept {
+    Database::Get().Init();
+    Commands::Get()
+            ->Register("register", []() { return std::make_shared<RegisterCommand>(); });
+    Commands::Get()
+            ->Register("login", []() { return std::make_shared<LoginCommand>(); });
+    Commands::Get()
+            ->Register("edit-profile", []() { return std::make_shared<EditCommand>(); });
+    Commands::Get()
+            ->Register("view-profile", []() { return std::make_shared<ViewCommand>(); });
+    Commands::Get()
+            ->Register("load-entries", []() { return std::make_shared<LoadEntriesCommand>(); });
+    Commands::Get()
+            ->Register("load-my-entries", []() { return std::make_shared<LoadMyEntriesCommand>(); });
+    Commands::Get()
+            ->Register("post-entry", []() { return std::make_shared<PostCommand>(); });
+    Commands::Get()
+            ->Register("quote-entry", []() { return std::make_shared<QuoteCommand>(); });
+
+    Context c{};
+
+    std::string line;
+    while (std::getline(istream, line)) {
+        try {
+            console->info("Got message <{}>", line);
+            Commands::Get()->Execute(c, ostream, std::string(absl::StripAsciiWhitespace(line)));
+        } catch (std::exception &e) {
+            ostream << e.what() << std::endl;
+        }
+    }
+}
+
+Application &Application::Drop() noexcept {
+    Database::Get().Drop();
+    return *this;
+}

GUEST_BOOK/app/lib/src/Commands.cpp

@@ -0,0 +1,19 @@
+#include "Commands.h"
+#include <absl/strings/str_split.h>
+#include <memory>
+void Commands::Execute(Context &c, std::basic_ostream<char> &s, const std::string &line) {
+    std::vector<std::string> parts = absl::StrSplit(line, "|");
+    if (commands.contains(parts[0])) {
+        commands.at(parts[0])()->Execute(c, s, line);
+    } else {
+        s << "error command unknown" << std::endl;
+    }
+}
+
+Commands *Commands::Get() {
+    static auto *commands = new Commands();
+    return commands;
+}
+void Commands::Register(const std::string &string, const std::function<std::shared_ptr<Command>()> &factory) {
+    commands.emplace(string, factory);
+}

GUEST_BOOK/app/lib/src/Database.cpp

@@ -0,0 +1,35 @@
+#include "Database.h"
+#include <Logger.h>
+#include <fstream>
+#include <functional>
+#include <pqxx/pqxx>
+Database &Database::Get() {
+    static Database db = Create();
+    return db;
+}
+
+Database Database::Create() {
+    return Database(pqxx::connection("postgresql://postgres:Password1@localhost/postgres"));
+}
+Database::Database(pqxx::connection connection) : connection{std::move(connection)} {
+}
+void Database::Init() {
+    std::ifstream t("data/init.sql");
+    std::stringstream initScript;
+    initScript << t.rdbuf();
+
+    pqxx::work w(connection);
+    pqxx::result r = w.exec(initScript.str());
+
+    w.commit();
+}
+void Database::Drop() {
+    std::ifstream t("data/drop.sql");
+    std::stringstream initScript;
+    initScript << t.rdbuf();
+
+    pqxx::work w(connection);
+    pqxx::result r = w.exec(initScript.str());
+
+    w.commit();
+}

GUEST_BOOK/app/lib/src/DbModel.cpp

@@ -0,0 +1,5 @@
+#include "DbModel.h"
+
+#include <utility>
+
+Message::Message(/*int dbId,*/ std::string id, std::string title, std::string text, bool pub) : /*db_id(dbId),*/ id(std::move(id)), text(std::move(text)), title(std::move(title)), pub(pub) {}

GUEST_BOOK/app/lib/src/EditCommand.cpp

@@ -0,0 +1,27 @@
+#include "EditCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void EditCommand::Execute(Context &c, std::basic_ostream<char> &ostream, std::string string) const {
+    static constexpr std::array validFields = {"firstname", "lastname", "top_secret_user_information"};
+    console->info("EditCommand");
+    std::vector<std::string> parts = SplitAndVerify(string, 4);
+
+    auto &field = parts.at(2);
+    auto &value = parts.at(3);
+
+    APP_ASSERT(!c.user.empty(), "error not logged in")
+    APP_ASSERT(Contains(validFields, field), "error field does not exist")
+
+    Database::Get().Update<User>({Condition::Eq("username", c.user)},
+                                 {Updates::Set(field, value)});
+
+
+    ostream << "ok" << std::endl;
+}

GUEST_BOOK/app/lib/src/LoadEntriesCommand.cpp

@@ -0,0 +1,46 @@
+#include "LoadEntriesCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void LoadEntriesCommand::Execute(Context &c, std::basic_ostream<char> &ostream, std::string string) const {
+    console->info("LoadEntriesCommand");
+    std::vector<std::string> parts = SplitAndVerify(string, 1);
+
+    auto quotes = Database::Get().Query<Quote>({});
+
+    auto posts = Database::Get().Query("select m.*, username from user_messages join message m on user_messages.message_id = m.id",{});
+
+
+    ostream << "ok" << '\n';
+    ostream << "posts:" << '\n';
+    for (auto &post : posts) {
+        ostream << "id: " << post["id"] << '\n';
+        ostream << "username: " << post["username"] << '\n';
+        ostream << "public: " << ((post["public"] == "t") ? "true" : "false") << '\n';
+
+        if (post["public"] == "t") {
+            ostream << "title: " << post["title"] << '\n';
+            ostream << "message: " << post["message"] << '\n';
+        } else {
+            ostream << "title: "
+                    << "<redacted>" << '\n';
+            ostream << "message: "
+                    << "<redacted>" << '\n';
+        }
+        ostream << '\n';
+    }
+    ostream << '\n';
+    ostream << "quotes:" << '\n';
+    for (auto &quote : quotes) {
+        ostream << "id: " << quote.id << '\n';
+        ostream << "quote_of: " << quote.messageId << '\n';
+        ostream << "message: " << quote.text << '\n';
+        ostream << '\n';
+    }
+}

GUEST_BOOK/app/lib/src/LoadMyEntriesCommand.cpp

@@ -0,0 +1,91 @@
+#include "LoadMyEntriesCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void LoadMyEntriesCommand::Execute(Context &c, std::basic_ostream<char> &ostream, std::string string) const {
+    console->info("LoadMyEntriesCommand");
+    std::vector<std::string> parts = SplitAndVerify(string, 1);
+
+    APP_ASSERT(!c.user.empty(), "error not logged in");
+
+    auto msgs = Database::Get().Query<UserMessage>({Condition::Eq("username", c.user)});
+
+    std::vector<std::string> messageIds;
+    std::transform(msgs.begin(), msgs.end(), std::back_inserter(messageIds), [](UserMessage &msg) {
+        return msg.messageId;
+    });
+
+
+    auto posts = Database::Get().Query<Message>({Condition::In("id", messageIds)});
+
+
+    auto quotes = Database::Get().Query<Quote>({Condition::In("id", messageIds)});
+
+    // select distinct quote.message_id from user_messages join Quote on user_messages.message_id = quote.id
+    // where Quote.id = 'f73dff6a92d287b7587d0214056b5427' and username = 'user'
+
+    ostream << "ok" << '\n';
+    ostream << "posts:" << '\n';
+    for (auto &post : posts) {
+        ostream << "id: " << post.id << '\n';
+        ostream << "title: " << post.title << '\n';
+        ostream << "message: " << post.text << '\n';
+        ostream << '\n';
+    }
+
+
+    auto fields = Database::Get().Query("select *\n"
+                                        "from user_messages join quote q on user_messages.message_id = q.id where username = $1;",
+                                        {c.user});
+
+
+    ostream << '\n';
+    ostream << "quotes:" << '\n';
+    for (auto &field : fields) {
+        auto id = field["id"];
+        auto fields2 = Database::Get().Query("select * from quote q\n"
+                                             "join message m on m.id = q.message_id\n"
+                                             "join user_messages quotedMessage on m.id = quotedMessage.message_id\n"
+                                             "join user_messages myQuote on q.id = myQuote.message_id\n"
+                                             "where q.id = $1\n"
+                                             "and (quotedMessage.username = $2 or m.public);",
+                                             {id, c.user});
+        if (!fields2.empty()) {
+            auto messages = Message::FromResult(Database::Get().QueryResult("select m.*\n"
+                                                                            "from  Quote join message m on quote.message_id = m.id\n"
+                                                                            "where Quote.id = $1",
+                                                                            {id}));
+            for (auto &quote : quotes) {
+                ostream << "id: " << quote.id << '\n';
+                ostream << "quote_of: " << quote.messageId << '\n';
+                for (auto &message : messages) {
+                    ostream << "\t"
+                            << "id: " << message.id << '\n';
+                    ostream << "\t"
+                            << "public: " << std::boolalpha << message.pub << '\n';
+                    ostream << "\t"
+                            << "title: " << message.title << '\n';
+                    ostream << "\t"
+                            << "text: " << message.text << '\n';
+                }
+
+                ostream << "message: " << quote.text << '\n';
+                ostream << '\n';
+            }
+        } else {
+            for (auto &quote : quotes) {
+                ostream << "id: " << quote.id << '\n';
+                ostream << "quote_of: " << quote.messageId << '\n';
+                ostream << "message: " << quote.text << '\n';
+                ostream << '\n';
+            }
+        }
+    }
+    ostream << '\n';
+}

GUEST_BOOK/app/lib/src/Logger.cpp

@@ -0,0 +1,4 @@
+#include "Logger.h"
+
+
+std::shared_ptr<spdlog::logger> console = spdlog::stderr_color_mt("console");;

GUEST_BOOK/app/lib/src/LoginCommand.cpp

@@ -0,0 +1,24 @@
+#include "LoginCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void LoginCommand::Execute(Context& c, std::basic_ostream<char> &ostream, std::string string) const {
+    console->info("LoginCommand");
+
+    std::vector<std::string> parts = SplitAndVerify(string, 3);
+
+    auto users = Database::Get().Query<User>({
+            Condition::Eq("username", parts.at(1)),
+                        Condition::Eq("password", Hash(parts.at(2))),
+    });
+    APP_ASSERT(users.size() == 1, "error username or password wrong")
+
+    c.user = parts.at(1);
+    ostream << "ok" << std::endl;
+}

GUEST_BOOK/app/lib/src/PostCommand.cpp

@@ -0,0 +1,28 @@
+#include "PostCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void PostCommand::Execute(Context &c, std::basic_ostream<char> &ostream, std::string string) const {
+    static constexpr std::array validVisibility = {"public", "private"};
+
+    console->info("PostCommand");
+    std::vector<std::string> parts = SplitAndVerify(string, 4);
+    APP_ASSERT(!c.user.empty(), "error not logged in")
+
+    auto &visibility = parts[1];
+    auto &title = parts[2];
+    auto &text = parts[3];
+
+    APP_ASSERT(Contains(validVisibility, visibility), "error visibility unknown")
+
+    Database::Get().Insert(Message(HashMD5(text), title, text, visibility == "public"));
+    Database::Get().Insert(UserMessage(c.user, HashMD5(text)));
+
+    ostream << "ok" << std::endl;
+}

GUEST_BOOK/app/lib/src/QuoteCommand.cpp

@@ -0,0 +1,38 @@
+#include "QuoteCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void QuoteCommand::Execute(Context &c, std::basic_ostream<char> &ostream, std::string string) const {
+    console->info("QuoteCommand");
+
+    std::vector<std::string> parts = SplitAndVerify(string, 3);
+    APP_ASSERT(!c.user.empty(), "error not logged in")
+
+    auto &id = parts[1];
+    auto &text = parts[2];
+
+    auto posts = Database::Get().Query<Message>({Condition::In("id", {id})});
+
+    auto existingPosts = Database::Get().Query<Quote>({Condition::In("quote", {text})});
+
+    APP_ASSERT(!posts.empty(), "error post does not exist")
+    APP_ASSERT(existingPosts.empty(), "error spam detection")
+
+    std::string hash;
+    if (posts.at(0).pub) {
+        hash = HashMD5(posts.at(0).text + " " + text);
+    } else {
+        hash = HashMD5(posts.at(0).id + " " + text);
+    }
+
+    Database::Get().Insert(Quote(hash, id, text));
+    Database::Get().Insert(UserMessage(c.user, hash));
+
+    ostream << "ok" << std::endl;
+}

GUEST_BOOK/app/lib/src/RegisterCommand.cpp

@@ -0,0 +1,18 @@
+#include "RegisterCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+
+void RegisterCommand::Execute(Context& c, std::basic_ostream<char> &ostream, std::string string) const {
+    console->info("RegisterCommand");
+    std::vector<std::string> parts = SplitAndVerify(string, 3);
+
+    Database::Get().Insert(User(parts.at(1), parts.at(2)));
+
+    ostream << "ok" << std::endl;
+}

GUEST_BOOK/app/lib/src/Util.cpp

@@ -0,0 +1,36 @@
+#include "Util.h"
+#include "cryptopp/base64.h"
+#include "cryptopp/hex.h"
+#include "cryptopp/md5.h"
+#include "cryptopp/sha.h"
+#include "string"
+#include <Logger.h>
+std::string Hash(const std::string &s) {
+    std::string digest;
+    CryptoPP::SHA256 hash;
+
+    CryptoPP::StringSource foo(s, true,
+                               new CryptoPP::HashFilter(hash,
+                                                        new CryptoPP::HexEncoder(
+                                                                new CryptoPP::StringSink(digest))));
+    return digest;
+}
+
+
+std::string HashMD5(const std::string &s) {
+    std::string digest;
+    CryptoPP::MD5 hash;
+
+    CryptoPP::StringSource foo(s, true,
+                               new CryptoPP::HashFilter(hash,
+                                                        new CryptoPP::HexEncoder(
+                                                                new CryptoPP::StringSink(digest), false)));
+    return digest;
+}
+
+
+std::vector<std::string> SplitAndVerify(const std::string &line, size_t number) {
+    std::vector<std::string> parts = absl::StrSplit(line, "|");
+    APP_ASSERT(parts.size() == number, "error wrong number of arguments")
+    return parts;
+}

GUEST_BOOK/app/lib/src/ViewCommand.cpp

@@ -0,0 +1,47 @@
+#include "ViewCommand.h"
+
+#include <Database.h>
+#include <DbModel.h>
+#include <Logger.h>
+#include <Util.h>
+#include <absl/strings/str_split.h>
+#include <string>
+
+extern "C" {
+struct Var {
+    unsigned long pos1, pos2;
+    char parts[2][32];
+    char userName[255];
+};
+}
+
+void ViewCommand::Execute(Context &c, std::basic_ostream<char> &ostream, std::string string) const {
+    console->info("ViewCommand");
+    Var var;
+
+    memset(var.userName, '\0', sizeof var.userName);
+    memset(var.parts, '\0', sizeof var.parts);
+    strncpy(var.userName, c.user.c_str(), c.user.size());
+
+    var.pos1 = string.find('|') + 1;
+    var.pos2 = string.size();
+
+    APP_ASSERT(var.pos1 != 0 && var.pos2 != 0, "error wrong number of arguments")
+
+    strncpy(var.parts[0], &string[0], var.pos1 - 0);
+    strncpy(var.parts[1], &string[var.pos1], var.pos2 - var.pos1);
+
+
+    APP_ASSERT(!c.user.empty(), "error not logged in")
+
+    auto users = Database::Get().Query<User>({Condition::Eq("username", std::string(var.userName))});
+    APP_ASSERT(!users.empty(), "error no user found");
+    auto user = users.at(0);
+
+    ostream << "ok" << '\n';
+    ostream << "firstname: " << user.firstname << '\n';
+    ostream << "lastname: " << user.lastname << '\n';
+    ostream << "top_secret_user_information: " << user.top_secret_user_information << '\n';
+
+    ostream << std::endl;
+}

GUEST_BOOK/app/run.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+timeout 60 ./Application

GUEST_BOOK/app/test/CMakeLists.txt

@@ -0,0 +1,19 @@
+project(test)
+set(CMAKE_CXX_STANDARD 20)
+
+
+include(${CMAKE_BINARY_DIR}/conan_paths.cmake)
+find_package(Catch2 REQUIRED)
+
+add_executable(custom_test src/main.cpp src/test.cpp)
+target_link_libraries(custom_test PRIVATE ApplicationLib)
+target_include_directories(custom_test PRIVATE "${Catch2_INCLUDE_DIR}")
+
+
+add_test(NAME custom_test COMMAND custom_test -r junit -d yes)
+
+file(COPY ${CMAKE_SOURCE_DIR}/data
+        DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
+
+
+

GUEST_BOOK/app/test/src/main.cpp

@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>

GUEST_BOOK/app/test/src/test.cpp

@@ -0,0 +1,694 @@
+#include "../../lib/include/Application.h"
+#include <Util.h>
+#include <catch2/catch.hpp>
+#include <fmt/format.h>
+#include <sstream>
+#include <string>
+using namespace std::string_literals;
+
+std::vector<std::string> GetLines(std::istream &s) {
+    std::vector<std::string> lines;
+
+    std::string line;
+    while (std::getline(s, line)) {
+        lines.push_back(line);
+    }
+
+    return lines;
+}
+
+
+TEST_CASE("RegisterCommand") {
+    SECTION("incorrect number of arguments") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"error wrong number of arguments"s}));
+    }
+
+    SECTION("incorrect number of arguments") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"error wrong number of arguments"s}));
+    }
+
+    SECTION("correct number of arguments") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"ok"s}));
+    }
+
+
+    SECTION("register and login") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"ok"s, "ok"s}));
+    }
+
+    SECTION("register and login wrong password") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|wrong\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"ok"s, "error username or password wrong"s}));
+    }
+}
+TEST_CASE("RegisterCommand + LoginCommand") {
+    SECTION("register and login") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"ok"s, "ok"s}));
+    }
+
+    SECTION("register and login wrong password") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|wrong\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{"ok"s, "error username or password wrong"s}));
+    }
+}
+
+TEST_CASE("RegisterCommand + LoginCommand + EditCommand") {
+    SECTION("set fields") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+        input << "edit-profile|user|firstname|user\n";
+        input << "edit-profile|user|lastname|usinger\n";
+        input << "edit-profile|user|top_secret_user_information|flag{flag{flag{flag}}}\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{
+                                  "ok"s,
+                                  "ok"s,
+                                  "ok"s,
+                                  "ok"s,
+                                  "ok"s}));
+    }
+    SECTION("set nonexisting field") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+        input << "edit-profile|user|förstname|user\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{
+                                  "ok"s,
+                                  "ok"s,
+                                  "error field does not exist"s}));
+    }
+
+    SECTION("set field not logged in ") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "edit-profile|user|firstname|user\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{
+                                  "ok"s,
+                                  "error not logged in"s}));
+    }
+}
+
+TEST_CASE("RegisterCommand + LoginCommand + PostCommand") {
+    SECTION("wrong number of arguments") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+        input << "post-entry\n";
+        input << "post-entry|title\n";
+        input << "post-entry|title|text\n";
+        input << "post-entry|title|text|publlic\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{
+                                  "ok"s,
+                                  "ok"s,
+                                  "error wrong number of arguments"s,
+                                  "error wrong number of arguments"s,
+                                  "error wrong number of arguments"s,
+                                  "error visibility unknown"s,
+                          }));
+    }
+
+    SECTION("not logged in ") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "post-entry|title|text|public\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{
+                                  "ok"s,
+                                  "error not logged in"s,
+                          }));
+    }
+
+    SECTION("post message") {
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+        input << "post-entry|public|title|text\n";
+
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector{
+                                  "ok"s,
+                                  "ok"s,
+                                  "ok"s,
+                          }));
+    }
+}
+
+
+TEST_CASE("RegisterCommand + LoginCommand + PostCommand + Quote Command") {
+    SECTION("Not logged in") {
+
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << fmt::format("quote-entry|{}|quoted_text\n", HashMD5("text"));
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);
+
+        CHECK_THAT(lines, Catch::Matchers::Equals(std::vector<std::string>{
+                                  "ok",
+                                  "error not logged in",
+                          }));
+    }
+    SECTION("post does not exist") {
+
+        std::stringstream input;
+        std::stringstream output;
+
+        input << "register|user|password\n";
+        input << "login|user|password\n";
+        input << fmt::format("quote-entry|{}|quoted_text\n", HashMD5("text"));
+        Application(input, output).Drop().Run();
+
+        auto lines = GetLines(output);