ParserMarkdown: Inherit from interface, not ParserLegacy

.gitignore

@@ -3,8 +3,6 @@
 *.out
 *.gch
 *.user
-*.swp
-*.kate-swp
 qswiki
 wikiqs*
 data/*

.gitmodules

@@ -4,6 +4,9 @@
 [submodule "submodules/cpp-httplib"]
 	path = submodules/cpp-httplib
 	url = https://github.com/yhirose/cpp-httplib
-[submodule "submodules/exile.h"]
+[submodule "submodules/qssb.h"]
-	path = submodules/exile.h
+	path = submodules/qssb.h
-	url = https://gitea.quitesimple.org/crtxcr/exile.h.git
+	url = https://gitea.quitesimple.org/crtxcr/qssb.h.git
+[submodule "submodules/qsmaddy"]
+	path = submodules/qsmaddy
+	url = https://gitea.quitesimple.org/crtxcr/qsmaddy

Makefile

@@ -1,14 +1,12 @@
-CPPSTD=c++20
 
-#CFIFLAGS=-fsanitize=cfi -fvisibility=hidden -fsanitize=cfi -flto
-#Does not work reliably atm
-CFIFLAGS=
 
-CXXFLAGS=-std=$(CPPSTD) -O2 -g -no-pie -pipe -MMD -Wall -Wextra -DGLIBCXX_ASSERTIONS -D_LIBCPP_ENABLE_ASSERTIONS=1 $(CFIFLAGS)
+CXXFLAGS=-std=c++17 -O0 -g -no-pie -pipe -MMD -Wall -Wextra
-RELEASE_CXXFLAGS=-std=$(CPPSTD) -O3 -pipe -MMD -Wall -Wextra -DGLIBCXX_ASSERTIONS -D_LIBCPP_ENABLE_ASSERTIONS=1 $(CFIFLAGS)
+RELEASE_CXXFLAGS=-std=c++17 -O3 -pipe -MMD -Wall -Wextra
+LDFLAGS=-lsqlite3 -lpthread -lcrypto -lstdc++fs -lseccomp
+INCLUDEFLAGS=-I submodules/sqlitemoderncpp/hdr -I submodules/cpp-httplib -I submodules/qssb.h -I submodules/qsmaddy/include/
+
+CXX=g++
 
-LDFLAGS=-lsqlite3 -lpthread -lcrypto -lstdc++fs $(CFIFLAGS)
-INCLUDEFLAGS=-I submodules/sqlitemoderncpp/hdr -I submodules/cpp-httplib -I submodules/exile.h
 
 SOURCES=$(wildcard *.cpp)
 SOURCES+=$(wildcard gateway/*.cpp)
@@ -16,7 +14,6 @@ SOURCES+=$(wildcard handlers/*.cpp)
 SOURCES+=$(wildcard database/*.cpp)
 SOURCES+=$(wildcard cache/*.cpp)
 SOURCES+=$(wildcard sandbox/*.cpp)
-SOURCES+=$(wildcard dynamic/*.cpp)
 
 HEADERS=$(wildcard *.h)
 HEADERS+=$(wildcard gateway/*.h)
@@ -24,7 +21,7 @@ HEADERS+=$(wildcard handlers/*.h)
 HEADERS+=$(wildcard database/*.h)
 HEADERS+=$(wildcard cache/*.h)
 HEADERS+=$(wildcard sandbox/*.h)
-HEADERS+=$(wildcard dynamic/*.h)
+
 
 OBJECTS=$(patsubst %.cpp, %.o, $(SOURCES))
 WIKIOBJECTS=$(filter-out test.o, $(OBJECTS))
@@ -38,25 +35,16 @@ GTEST_DIR = /home/data/SOURCES/gtest/googletest
 
 GTESTS_TESTDIR = ./tests/
 
-GTEST_CXXFLAGS=-std=$(CPPSTD) -isystem $(GTEST_DIR)/include -I$(GTEST_DIR) -g -O0 -pipe -Wall -Wextra
+GTEST_CXXFLAGS=-std=c++17 -isystem $(GTEST_DIR)/include -I$(GTEST_DIR) -g -O0 -pipe -Wall -Wextra
 GTEST_LDFLAGS=-lsqlite3 -g -O0 -lpthread -lcrypto -lstdc++fs
 GTEST_OBJECTS=$(filter-out qswiki.o, $(WIKIOBJECTS))
 
 .DEFAULT_GOAL := qswiki
 
 release: CXXFLAGS=$(RELEASE_CXXFLAGS)
-profile: CXXFLAGS=$(RELEASE_CXXFLAGS) -pg
-profile: LDFLAGS+= -pg
-
 release: qswiki
-profile: qswiki
+qswiki: $(WIKIOBJECTS)
-
+	$(CXX) $(WIKIOBJECTS) ${LDFLAGS} ${INCLUDEFLAGS}  -o qswiki
-
-exile.o: submodules/exile.h/exile.c
-	$(CC) -std=c99 -DHAVE_LANDLOCK=0 -c submodules/exile.h/exile.c -o exile.o
-
-qswiki: $(WIKIOBJECTS) exile.o
-	$(CXX) $(shell shuf -e $(WIKIOBJECTS) exile.o ) ${LDFLAGS} ${INCLUDEFLAGS}  -o qswiki
 
 test: $(TESTOBJECTS)
 	$(CXX) $(TESTOBJECTS) ${LDFLAGS} -o test
@@ -65,11 +53,9 @@ gtest: $(GTESTS_TESTDIR)/*.cpp $(GTEST_OBJECTS)
 	$(CXX) -o gtest $(GTESTS_TESTDIR)/*.cpp $(GTEST_OBJECTS) $(GTEST_CXXFLAGS) $(GTEST_DIR)/src/gtest_main.cc $(GTEST_DIR)/src/gtest-all.cc $(GTEST_LDFLAGS)
 
 %.o:%.cpp
-	$(CXX) ${CXXFLAGS} ${INCLUDEFLAGS} -c -o $@ $<
+	$(CXX) ${CXXFLAGS} ${LDFLAGS} ${INCLUDEFLAGS} -c -o $@ $<
 
-version.o:version.cpp
-	$(CXX) ${CXXFLAGS} ${INCLUDEFLAGS} -DGITCOMMIT=\"$(shell git rev-parse --short HEAD)\" -c -o $@ $<
 clean:
-	rm -f exile.o $(OBJECTS) $(DEPENDS)
+	rm -f $(OBJECTS) $(DEPENDS)
 
 

README.md

@@ -1,26 +1,23 @@
 # qswiki
 
-## About
+About
-qswiki is a wiki software, intended for my needs. Originally  implemented in C, it's now written in C++.
+====
+qswiki is a wiki software, intended for small wikis. Originally 
+implemented in C, it's now written in C++.
 
-## Dude... why?
+History
-
+====
-tl;dr: It was a playground, an experiment (taken too far). I guess at some point I couldn't stop, because I've already
+A couple of years ago, I wanted to setup a personal wiki on my raspberry 
-started.
-
-### History
-Several years ago, I wanted to setup a personal wiki on my raspberry
 pi. However, the distribution I used back then did not have a PHP package 
 for ARM. So instead of switching distributions or searching for other
-wikis that I could use, I simply decided I would write one in C. Yes,
+wikis that I could use, I decided I would write one in C. Yes, 
 that's an odd way  to approach the problem and indeed, I may have had too 
 much time back  then. Also, I wanted to see how it's like to write a 
 "web app" in C and wanted to sharpen my C skills a little bit.
 
-Of course, it's pretty straightforward at first. No really: Just use CGI
+Of course, it's pretty straightforward at first. No really: Just use CGI. 
-and print your HTML to stdout.And indeed, that would have been more than enough for my use cases.
+And indeed, that would have been more than enough for my use cases. 
-
+Then I decided to play around and started using FastCGI (with the official 
-But then I decided to play around and started using FastCGI (with the official
 library from now  defunct fastcgi.com) and created a multi-threaded version.
 It initially  used a "pile of files database", but that became too painful, 
 so then I started using sqlite.
@@ -28,55 +25,55 @@ so then I started using sqlite.
 C++
 ---
 Eventually, since it was mostly a playground for me, the code became 
-unmaintainable. Furthermore, I initially wanted something quick and given that
+unmaintainable. Furthermore, I wanted something quick and given that 
 it was CGI, I didn't bother taking care of memory leaks. 
 After initiating a FastCGI interface, they became an issue and then the 
 task of avoiding memory leaks became too annoying. And of course, C does n
 ot include any "batteries" and while I could manage, this too was another 
 good reason.
 
-Overall, I am just continuing the experiment with >=C++17 now. It's not
+Overall, I am just continuing the experiment with C++17 now. It's not 
 nearly as bad as you would expect perhaps. Some things are surprisingly 
 convenient even. Still, the standard library is lacking and 
 I would hope for a some better built-in Unicode support in future C++ 
 standards.
 
-
+Features
-## Features
+========
-Some essential features are lacking, such as a diff between revisions,
+To be fair, at this point it doesn't even have a "diff" between revisions 
-user registration UI, etc.
+yet and does not have features that would make you prefer it over other 
-
+wikis.
-It doesn't compete with any other software anyway.
 
  - CGI
- - HTTP server using the header only library [cpp-httplib](https://github.com/yhirose/cpp-httplib). It's more
+ - HTTP server using the header only library cpp-httplib. It's more 
  portable and more "future-proof" than FastCGI (since the official website 
  disappeared, the library's future appears to be uncertain).
  - Support for user accounts. Passwords are stored using PBKDF2.
   sqlite database, but not too much of an effort to add other types of 
   storage backends. sqlite is using the great header only library 
-  [sqlite_modern_cpp](https://github.com/SqliteModernCpp)
+  sqlite_modern_cpp
  - Relatively fine-grained permission system.
  - Categories
  - Templates
  - FTS search
  - Caching
- - Blog-like functionality
- - RSS/Atom feeds
 
-## Security
+Security
-[exile.h](https://github.com/quitesimpleorg/exile.h) is used
+========
-to restrict access to the files the wiki needs.  It doesn't have access to other paths
+On Linux namespaces are used to restrict the process to only access
-in the system and the system calls that the qswiki process can make are restricted.
+files it needs. It doesn't have access to other paths in the system.
-
+In addition, Seccomp is used to restrict the syscalls the qswiki process
-As for "web security", all POST requests are centrally protected against CSRF attacks and all input is escaped against XSS
+can call.  As for "web security", all POST requests are centrally
+protected against CSRF attacks and all input is escaped against XSS 
 attacks.
 
-## Building
+Building
+========
 Dependencies:
   - cpp-httplib: https://github.com/yhirose/cpp-httplib
   - SqliteModernCpp: https://github.com/SqliteModernCpp
-  - exile.h: https://gitea.quitesimple.org/crtxcr/exile.h
+  - qssb.h: https://gitea.quitesimple.org/crtxcr/qssb.h
+  - libseccomp: https://github.com/seccomp/libseccomp
   - sqlite3: https://sqlite.org/index.html
     
 The first three are header-only libraries that are included as a git submodule. The others must

authenticator.cpp

@@ -21,7 +21,7 @@ Authenticator::Authenticator(UserDao &userDao)
 // TODO: make failure counter configurable
 bool Authenticator::isBanned(std::string ip)
 {
-	if(loginFails.contains(ip))
+	if(utils::hasKey(loginFails, ip))
 	{
 		LoginFail &fl = loginFails[ip];
 		std::lock_guard<std::mutex> lock(fl.mutex);
@@ -42,12 +42,11 @@ std::vector<char> Authenticator::pbkdf5(std::string password, const std::vector<
 	unsigned char hash[32];
 	const EVP_MD *sha256 = EVP_sha256();
 	const unsigned char *rawsalt = reinterpret_cast<const unsigned char *>(salt.data());
-	int ret =
+	int ret = PKCS5_PBKDF2_HMAC(password.c_str(), password.size(), rawsalt, salt.size(), 300000, sha256, sizeof(hash), hash);
-		PKCS5_PBKDF2_HMAC(password.c_str(), password.size(), rawsalt, salt.size(), 300000, sha256, sizeof(hash), hash);
 	if(ret != 1)
 	{
 		Logger::error() << "Authenticator: pbkdf5: Failed to create hash";
-		return {};
+		return { };
 	}
 	std::vector<char> result;
 

authenticator.h

@@ -3,7 +3,6 @@
 #include <variant>
 #include "database/userdao.h"
 
-#define AUTH_DEFAULT_SALT_SIZE 32
 enum AuthenticationError
 {
 	UserNotFound,

cache/fscache.cpp

@@ -46,7 +46,7 @@ void FsCache::removePrefix(std::string_view prefix)
 	// TODO: lock dir
 	for(auto &entry : std::filesystem::directory_iterator(std::filesystem::path{this->path}))
 	{
-		if(std::string_view(entry.path().filename().c_str()).starts_with(prefix))
+		if(static_cast<std::string>(entry.path().filename()).find(prefix) == 0)
 		{
 			std::filesystem::remove_all(entry);
 		}

cache/mapcache.cpp

@@ -1 +0,0 @@
-#include "mapcache.h"

cache/mapcache.h

@@ -1,87 +0,0 @@
-#ifndef MAPCACHE_H
-#define MAPCACHE_H
-#include <map>
-#include <set>
-#include <shared_mutex>
-#include <optional>
-#include <string>
-#include "icache.h"
-
-/* Thread-Safe Key-Value store */
-template <class T> class MapCache
-{
-  private:
-	std::unordered_map<std::string, T> cache;
-	mutable std::shared_mutex sharedMutex;
-
-  public:
-	std::optional<T> find(const std::string &key) const
-	{
-		std::shared_lock<std::shared_mutex> lock(this->sharedMutex);
-		auto it = this->cache.find(key);
-		if(it != this->cache.end())
-		{
-			return it->second;
-		}
-		return {};
-	}
-	void set(const std::string &key, const T &val)
-	{
-		std::lock_guard<std::shared_mutex> lock{sharedMutex};
-		this->cache[key] = val;
-	}
-	void clear()
-	{
-		std::lock_guard<std::shared_mutex> lock{sharedMutex};
-		this->cache.clear();
-	}
-
-	void remove(const std::string &key)
-	{
-		std::lock_guard<std::shared_mutex> lock{sharedMutex};
-		this->cache.erase(key);
-	}
-
-	void removePrefix(const std::string &key)
-	{
-		std::lock_guard<std::shared_mutex> lock{sharedMutex};
-		std::erase_if(this->cache, [key](const auto &item)
-		{
-			auto const& [k, v] = item;
-			return k.starts_with(std::string_view(key));
-		});
-	}
-
-};
-
-
-class StringCache : public MapCache<std::string>, public ICache
-{
-	virtual std::optional<std::string> get(std::string_view key) const override
-	{
-		return MapCache<std::string>::find(std::string(key));
-	}
-
-	virtual void put(std::string_view key, std::string val) override
-	{
-		MapCache<std::string>::set(std::string(key), val);
-	}
-
-	virtual void remove(std::string_view key) override
-	{
-		MapCache<std::string>::remove(std::string(key));
-	}
-
-	virtual void removePrefix(std::string_view prefix)
-	{
-		MapCache<std::string>::removePrefix(std::string(prefix));
-	}
-
-	virtual void clear() override
-	{
-		MapCache<std::string>::clear();
-	}
-
-};
-
-#endif // MAPCACHE_H

cache/nocache.h

@@ -1,30 +0,0 @@
-#include "icache.h"
-
-class NoCache : public ICache
-{
-public:
-	NoCache(std::string p)
-	{
-
-	}
-	virtual std::optional<std::string> get(std::string_view key) const
-	{
-		return {};
-	}
-	virtual void put(std::string_view key, std::string val)
-	{
-		return;
-	}
-	virtual void remove(std::string_view key)
-	{
-		return;
-	}
-	virtual void removePrefix(std::string_view prefix)
-	{
-		return;
-	}
-	virtual void clear()
-	{
-		return;
-	}
-};

cli.cpp

@@ -1,278 +0,0 @@
-#include <map>
-#include <functional>
-#include <iomanip>
-
-#include "cli.h"
-#include "utils.h"
-#include "random.h"
-#include "authenticator.h"
-#include "config.h"
-#include "logger.h"
-#include "version.h"
-
-CLIHandler::CLIHandler(Config &config, Database &db)
-{
-	this->db = &db;
-	this->conf = &config;
-}
-
-std::pair<bool, std::string> CLIHandler::user_add(const std::vector<std::string> &args)
-{
-	std::string username = args.at(0);
-	std::string password = args.at(1);
-
-	auto userDao = db->createUserDao();
-
-	Permissions perms = this->conf->handlersConfig.anon_permissions;
-	int p = perms.getPermissions();
-	p |= PERM_CAN_CREATE | PERM_CAN_SEARCH | PERM_CAN_EDIT;
-	Permissions newPermissions = Permissions{p};
-
-	Random r;
-	User user;
-	user.enabled = true;
-	user.login = username;
-	user.salt = r.getRandom(AUTH_DEFAULT_SALT_SIZE);
-	user.permissions = newPermissions;
-
-	Authenticator auth{*userDao};
-	std::vector<char> hashResult = auth.hash(password, user.salt);
-	if(hashResult.empty())
-	{
-		return {false, "Error during hashing - Got empty hash"};
-	}
-	user.password = hashResult;
-
-	try
-	{
-		userDao->save(user);
-	}
-	catch(std::runtime_error &e)
-	{
-		return {false, "Exception: " + std::string(e.what())};
-	}
-	return {true, ""};
-}
-
-std::pair<bool, std::string> CLIHandler::user_change_pw([[maybe_unused]] const std::vector<std::string> &args)
-{
-	std::string username = args.at(0);
-	std::string password = args.at(1);
-
-	auto userDao = db->createUserDao();
-
-	auto user = userDao->find(username);
-	if(user)
-	{
-		Random r;
-		Authenticator auth{*userDao};
-		user->salt = r.getRandom(AUTH_DEFAULT_SALT_SIZE);
-		user->password = auth.hash(password, user->salt);
-		if(user->password.empty())
-		{
-			return {false, "Error during hashing - Got empty hash"};
-		}
-
-		userDao->save(*user);
-	}
-	return {false, "User not found"};
-}
-
-std::pair<bool, std::string> CLIHandler::user_rename([[maybe_unused]] const std::vector<std::string> &args)
-{
-
-	return {true, ""};
-}
-
-std::pair<bool, std::string> CLIHandler::user_set_perms([[maybe_unused]] const std::vector<std::string> &args)
-{
-	auto userDao = this->db->createUserDao();
-	std::string username = args.at(0);
-	std::string permission_string = args.at(1);
-
-	Permissions perms{permission_string};
-
-	auto user = userDao->find(username);
-	if(user)
-	{
-		user->permissions = perms;
-		userDao->save(*user);
-		user_show({username});
-		return {true, ""};
-	}
-
-	return {false, "User not found"};
-}
-
-std::pair<bool, std::string> CLIHandler::user_list([[maybe_unused]] const std::vector<std::string> &args)
-{
-	auto userDao = this->db->createUserDao();
-	QueryOption o;
-	auto result = userDao->list(o);
-	std::stringstream stream;
-	for(User &u : result)
-	{
-		stream << u.login << "\t" << std::string(u.enabled ? "enabled" : "disabled") << "\t" << u.permissions.toString()
-			   << std::endl;
-	}
-	return {true, stream.str()};
-}
-
-std::pair<bool, std::string> CLIHandler::user_show(const std::vector<std::string> &args)
-{
-	std::string username = args.at(0);
-	auto userDao = this->db->createUserDao();
-	auto user = userDao->find(username);
-	std::stringstream stream;
-	if(user)
-	{
-		stream << "Username: " << user->login << std::endl;
-
-		stream << "Enabled: " << std::string(user->enabled ? "yes" : "no") << std::endl;
-		stream << "Permissions (general): " << user->permissions.toString() << std::endl;
-		return {true, stream.str()};
-	}
-	return {false, "User not found"};
-}
-
-std::pair<bool, std::string> CLIHandler::page_list([[maybe_unused]] const std::vector<std::string> &args)
-{
-	auto pageDao = this->db->createPageDao();
-	QueryOption o;
-	auto result = pageDao->getPageList(o);
-	std::stringstream stream;
-	for(Page &page : result)
-	{
-		stream << page.name << " " << page.pageid << " " << std::string(page.listed ? "listed" : "unlisted") << std::endl;
-	}
-	return {true, stream.str()};
-}
-
-std::pair<bool, std::string> CLIHandler::pageperms_set_permissions(const std::vector<std::string> &args)
-{
-	std::string page = args.at(0);
-	std::string username = args.at(1);
-	std::string perms = args.at(2);
-
-	auto permissionsDao = this->db->createPermissionsDao();
-	permissionsDao->save(page, username, Permissions{perms});
-	return {true, ""};
-}
-
-std::pair<bool, std::string> CLIHandler::attach([[maybe_unused]] const std::vector<std::string> &args)
-{
-	/* TODO: consider authentication */
-	pid_t pid = getpid();
-	return {true, "Hi, I am pid: " + std::to_string(pid)};
-}
-
-std::pair<bool, std::string> CLIHandler::cli_help(const std::vector<std::string> &args)
-{
-	std::string command;
-	if(args.size() > 0)
-		command = args[0];
-	std::stringstream stream;
-	for(struct cmd &cmd : cmds)
-	{
-		if(command != "" && cmd.name != command)
-		{
-			continue;
-		}
-
-		stream << cmd.name << " - " << cmd.helptext << std::endl;
-		for(struct cmd &subCmd : cmd.subCommands)
-		{
-			stream << "\t" << subCmd.name << " " << subCmd.helptext << std::endl;
-		}
-		stream << std::endl;
-	}
-	return {true, stream.str()};
-}
-
-std::pair<bool, std::string> CLIHandler::processCommand(const std::vector<CLIHandler::cmd> &commands, std::string cmd,
-														const std::vector<std::string> &args)
-{
-	auto c = std::find_if(commands.begin(), commands.end(),
-						  [&cmd](const struct CLIHandler::cmd &a) { return a.name == cmd; });
-	if(c == commands.end())
-	{
-		std::cout << "No such command: " << cmd << std::endl;
-		return cli_help({});
-	}
-
-	if(!c->subCommands.empty() && args.size() >= c->required_args)
-	{
-		std::string newcmd = args[0];
-		std::vector<std::string> newargs = args;
-		newargs.erase(newargs.begin());
-		return processCommand(c->subCommands, newcmd, newargs);
-	}
-	if(args.size() < c->required_args)
-	{
-		return {false, "not enough parameters passed"};
-	}
-
-	try
-	{
-		return c->func(this, args);
-	}
-	catch(std::runtime_error &e)
-	{
-		return {false, "Exception: " + std::string(e.what())};
-	}
-	return {false, ""};
-}
-
-std::pair<bool, std::string> CLIHandler::processCommand(std::string cmd, const std::vector<std::string> &args)
-{
-	return processCommand(this->cmds, cmd, args);
-}
-
-std::pair<std::string, std::vector<std::string>> CLIHandler::splitCommand(std::string input)
-{
-	input = utils::trim(input);
-	std::vector<std::string> splitted = utils::split(input, "\\s+");
-	if(splitted.empty())
-	{
-		return {" ", splitted};
-	}
-	std::string cmd = splitted[0];
-	splitted.erase(splitted.begin());
-	return {cmd, splitted};
-}
-
-std::pair<bool, std::string> CLIHandler::version([[maybe_unused]] const std::vector<std::string> &args)
-{
-	return {true, get_version_string()};
-}
-
-std::pair<bool, std::string> CLIHandler::category_list([[maybe_unused]] const std::vector<std::string> &args)
-{
-	auto categoryDao = this->db->createCategoryDao();
-	auto categories = categoryDao->fetchList(QueryOption{});
-	std::stringstream stream;
-	for(std::string &cat : categories)
-	{
-		stream << cat << std::endl;
-	}
-	return {true, stream.str()};
-}
-
-std::pair<bool, std::string> CLIHandler::category_delete(const std::vector<std::string> &args)
-{
-	auto categoryDao = this->db->createCategoryDao();
-	categoryDao->deleteCategory(args.at(0));
-	return {true, ""};
-}
-
-std::pair<bool, std::string> CLIHandler::category_show(const std::vector<std::string> &args)
-{
-	auto categoryDao = this->db->createCategoryDao();
-	auto members = categoryDao->fetchMembers(args.at(0), QueryOption{});
-	std::stringstream stream;
-	for(Page &member : members)
-	{
-		stream << member.name << std::endl;
-	}
-	return {true, stream.str()};
-}

cli.h

@@ -1,94 +0,0 @@
-#ifndef CLI_H
-#define CLI_H
-#include <iostream>
-#include <string>
-#include <vector>
-#include "database/database.h"
-#include "config.h"
-
-class CLIHandler
-{
-	struct cmd
-	{
-		std::string name;
-		std::string helptext;
-		unsigned int required_args;
-		std::vector<cmd> subCommands;
-		std::function<std::pair<bool, std::string>(CLIHandler *, const std::vector<std::string> &)> func;
-	};
-
-  private:
-	Database *db;
-	Config *conf;
-
-  protected:
-	std::pair<bool, std::string> attach([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> cli_help([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_add([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_change_pw([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_rename([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_set_perms([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_list([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_show([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> page_list([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> pageperms_set_permissions([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> version([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> category_list([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> category_delete([[maybe_unused]] const std::vector<std::string> &args);
-	std::pair<bool, std::string> category_show([[maybe_unused]] const std::vector<std::string> &args);
-
-	std::vector<struct cmd> cmds{
-		{{"user",
-		  "user operations on the database",
-		  1,
-		  {{{"add", "[user] [password] - creates a user", 2, {}, &CLIHandler::user_add},
-			{"changepw", "[user] [password] - changes the password of user", 2, {}, &CLIHandler::user_change_pw},
-			{"rename", "[user] [new name] - renames a user", 2, {}, &CLIHandler::user_rename},
-			{"setperms", "[user] [perms] - sets the permissions of the user", 2, {}, &CLIHandler::user_set_perms},
-			{"list", "- lists users", 0, {}, &CLIHandler::user_list},
-			{"show", "[user] - show detailed information about user", 1, {}, &CLIHandler::user_show}}},
-		  &CLIHandler::cli_help},
-		 {"page",
-		  "operation on pages",
-		  1,
-		  {{{"list", "- lists existing pages", 0, {}, &CLIHandler::page_list}}},
-		  &CLIHandler::cli_help},
-		 {"category",
-		  "operation on categories",
-		  1,
-		  {{{"list", "- lists existing categories", 0, {}, &CLIHandler::category_list},
-			{"delete", " - deletes a category", 1, {}, &CLIHandler::category_delete},
-			{"show", " - shows pages of a category", 1, {}, &CLIHandler::category_show}}},
-		  &CLIHandler::cli_help},
-		 {"pageperms",
-		  "set permissions on pages",
-		  1,
-		  {{{"set",
-			 "- [page] [username] [permissions] set permisisons on page",
-			 3,
-			 {},
-			 &CLIHandler::pageperms_set_permissions}}},
-		  &CLIHandler::cli_help},
-		 {"exit",
-		  "exit cli",
-		  0,
-		  {},
-		  [](CLIHandler *, [[maybe_unused]] const std::vector<std::string> &args) -> std::pair<bool, std::string>
-		  {
-			  exit(EXIT_SUCCESS);
-			  return {true, ""};
-		  }},
-		 {"help", "print this help", 0, {}, &CLIHandler::cli_help},
-		 {"attach", "attach to running instance", 0, {}, &CLIHandler::attach},
-		 {"version", "print verison info", 0, {}, &CLIHandler::version}}};
-
-	std::pair<bool, std::string> processCommand(const std::vector<CLIHandler::cmd> &commands, std::string cmd,
-												const std::vector<std::string> &args);
-
-  public:
-	CLIHandler(Config &config, Database &d);
-	std::pair<bool, std::string> processCommand(std::string cmd, const std::vector<std::string> &args);
-	static std::pair<std::string, std::vector<std::string>> splitCommand(std::string input);
-};
-
-#endif // CLI_H

cliconsole.cpp

@@ -1,147 +0,0 @@
-#include "cliconsole.h"
-
-CLIConsole::CLIConsole(CLIHandler &cliHandler, std::string socketPath)
-{
-	this->handler = &cliHandler;
-	this->socketPath = socketPath;
-}
-
-std::pair<bool, std::string> CLIConsole::send(std::string input)
-{
-	ssize_t ret =
-		sendto(this->sock, input.c_str(), input.size(), 0, (const sockaddr *)&this->server, sizeof(this->server));
-	if((size_t)ret != input.size())
-	{
-		return {false, "sendto failed: " + std::to_string(ret) + " " + std::string(strerror(errno))};
-	}
-	char buffer[1024] = {0};
-	ret = recvfrom(this->sock, buffer, sizeof(buffer) - 1, 0, NULL, NULL);
-	if(ret == -1)
-	{
-		return {false, "recvfrom failed: " + std::string(strerror(errno))};
-	}
-
-	bool success = false;
-	std::string_view view = buffer;
-	if(view[0] == '1')
-	{
-		success = true;
-	}
-	view.remove_prefix(1);
-	std::string msg = std::string{view};
-
-	return {success, msg};
-}
-
-void CLIConsole::attach()
-{
-	if(attached)
-	{
-		std::cout << "Already attached" << std::endl;
-		return;
-	}
-	if(socketPath.size() > sizeof(this->server.sun_path) - 1)
-	{
-		std::cout << "Socket path too long" << std::endl;
-		return;
-	}
-	memset(&this->server, 0, sizeof(this->server));
-	this->server.sun_family = AF_UNIX;
-	memcpy(&this->server.sun_path, socketPath.c_str(), socketPath.size());
-	this->server.sun_path[socketPath.size()] = 0;
-
-	int s = socket(AF_UNIX, SOCK_DGRAM, 0);
-	if(s == -1)
-	{
-		std::cout << "Failed to create socket" << strerror(errno) << std::endl;
-		return;
-	}
-	this->sock = s;
-
-	struct sockaddr_un client;
-	client.sun_family = AF_UNIX;
-	client.sun_path[0] = '\0';
-
-	int ret = bind(this->sock, (struct sockaddr *)&client, sizeof(client));
-	if(ret != 0)
-	{
-		std::cout << "bind() failed: " << strerror(errno) << std::endl;
-		return;
-	}
-	auto result = this->send("attach");
-	if(result.first)
-	{
-		std::cout << "Attached successfully: " << result.second << std::endl;
-		this->attached = true;
-	}
-	else
-	{
-		std::cout << "Attached unsuccessfully: " << result.second << std::endl;
-	}
-}
-
-void CLIConsole::startInteractive()
-{
-	std::cout << "qswiki CLI" << std::endl;
-	std::cout << "not attached - use 'attach' to connect to running instance" << std::endl;
-
-	while(true)
-	{
-		std::string input;
-		std::cout << "> ";
-		std::getline(std::cin, input);
-
-		if(std::cin.bad() || std::cin.eof())
-		{
-			std::cout << "Exiting" << std::endl;
-			return;
-		}
-		if(input.empty())
-		{
-			continue;
-		}
-
-		auto pair = CLIHandler::splitCommand(input);
-		if(pair.first == "exit")
-		{
-			if(attached)
-			{
-				std::cout << "You are attached. Quit attached instance too (y) or only this one(n)" << std::endl;
-				char response;
-				std::cin >> response;
-				if(response == 'y')
-				{
-					this->send("exit");
-				}
-			}
-			std::cout << "Exiting CLI" << std::endl;
-			exit(EXIT_SUCCESS);
-		}
-		if(pair.first == "attach")
-		{
-			attach();
-			continue;
-		}
-
-		std::pair<bool, std::string> result;
-		if(!attached)
-		{
-			result = handler->processCommand(pair.first, pair.second);
-		}
-		else
-		{
-			result = this->send(input);
-		}
-
-		if(!result.second.empty())
-		{
-			std::cout << result.second << std::endl;
-		}
-		if(!result.first)
-		{
-			std::cout << "Command failed" << std::endl;
-		}
-	}
-
-	std::cout << "\n";
-}

cliconsole.h

@@ -1,27 +0,0 @@
-#ifndef CLICONSOLE_H
-#define CLICONSOLE_H
-
-#include <iostream>
-#include <string>
-#include <vector>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include "cli.h"
-
-class CLIConsole
-{
-  private:
-	struct sockaddr_un server;
-	int sock;
-	CLIHandler *handler;
-	std::string socketPath;
-	bool attached = false;
-	std::pair<bool, std::string> send(std::string input);
-	void attach();
-
-  public:
-	CLIConsole(CLIHandler &cliHandler, std::string socketPath);
-	void startInteractive();
-};
-
-#endif // CLICONSOLE_H

cliserver.cpp

@@ -1,77 +0,0 @@
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>
-#include "cliserver.h"
-#include "logger.h"
-CLIServer::CLIServer(CLIHandler &handler)
-{
-	this->handler = &handler;
-}
-
-bool CLIServer::detachServer(std::string socketpath)
-{
-	struct sockaddr_un name;
-	const int max_socket_length = sizeof(name.sun_path) - 1;
-	if(socketpath.size() > max_socket_length)
-	{
-		perror("socket path too long");
-		return false;
-	}
-	int s = socket(AF_UNIX, SOCK_DGRAM, 0);
-	if(s == -1)
-	{
-		perror("socket");
-		return false;
-	}
-
-	memset(&name, 0, sizeof(name));
-	name.sun_family = AF_UNIX;
-	memcpy(&name.sun_path, socketpath.c_str(), socketpath.size());
-
-	unlink(socketpath.c_str());
-	int ret = bind(s, (const struct sockaddr *)&name, sizeof(name));
-	if(ret == -1)
-	{
-		perror("bind");
-		exit(EXIT_FAILURE);
-	}
-
-	auto worker = [this, s]
-	{
-		while(true)
-		{
-			char buffer[1024] = {0};
-			struct sockaddr_un peer;
-			socklen_t peerlen = sizeof(peer);
-
-			int ret = recvfrom(s, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &peerlen);
-			if(ret == -1)
-			{
-				Logger::error() << "Error during recvfrom in CLI server: " << strerror(errno);
-				return false;
-			}
-
-			std::string input{buffer};
-
-			auto pair = CLIHandler::splitCommand(input);
-
-			auto result = handler->processCommand(pair.first, pair.second);
-			char resultCode = '0';
-			if(result.first)
-			{
-				resultCode = '1';
-			}
-			std::string resultString;
-			resultString += resultCode;
-			resultString += result.second;
-			ret = sendto(s, resultString.c_str(), resultString.size(), 0, (struct sockaddr *)&peer, peerlen);
-			if(ret == -1)
-			{
-				Logger::error() << "Error during sendto in CLI server: " << strerror(errno);
-			}
-		}
-	};
-	std::thread t1{worker};
-	t1.detach();
-	return true;
-}

cliserver.h

@@ -1,16 +0,0 @@
-#ifndef CLISERVER_H
-#define CLISERVER_H
-#include <thread>
-#include "cli.h"
-
-class CLIServer
-{
-  private:
-	CLIHandler *handler = nullptr;
-
-  public:
-	CLIServer(CLIHandler &handler);
-	bool detachServer(std::string socketpath);
-};
-
-#endif // CLISERVER_H

config.cpp

@@ -24,7 +24,6 @@ SOFTWARE.
 #include "config.h"
 #include "permissions.h"
 #include "varreplacer.h"
-
 std::string Config::required(const std::string &key)
 {
 	auto it = this->configmap.find(key);
@@ -72,22 +71,20 @@ Config::Config(const std::map<std::string, std::string> &map)
 
 	this->configmap = map;
 	this->wikipath = optional("wikipath", "/");
+	this->parser = optional("parser", "markdown");
 	this->handlersConfig.anon_username = optional("anon_username", "anonymouse");
 	this->handlersConfig.wikiname = required("wikiname");
 	this->logfile = required("logfile");
 	this->templatepath = required("templatepath");
 	this->urls.linkallcats = required("linkallcats");
 	this->urls.linkallpages = required("linkallpages");
-	this->urls.linkallpagesrendertype = required ("linkallpagesrendertype");
 	this->urls.linkcategory = required("linkcategory");
-	this->urls.linkcategoryrendertype = required("linkcategoryrendertype");
 	this->urls.linkdelete = required("linkdelete");
 	this->urls.linkedit = required("linkedit");
 	this->urls.linkhistory = required("linkhistory");
 	this->urls.linkindex = required("linkindex");
 	this->urls.linklogout = required("linklogout");
 	this->urls.linkpage = required("linkpage");
-	this->urls.linkpagebytitle = required("linkpagebytitle");
 	this->urls.linkrecent = required("linkrecent");
 	this->urls.linkrevision = required("linkrevision");
 	this->urls.linksettings = required("linksettings");
@@ -100,8 +97,6 @@ Config::Config(const std::map<std::string, std::string> &map)
 	this->urls.deletionurl = required("deletionurl");
 	this->urls.adminregisterurl = required("adminregisterurl");
 	this->urls.usersettingsurl = required("usersettingsurl");
-	this->urls.rooturl = required("rooturl");
-	this->urls.atomurl = required("atomurl");
 	this->connectionstring = required("connectionstring");
 
 	this->handlersConfig.max_pagename_length = optional("max_pagename_length", 256);
@@ -114,7 +109,7 @@ Config::Config(const std::map<std::string, std::string> &map)
 
 	this->templateprefix = "{qswiki:";
 
-	this->max_payload_length = optional("max_payload_length", 60 * 1024 * 1024);
+	this->max_payload_length = optional("max_payload_length", 10 * 1024 * 1024);
 
 	ConfigVariableResolver resolver{this->configmap};
 	this->configVarResolver = resolver;

config.h

@@ -23,11 +23,9 @@ struct ConfigUrls
 	std::string linkindex;
 	std::string linkrecent;
 	std::string linkallpages;
-	std::string linkallpagesrendertype;
 	std::string linkallcats;
 	std::string linkshere;
 	std::string linkpage;
-	std::string linkpagebytitle;
 	std::string linkrevision;
 	std::string linkhistory;
 	std::string linkedit;
@@ -35,7 +33,6 @@ struct ConfigUrls
 	std::string linkdelete;
 	std::string linklogout;
 	std::string linkcategory;
-	std::string linkcategoryrendertype;
 	std::string loginurl;
 	std::string linkrecentsort;
 	std::string actionurl;
@@ -44,8 +41,6 @@ struct ConfigUrls
 	std::string linkhistorysort;
 	std::string adminregisterurl;
 	std::string usersettingsurl;
-	std::string rooturl;
-	std::string atomurl;
 };
 
 class ConfigVariableResolver
@@ -91,6 +86,7 @@ class Config
 	std::string templateprefix;
 	std::string logfile;
 	std::string connectionstring;
+	std::string parser;
 	int session_max_lifetime;
 	int threadscount;
 

database/categorydao.h

@@ -5,7 +5,7 @@
 #include <optional>
 #include "queryoption.h"
 #include "../category.h"
-#include "../page.h"
+
 class CategoryDao
 {
   public:
@@ -14,8 +14,7 @@ class CategoryDao
 	virtual std::vector<std::string> fetchList(QueryOption o) = 0;
 	virtual std::optional<Category> find(std::string name) = 0;
 	virtual void deleteCategory(std::string name) = 0;
-	virtual std::vector<Page> fetchMembers(std::string name, QueryOption o) = 0;
+	virtual std::vector<std::string> fetchMembers(std::string name, QueryOption o) = 0;
-	virtual ~CategoryDao() = default;
 };
 
 #endif // CATEGORYDAO_H

database/categorydaosqlite.cpp

@@ -42,7 +42,6 @@ std::optional<Category> CategoryDaoSqlite::find(std::string name)
 	{
 		throwFrom(e);
 	}
-	return {};
 }
 
 void CategoryDaoSqlite::save(const Category &c)
@@ -65,14 +64,13 @@ void CategoryDaoSqlite::deleteCategory(std::string name)
 	try
 	{
 
-		*db << "BEGIN;";
+		*db << "BEGIN";
-		*db << "DELETE FROM categorymember WHERE category = (SELECT id FROM category WHERE name = ?);" << name;
+		*db << "DELETE FROM categorymember WHERE catid = (SELECT id FROM category WHERE name = ?)" << name;
-		*db << "DELETE FROM category WHERE name = ?;" << name;
+		*db << "DELETE FROM category WHERE name = ?" << name;
 		*db << "COMMIT;";
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
-		*db << "ROLLBACK";
 		throwFrom(e);
 	}
 }
@@ -95,36 +93,21 @@ std::vector<std::string> CategoryDaoSqlite::fetchList(QueryOption o)
 	}
 	return result;
 }
-
+std::vector<std::string> CategoryDaoSqlite::fetchMembers(std::string name, QueryOption o)
-std::vector<Page> CategoryDaoSqlite::fetchMembers(std::string name, QueryOption o)
 {
-	std::vector<Page> result;
+	std::vector<std::string> result;
 
 	SqliteQueryOption queryOption{o};
 	std::string queryoptions =
-		queryOption.setOrderByColumn("name").setListedColumnName("page.listed").setPrependWhere(false).build();
+		queryOption.setOrderByColumn("name").setVisibleColumnName("page.visible").setPrependWhere(false).build();
 
 	try
 	{
-		auto query =
+		auto query = *db << "SELECT page.name AS name FROM categorymember INNER JOIN page ON page.id = "
-			*db
-			<< "SELECT page.id, page.name AS name, page.title, page.lastrevision, page.listed, page.feedlisted FROM "
-			   "categorymember INNER JOIN page ON page.id = "
 							"categorymember.page WHERE category = (SELECT id FROM category WHERE name = ? ) AND " +
 								queryoptions
 						 << name;
-		query >> [&](unsigned int id, std::string name, std::string title, unsigned int lastrevision, bool listed,
+		query >> [&](std::string p) { result.push_back(p); };
-					 bool feedlisted)
-		{
-			Page p;
-			p.name = name;
-			p.pageid = id;
-			p.title = title;
-			p.current_revision = lastrevision;
-			p.listed = listed;
-			p.feedlisted = feedlisted;
-			result.push_back(p);
-		};
 	}
 	catch(const sqlite::exceptions::no_rows &e)
 	{

database/categorydaosqlite.h

@@ -3,13 +3,12 @@
 
 #include "categorydao.h"
 #include "sqlitedao.h"
-#include "../page.h"
 class CategoryDaoSqlite : public CategoryDao, protected SqliteDao
 {
   public:
 	CategoryDaoSqlite();
 	std::vector<std::string> fetchList(QueryOption o) override;
-	std::vector<Page> fetchMembers(std::string name, QueryOption o) override;
+	std::vector<std::string> fetchMembers(std::string name, QueryOption o) override;
 	void save(const Category &c) override;
 	void deleteCategory(std::string name) override;
 	std::optional<Category> find(std::string name) override;

database/database.h

@@ -13,7 +13,7 @@
 #include "permissionsdao.h"
 class Database
 {
-  protected:
+  private:
 	std::string connnectionstring;
 
   public:

database/pagedao.h

@@ -13,9 +13,8 @@ class PageDao
 	virtual bool exists(std::string page) const = 0;
 	virtual bool exists(unsigned int id) const = 0;
 	virtual std::optional<Page> find(std::string name) = 0;
-	virtual std::optional<Page> findByTitle(std::string title) = 0;
 	virtual std::optional<Page> find(unsigned int id) = 0;
-	virtual std::vector<Page> getPageList(QueryOption option) = 0;
+	virtual std::vector<std::string> getPageList(QueryOption option) = 0;
 	virtual std::vector<std::string> fetchCategories(std::string pagename, QueryOption option) = 0;
 	virtual void deletePage(std::string page) = 0;
 	virtual void save(const Page &page) = 0;
@@ -23,8 +22,6 @@ class PageDao
 	virtual void setCategories(std::string pagename, const std::vector<std::string> &catnames) = 0;
 	virtual std::vector<SearchResult> search(std::string query, QueryOption option) = 0;
 
-	virtual std::vector<std::string> getChildren(std::string pagename) = 0;
-
 	virtual ~PageDao()
 	{
 	}

database/pagedaosqlite.cpp

@@ -52,43 +52,15 @@ std::optional<Page> PageDaoSqlite::find(std::string name)
 	}
 }
 
-std::optional<Page> PageDaoSqlite::findByTitle(std::string title)
-{
-	Page result;
-	try
-	{
-		auto ps =
-			*db
-			<< "SELECT id, name, title, lastrevision, listed, feedlisted, (SELECT name FROM page WHERE id = parent) "
-			   "FROM page WHERE title = ?";
-		ps << title >> std::tie(result.pageid, result.name, result.title, result.current_revision, result.listed,
-								result.feedlisted, result.parentpage);
-	}
-	catch(const sqlite::errors::no_rows &e)
-	{
-		return {};
-	}
-	catch(sqlite::sqlite_exception &e)
-	{
-		throwFrom(e);
-	}
-
-	return result;
-}
-
 std::optional<Page> PageDaoSqlite::find(unsigned int id)
 {
 	Page result;
 	result.pageid = id;
 	try
 	{
-		auto ps =
+		auto ps = *db << "SELECT name, lastrevision, visible FROM page WHERE id = ?";
-			*db
-			<< "SELECT name, title, lastrevision, listed, feedlisted, (SELECT name FROM page WHERE id = parent) FROM "
-			   "page WHERE id = ?";
 
-		ps << id >> std::tie(result.name, result.title, result.current_revision, result.listed, result.feedlisted,
+		ps << id >> std::tie(result.name, result.current_revision, result.listed);
-							 result.parentpage);
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -117,7 +89,6 @@ void PageDaoSqlite::deletePage(std::string page)
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
-		*db << "ROLLBACK";
 		throwFrom(e);
 	}
 }
@@ -126,44 +97,30 @@ void PageDaoSqlite::save(const Page &page)
 {
 	try
 	{
-		*db << "INSERT OR REPLACE INTO page (id, name, title, lastrevision, listed, feedlisted, parent) VALUES((SELECT "
+		*db << "INSERT OR REPLACE INTO page (id, name, lastrevision, visible) VALUES((SELECT id FROM page WHERE name = "
-			   "id FROM page WHERE name = ? OR id = ?), ?, ?, ?, ?, ?, (SELECT id FROM page WHERE name = ?))"
+			   "? OR id = ?), ?, ?, ?)"
-			<< page.name << page.pageid << page.name << page.title << page.current_revision << page.listed
+			<< page.name << page.pageid << page.name << page.current_revision << page.listed;
-			<< page.feedlisted << page.parentpage;
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
 		throwFrom(e);
 	}
 }
-
+std::vector<std::string> PageDaoSqlite::getPageList(QueryOption option)
-std::vector<Page> PageDaoSqlite::getPageList(QueryOption option)
 {
-	std::vector<Page> result;
+	std::vector<std::string> result;
 
 	try
 	{
+
 		std::string queryOption = SqliteQueryOption(option)
 									  .setOrderByColumn("lower(name)")
-									  .setListedColumnName("listed")
+									  .setVisibleColumnName("visible")
 									  .setPrependWhere(true)
 									  .build();
-		std::string query = "SELECT id, name, title, lastrevision, listed, feedlisted,  (SELECT name FROM page WHERE "
+		std::string query = "SELECT name FROM page " + queryOption;
-							"id = parent) FROM page " +
+
-							queryOption;
+		*db << query >> [&](std::string name) { result.push_back(name); };
-		*db << query >> [&](unsigned int pageid, std::string name, std::string title, unsigned int current_revision,
-							bool listed, bool feedlisted, std::string parent)
-		{
-			Page tmp;
-			tmp.pageid = pageid;
-			tmp.name = name;
-			tmp.title = title;
-			tmp.current_revision = current_revision;
-			tmp.listed = listed;
-			tmp.feedlisted = feedlisted;
-			tmp.parentpage = parent;
-			result.push_back(tmp);
-		};
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -226,8 +183,7 @@ std::vector<SearchResult> PageDaoSqlite::search(std::string name, QueryOption op
 		auto query =
 			*db << "SELECT page.name FROM search INNER JOIN page ON search.page = page.id WHERE search MATCH ? "
 				<< ftsEscape(name);
-		query >> [&](std::string pagename)
+		query >> [&](std::string pagename) {
-		{
 			SearchResult sresult;
 			sresult.pagename = pagename;
 			sresult.query = name;
@@ -274,11 +230,3 @@ int PageDaoSqlite::fetchPageId(std::string pagename)
 	auto binder = *db << "SELECT id FROM page WHERE name = ?" << pagename;
 	return execInt(binder);
 }
-
-std::vector<std::string> PageDaoSqlite::getChildren(std::string pagename)
-{
-	std::vector<std::string> result;
-	auto query = *db << "SELECT name FROM page WHERE parent = (SELECT id FROM page WHERE name = ?)" << pagename;
-	query >> [&](std::string page) { result.push_back(page); };
-	return result;
-}

database/pagedaosqlite.h

@@ -20,16 +20,13 @@ class PageDaoSqlite : public PageDao, protected SqliteDao
 	bool exists(std::string name) const override;
 	void save(const Page &page) override;
 	std::optional<Page> find(std::string name) override;
-	std::optional<Page> findByTitle(std::string title) override;
 	std::optional<Page> find(unsigned int id) override;
-	std::vector<Page> getPageList(QueryOption option) override;
+	std::vector<std::string> getPageList(QueryOption option) override;
 	std::vector<std::string> fetchCategories(std::string pagename, QueryOption option) override;
 	using SqliteDao::SqliteDao;
 	int fetchPageId(std::string pagename);
 	std::vector<SearchResult> search(std::string query, QueryOption option) override;
 	void setCategories(std::string pagename, const std::vector<std::string> &catnames) override;
-	std::vector<std::string> getChildren(std::string pagename) override;
-
 };
 
 #endif // PAGEDAOSQLITE_H

database/permissionsdao.h

@@ -1,6 +1,5 @@
 #ifndef PERMISSIONSDAO_H
 #define PERMISSIONSDAO_H
-#include <optional>
 #include "../permissions.h"
 #include "../user.h"
 class PermissionsDao
@@ -8,10 +7,6 @@ class PermissionsDao
   public:
 	PermissionsDao();
 	virtual std::optional<Permissions> find(std::string pagename, std::string username) = 0;
-	virtual void save(std::string pagename, std::string username, Permissions perms) = 0;
-	virtual void clearForPage(std::string pagename) = 0;
-
-	virtual ~PermissionsDao() = default;
 };
 
 #endif // PERMISSIONSDAO_H

database/permissionsdaosqlite.cpp

@@ -41,34 +41,3 @@ std::optional<Permissions> PermissionsDaoSqlite::find(std::string pagename, std:
 
 	return Permissions{permissions};
 }
-
-void PermissionsDaoSqlite::save(std::string pagename, std::string username, Permissions perms)
-{
-	try
-	{
-		auto query =
-			*db
-			<< "INSERT OR REPLACE INTO permissions (id, permissions, userid, page) VALUES((SELECT id FROM permissions "
-			   "WHERE page = (SELECT id FROM page WHERE name = ?) AND userid = (SELECT id FROM user WHERE username = "
-			   "?)), ?, (SELECT id FROM user WHERE username = ?), (SELECT id FROM page WHERE name = ?))";
-		query << pagename << username << perms.getPermissions() << username << pagename;
-		query.execute();
-	}
-	catch(const sqlite::errors::no_rows &e)
-	{
-		throwFrom(e);
-	}
-}
-
-void PermissionsDaoSqlite::clearForPage(std::string pagename)
-{
-	try
-	{
-		auto stmt = *db << "DELETE FROM permissions WHERE page = (SELECT id FROM page WHERE name = ?)" << pagename;
-		stmt.execute();
-	}
-	catch(sqlite::sqlite_exception &e)
-	{
-		throwFrom(e);
-	}
-}

database/permissionsdaosqlite.h

@@ -9,8 +9,6 @@ class PermissionsDaoSqlite : public PermissionsDao, protected SqliteDao
 	PermissionsDaoSqlite();
 
 	std::optional<Permissions> find(std::string pagename, std::string username) override;
-	virtual void save(std::string pagename, std::string username, Permissions perms) override;
-	virtual void clearForPage(std::string pagename) override;
 	using SqliteDao::SqliteDao;
 };
 

database/queryoption.h

@@ -13,7 +13,7 @@ class QueryOption
 	unsigned int offset = 0;
 	unsigned int limit = 0;
 	SORT_ORDER order = ASCENDING;
-	bool includeUnlisted = true;
+	bool includeInvisible = true;
 };
 
 #endif // QUERYOPTION_H

database/revisiondaosqlite.cpp

@@ -52,7 +52,7 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisions(QueryOption &options)
 	{
 		SqliteQueryOption queryOption{options};
 		std::string queryOptionSql = queryOption.setPrependWhere(true)
-										 .setListedColumnName("page.listed")
+										 .setVisibleColumnName("page.visible")
 										 .setOrderByColumn("creationtime")
 										 .build();
 		auto query =
@@ -61,8 +61,7 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisions(QueryOption &options)
 			   "page.name, revisionid FROM revision INNER JOIN page ON revision.page = page.id " +
 				   queryOptionSql;
 		query >> [&](std::string author, std::string comment, std::string content, time_t creationtime,
-					 std::string page, unsigned int revisionid)
+					 std::string page, unsigned int revisionid) {
-		{
 			Revision r;
 			r.author = author;
 			r.comment = comment;
@@ -92,7 +91,7 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisionsForPage(std::string page
 	{
 		SqliteQueryOption queryOption{option};
 		std::string queryOptionSql = queryOption.setPrependWhere(false)
-										 .setListedColumnName("page.listed")
+										 .setVisibleColumnName("page.visible")
 										 .setOrderByColumn("creationtime")
 										 .build();
 		auto query = *db << "SELECT (SELECT username FROM user WHERE id = author), comment, content, "
@@ -102,8 +101,7 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisionsForPage(std::string page
 						 << pagename;
 
 		query >> [&](std::string author, std::string comment, std::string content, time_t creationtime,
-					 std::string page, unsigned int revisionid)
+					 std::string page, unsigned int revisionid) {
-		{
 			Revision r;
 			r.author = author;
 			r.comment = comment;
@@ -131,9 +129,9 @@ std::optional<Revision> RevisionDaoSqlite::getCurrentForPage(std::string pagenam
 	try
 	{
 		auto query = *db << "SELECT (SELECT username FROM user WHERE id = author), comment, content, "
-							"strftime('%s',creationtime), page.name, revisionid FROM revision INNER JOIN page ON "
+							"strftime('%s',creationtime), page, revisionid FROM revision WHERE page = (SELECT id FROM "
-							"revision.page = page.id WHERE page.name = ? AND page.lastrevision = revision.revisionid";
+							"page WHERE name = ? ) AND revisionid = (SELECT lastrevision FROM page WHERE name = ?)";
-		query << pagename;
+		query << pagename << pagename;
 		query >>
 			std::tie(result.author, result.comment, result.content, result.timestamp, result.page, result.revision);
 	}
@@ -157,8 +155,7 @@ std::optional<Revision> RevisionDaoSqlite::getRevisionForPage(std::string pagena
 		auto query =
 			*db
 			<< "SELECT (SELECT username FROM user WHERE id = author), comment, content, strftime('%s',creationtime), "
-			   "page.name, revisionid FROM revision INNER JOIN page ON revision.page = page.id WHERE page.name = ? AND "
+			   "page, revisionid FROM revision WHERE page = (SELECT id FROM page WHERE name = ? ) AND revisionid = ?";
-			   "revisionid = ?  ";
 		query << pagename << revision;
 		query >>
 			std::tie(result.author, result.comment, result.content, result.timestamp, result.page, result.revision);

database/sessiondao.h

@@ -10,7 +10,6 @@ class SessionDao
 	virtual void save(const Session &session) = 0;
 	virtual std::optional<Session> find(std::string token) = 0;
 	virtual void deleteSession(std::string token) = 0;
-	virtual std::vector<Session> fetch() = 0;
 	virtual ~SessionDao()
 	{
 	}

database/sessiondaosqlite.cpp

@@ -50,29 +50,6 @@ void SessionDaoSqlite::deleteSession(std::string token)
 	}
 }
 
-void SessionDaoSqlite::fillSession(int userid, Session &sess)
-{
-	if(userid > -1)
-	{
-		UserDaoSqlite userDao{*this->db};
-		auto u = userDao.find(userid);
-		if(u)
-		{
-			sess.user = *u;
-		}
-		else
-		{
-			Logger::error() << "Session for non existent user";
-			throw DatabaseQueryException("Session for non existent user");
-		}
-	}
-	else
-	{
-		sess.user = User::Anonymous();
-	}
-	sess.loggedIn = userid != -1;
-}
-
 std::optional<Session> SessionDaoSqlite::find(std::string token)
 {
 	Session result;
@@ -85,7 +62,25 @@ std::optional<Session> SessionDaoSqlite::find(std::string token)
 		int userid;
 		q >> std::tie(userid, result.token, result.csrf_token, result.creation_time);
 
-		fillSession(userid, result);
+		if(userid > -1)
+		{
+			UserDaoSqlite userDao{this->db};
+			auto u = userDao.find(userid);
+			if(u)
+			{
+				result.user = *u;
+			}
+			else
+			{
+				Logger::error() << "Session for non existent user";
+				throw DatabaseQueryException("Session for non existent user");
+			}
+		}
+		else
+		{
+			result.user = User::Anonymous();
+		}
+		result.loggedIn = userid != -1;
 	}
 	catch(const sqlite::exceptions::no_rows &e)
 	{
@@ -97,23 +92,3 @@ std::optional<Session> SessionDaoSqlite::find(std::string token)
 	}
 	return result;
 }
-
-std::vector<Session> SessionDaoSqlite::fetch()
-{
-	std::vector<Session> result;
-
-	*db << "SELECT userid, token, csrf_token, strftime('%s', creationtime) FROM session" >>
-		[this, &result](int userid, std::string token, std::string csrf_token, time_t creationtime)
-	{
-		Session tmp;
-		tmp.csrf_token = csrf_token;
-		tmp.token = token;
-		tmp.creation_time = creationtime;
-
-		fillSession(userid, tmp);
-
-		result.push_back(tmp);
-	};
-
-	return result;
-}

database/sessiondaosqlite.h

@@ -6,15 +6,11 @@
 
 class SessionDaoSqlite : public SessionDao, protected SqliteDao
 {
-private:
-  void fillSession(int userid, Session &sess);
-
   public:
 	SessionDaoSqlite();
 	void save(const Session &session) override;
 	std::optional<Session> find(std::string token) override;
 	void deleteSession(std::string token) override;
-	std::vector<Session> fetch() override;
 	using SqliteDao::SqliteDao;
 };
 

database/sqlite.cpp

@@ -18,43 +18,23 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
-#include <atomic>
 #include "sqlite.h"
+#include "../logger.h"
 #include "pagedaosqlite.h"
 #include "revisiondaosqlite.h"
 #include "sessiondaosqlite.h"
-#include "sqlite_modern_cpp.h"
 #include "userdaosqlite.h"
 #include "categorydaosqlite.h"
+#include "exceptions.h"
 #include "permissionsdaosqlite.h"
 
-thread_local sqlite::database *Sqlite::db = nullptr;
-
-std::atomic<int> instances = 0;
 Sqlite::Sqlite(std::string path) : Database(path)
 {
-	instances++;
+	this->db = std::make_shared<sqlite::database>(path);
-	if(instances.load() > 1)
+
-	{
+	*db << "PRAGMA journal_mode=WAL;";
-		std::cerr << "temporal (yeah, right) HACK... only one instance allowed" << std::endl;
-		abort();
-	}
 }
 
-std::mutex dbmutex;
-sqlite::database &Sqlite::database() const
-{
-	if(Sqlite::db == nullptr)
-	{
-		sqlite::sqlite_config config;
-		config.flags = config.flags | sqlite::OpenFlags::FULLMUTEX;
-		std::lock_guard<std::mutex> dbguard(dbmutex);
-		Sqlite::db = new sqlite::database(this->connnectionstring, config);
-		*Sqlite::db << "PRAGMA journal_mode=WAL;";
-		*Sqlite::db << "PRAGMA busy_timeout=10000;";
-	}
-	return *Sqlite::db;
-}
 std::unique_ptr<RevisionDao> Sqlite::createRevisionDao() const
 {
 	return create<RevisionDaoSqlite>();
@@ -87,20 +67,27 @@ std::unique_ptr<PermissionsDao> Sqlite::createPermissionsDao() const
 
 void Sqlite::beginTransaction()
 {
+	if(!inTransaction)
+	{
 		*db << "begin;";
+		inTransaction = true;
+	}
 }
 
 void Sqlite::rollbackTransaction()
 {
+	if(inTransaction)
+	{
 		*db << "rollback;";
+		inTransaction = false;
+	}
 }
 
 void Sqlite::commitTransaction()
 {
+	if(inTransaction)
+	{
 		*db << "commit;";
-}
+		inTransaction = false;
-
+	}
-Sqlite::~Sqlite()
-{
-	delete this->db;
 }

database/sqlite.h

@@ -8,15 +8,14 @@
 class Sqlite : public Database
 {
   private:
-	static thread_local sqlite::database *db;
+	bool inTransaction = false;
+	std::shared_ptr<sqlite::database> db;
 
 	template <class T> std::unique_ptr<T> create() const
 	{
-		return std::make_unique<T>(database());
+		return std::make_unique<T>(db);
 	}
 
-	sqlite::database &database() const;
-
   public:
 	Sqlite(std::string path);
 	std::unique_ptr<PageDao> createPageDao() const;
@@ -28,7 +27,6 @@ class Sqlite : public Database
 	void beginTransaction();
 	void commitTransaction();
 	void rollbackTransaction();
-	virtual ~Sqlite();
 };
 
 #endif // SQLITE_H

database/sqlitedao.cpp

@@ -22,17 +22,18 @@ SOFTWARE.
 
 bool SqliteDao::execBool(sqlite::database_binder &binder) const
 {
-	bool result = false;
+	bool result;
 	try
 	{
+		bool result;
 		binder >> result;
+		return result;
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
 		// TODO: well, we may want to check whether rows have found or not and thus log this here
-		result = false;
+		return false;
 	}
-	return result;
 }
 
 int SqliteDao::execInt(sqlite::database_binder &binder) const
@@ -51,5 +52,4 @@ int SqliteDao::execInt(sqlite::database_binder &binder) const
 	{
 		throwFrom(e);
 	}
-	return 0;
 }

database/sqlitedao.h

@@ -12,20 +12,20 @@
 class SqliteDao
 {
   protected:
-	sqlite::database *db = nullptr;
+	std::shared_ptr<sqlite::database> db;
 
   public:
 	SqliteDao()
 	{
 	}
 
-	SqliteDao(sqlite::database &db)
+	SqliteDao(std::shared_ptr<sqlite::database> db)
 	{
-		this->db = &db;
+		this->db = db;
 	}
-	void setDb(sqlite::database &db)
+	void setDb(std::shared_ptr<sqlite::database> db)
 	{
-		this->db = &db;
+		this->db = db;
 	}
 
 	inline void throwFrom(const sqlite::sqlite_exception &e) const
@@ -37,8 +37,6 @@ class SqliteDao
 
 	bool execBool(sqlite::database_binder &binder) const;
 	int execInt(sqlite::database_binder &binder) const;
-
-	virtual ~SqliteDao() = default;
 };
 
 #endif // SQLITEDAO_H

database/sqlitequeryoption.cpp

@@ -31,9 +31,9 @@ SqliteQueryOption &SqliteQueryOption::setOrderByColumn(std::string name)
 	return *this;
 }
 
-SqliteQueryOption &SqliteQueryOption::setListedColumnName(std::string name)
+SqliteQueryOption &SqliteQueryOption::setVisibleColumnName(std::string name)
 {
-	this->listedColumnName = name;
+	this->visibleColumnName = name;
 	return *this;
 }
 
@@ -46,18 +46,15 @@ SqliteQueryOption &SqliteQueryOption::setPrependWhere(bool b)
 std::string SqliteQueryOption::build()
 {
 	std::string result;
+	if(!o.includeInvisible && !this->visibleColumnName.empty())
+	{
 		if(this->prependWhere)
 		{
 			result += "WHERE ";
 		}
-	if(!o.includeUnlisted && !this->listedColumnName.empty())
+		result += this->visibleColumnName + " = 1";
-	{
-		result += this->listedColumnName + " = 1";
-	}
-	else
-	{
-		result += " 1 = 1";
 	}
+
 	result += " ORDER BY " + orderByColumnName;
 	if(o.order == ASCENDING)
 	{
@@ -69,8 +66,7 @@ std::string SqliteQueryOption::build()
 	}
 	// TODO: limits for offset?
 	if(o.limit > 0)
-	{
 		result += " LIMIT " + std::to_string(o.limit) + " OFFSET " + std::to_string(o.offset);
-	}
+
 	return result;
 }

database/sqlitequeryoption.h

@@ -7,7 +7,7 @@ class SqliteQueryOption
 {
   private:
 	QueryOption o;
-	std::string listedColumnName;
+	std::string visibleColumnName;
 	std::string orderByColumnName;
 
 	bool prependWhere;
@@ -17,7 +17,7 @@ class SqliteQueryOption
 
 	SqliteQueryOption &setOrderByColumn(std::string name);
 
-	SqliteQueryOption &setListedColumnName(std::string name);
+	SqliteQueryOption &setVisibleColumnName(std::string name);
 
 	SqliteQueryOption &setPrependWhere(bool b);
 

database/userdao.h

@@ -3,7 +3,6 @@
 #include <string>
 #include <optional>
 #include "../user.h"
-#include "queryoption.h"
 class UserDao
 {
   public:
@@ -11,7 +10,6 @@ class UserDao
 	virtual bool exists(std::string username) = 0;
 	virtual std::optional<User> find(std::string username) = 0;
 	virtual std::optional<User> find(int id) = 0;
-	virtual std::vector<User> list(QueryOption o) = 0;
 	virtual void deleteUser(std::string username) = 0;
 	virtual void save(const User &u) = 0;
 	virtual ~UserDao(){};

database/userdaosqlite.cpp

@@ -23,7 +23,6 @@ SOFTWARE.
 #include <memory>
 #include <cstring>
 #include "userdaosqlite.h"
-#include "sqlitequeryoption.h"
 
 UserDaoSqlite::UserDaoSqlite()
 {
@@ -37,6 +36,7 @@ bool UserDaoSqlite::exists(std::string username)
 
 std::optional<User> UserDaoSqlite::find(std::string username)
 {
+
 	try
 	{
 		User user;
@@ -47,7 +47,7 @@ std::optional<User> UserDaoSqlite::find(std::string username)
 		stmt >> std::tie(user.login, user.password, user.salt, perms, user.enabled);
 		user.permissions = Permissions{perms};
 
-		return user;
+		return std::move(user);
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -57,7 +57,6 @@ std::optional<User> UserDaoSqlite::find(std::string username)
 	{
 		throwFrom(e);
 	}
-	return {};
 }
 
 std::optional<User> UserDaoSqlite::find(int id)
@@ -71,7 +70,7 @@ std::optional<User> UserDaoSqlite::find(int id)
 		stmt >> std::tie(user.login, user.password, user.salt, perms, user.enabled);
 		user.permissions = Permissions{perms};
 
-		return user;
+		return std::move(user);
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -81,43 +80,9 @@ std::optional<User> UserDaoSqlite::find(int id)
 	{
 		throwFrom(e);
 	}
-	return {};
 }
 
-std::vector<User> UserDaoSqlite::list(QueryOption o)
+void UserDaoSqlite::deleteUser(std::string username)
-{
-	std::vector<User> result;
-
-	try
-	{
-
-		std::string queryOption = SqliteQueryOption(o).setOrderByColumn("username").setPrependWhere(true).build();
-		std::string query = "SELECT username, password, salt, permissions, enabled FROM user " + queryOption;
-
-		*db << query >>
-			[&](std::string username, std::vector<char> pw, std::vector<char> salt, int permisisons, bool enabled)
-		{
-			User tmp;
-			tmp.login = username;
-			tmp.password = pw;
-			tmp.salt = salt;
-			tmp.permissions = Permissions{permisisons};
-			tmp.enabled = enabled;
-			result.push_back(tmp);
-		};
-	}
-	catch(const sqlite::errors::no_rows &e)
-	{
-		return result;
-	}
-	catch(sqlite::sqlite_exception &e)
-	{
-		throwFrom(e);
-	}
-	return result;
-}
-
-void UserDaoSqlite::deleteUser([[maybe_unused]] std::string username)
 {
 	// What to do with the contributions of the user?
 }

database/userdaosqlite.h

@@ -13,7 +13,6 @@ class UserDaoSqlite : public UserDao, protected SqliteDao
 	std::optional<User> find(std::string username);
 	std::optional<User> find(int id);
 
-	std::vector<User> list(QueryOption o);
 	void deleteUser(std::string username);
 	void save(const User &u);
 	using SqliteDao::SqliteDao;

dynamic/dynamiccontent.cpp

@@ -1,9 +0,0 @@
-#include "dynamiccontent.h"
-
-DynamicContent::DynamicContent(Template &templ, Database &database, UrlProvider &provider, Session &session)
-{
-	this->templ = &templ;
-	this->database = &database;
-	this->urlProvider = &provider;
-	this->userSession = &session;
-}

dynamic/dynamiccontent.h

@@ -1,29 +0,0 @@
-#ifndef DYNAMICCONTENT_H
-#define DYNAMICCONTENT_H
-#include <string>
-#include "../database/database.h"
-#include "../template.h"
-#include "../urlprovider.h"
-class DynamicContent
-{
-  protected:
-	Template *templ;
-	Database *database;
-	UrlProvider *urlProvider;
-	Session *userSession;
-
-	std::string argument;
-
-  public:
-	DynamicContent(Template &templ, Database &database, UrlProvider &urlProvider, Session &session);
-	virtual std::string render() = 0;
-	virtual void setArgument(std::string argument)
-	{
-		this->argument = argument;
-	}
-	virtual ~DynamicContent()
-	{
-	}
-};
-
-#endif // DYNAMICCONTENT_H

dynamic/dynamiccontentfactory.h

@@ -1,30 +0,0 @@
-#ifndef DYNAMICCONTENTFACTORY_H
-#define DYNAMICCONTENTFACTORY_H
-
-#include "dynamiccontent.h"
-
-class DynamicContentFactory
-{
-private:
-	Template *templ;
-	Database *db;
-	UrlProvider *urlProvider;
-	Session *session;
-	
-public:
-	DynamicContentFactory(Template &templ, Database &db, UrlProvider &urlProvider, Session &session)
-	{
-		this->templ = &templ;
-		this->db = &db;
-		this->urlProvider = &urlProvider;
-		this->session = &session;
-	}
-	
-	template <class T> inline std::shared_ptr<T> createDynamicContent()
-	{
-		return std::make_shared<T>(*this->templ, *this->db, *this->urlProvider, *this->session);
-	}
-	
-	
-};
-#endif // DYNAMICCONTENTFACTORY_H_INCLUDED

dynamic/dynamiccontentgetvar.cpp

@@ -1,11 +0,0 @@
-#include "dynamiccontentgetvar.h"
-
-std::string DynamicContentGetVar::render()
-{
-	return (*this->map)[this->argument];
-}
-
-void DynamicContentGetVar::setMap(std::map<std::string, std::string> &map)
-{
-	this->map = &map;
-}

dynamic/dynamiccontentgetvar.h

@@ -1,19 +0,0 @@
-#ifndef DYNAMICCONTENTGETVAR_H
-#define DYNAMICCONTENTGETVAR_H
-
-#include "dynamiccontent.h"
-class DynamicContentGetVar : public DynamicContent
-{
-  private:
-	std::map<std::string, std::string> *map;
-
-  public:
-	using DynamicContent::DynamicContent;
-
-	// DynamicContent interface
-  public:
-	std::string render();
-	void setMap(std::map<std::string, std::string> &map);
-};
-
-#endif // DYNAMICCONTENTGETVAR_H

dynamic/dynamiccontentincludepage.cpp

@@ -1,16 +0,0 @@
-#include "dynamiccontentincludepage.h"
-#include "../parser.h"
-std::string DynamicContentIncludePage::render()
-{
-	auto revisionDao = this->database->createRevisionDao();
-	auto rev = revisionDao->getCurrentForPage(this->argument);
-	if(rev)
-	{
-		/* Quite dirty */
-		if(rev->content.find("[cmd:allowinclude]1[") != std::string::npos)
-		{
-			return rev->content;
-		}
-	}
-	return {};
-}

dynamic/dynamiccontentincludepage.h

@@ -1,12 +0,0 @@
-#ifndef DYNAMICCONTENTINCLUDEPAGE_H
-#define DYNAMICCONTENTINCLUDEPAGE_H
-#include "dynamiccontent.h"
-class DynamicContentIncludePage : public DynamicContent
-{
-  public:
-	using DynamicContent::DynamicContent;
-
-	std::string render();
-};
-
-#endif // DYNAMICCONTENTINCLUDEPAGE_H

dynamic/dynamiccontentpostlist.cpp

@@ -1,46 +0,0 @@
-#include <chrono>
-#include "dynamiccontentpostlist.h"
-
-std::string DynamicContentPostList::render()
-{
-	auto categoryDao = this->database->createCategoryDao();
-	auto pageDao = this->database->createPageDao();
-	auto revisionDao = this->database->createRevisionDao();
-	auto permissionDao = this->database->createPermissionsDao();
-
-	QueryOption option;
-	option.includeUnlisted = false;
-	auto members = categoryDao->fetchMembers(this->argument, option);
-	std::vector<std::pair<std::string, time_t>> pageList;
-	for(const Page &member : members)
-	{
-		Permissions perms = permissionDao->find(member.name, this->userSession->user.login)
-								.value_or(this->userSession->user.permissions);
-		if(perms.canRead()) /* TODO: Maybe add canList() */
-		{
-			auto revision = revisionDao->getRevisionForPage(member.name, 1);
-			pageList.push_back({member.name, revision->timestamp});
-		}
-	}
-	std::sort(pageList.begin(), pageList.end(),
-			  [](std::pair<std::string, time_t> &a, std::pair<std::string, time_t> &b) { return a.second > b.second; });
-
-	std::string postListBegin = this->templ->loadResolvedPart("dynamic/postlistbegin");
-	std::string postListEnd = this->templ->loadResolvedPart("dynamic/postlistend");
-	std::string postLink = this->templ->loadResolvedPart("dynamic/postlistlink");
-	std::stringstream stream;
-	stream << postListBegin;
-	for(auto &pair : pageList)
-	{
-		std::string link = this->urlProvider->page(pair.first);
-		std::string date = utils::toISODate(pair.second);
-		Varreplacer replacer{"{"};
-		replacer.addKeyValue("url", link);
-		replacer.addKeyValue("date", date);
-		replacer.addKeyValue("title", pageDao->find(pair.first)->title);
-
-		stream << replacer.parse(postLink);
-	}
-	stream << postListEnd;
-	return stream.str();
-}

dynamic/dynamiccontentpostlist.h

@@ -1,12 +0,0 @@
-#ifndef DYNAMICCONTENTPOSTLIST_H
-#define DYNAMICCONTENTPOSTLIST_H
-
-#include "dynamiccontent.h"
-class DynamicContentPostList : public DynamicContent
-{
-  public:
-	using DynamicContent::DynamicContent;
-	std::string render() override;
-};
-
-#endif // DYNAMICCONTENTPOSTLIST_H

dynamic/dynamiccontentsetvar.cpp

@@ -1,21 +0,0 @@
-#include "dynamiccontentsetvar.h"
-
-std::string DynamicContentSetVar::render()
-{
-	auto result = utils::split(this->argument, '=');
-	if(result.size() == 2)
-	{
-		this->map->emplace(std::make_pair(result[0], result[1]));
-	}
-	return {};
-}
-
-void DynamicContentSetVar::setArgument(std::string argument)
-{
-	this->argument = argument;
-}
-
-void DynamicContentSetVar::setMap(std::map<std::string, std::string> &map)
-{
-	this->map = &map;
-}

dynamic/dynamiccontentsetvar.h

@@ -1,17 +0,0 @@
-#ifndef DYNAMCCONTENTPUSHVAR_H
-#define DYNAMCCONTENTPUSHVAR_H
-#include "dynamiccontent.h"
-class DynamicContentSetVar : public DynamicContent
-{
-  private:
-	std::map<std::string, std::string> *map;
-
-  public:
-	using DynamicContent::DynamicContent;
-
-	std::string render();
-	void setArgument(std::string argument);
-	void setMap(std::map<std::string, std::string> &map);
-};
-
-#endif // DYNAMCCONTENTPUSHVAR_H

dynamic/dynamicpostrenderer.cpp

@@ -1,73 +0,0 @@
-#include <chrono>
-#include "dynamicpostrenderer.h"
-#include "../parser.h"
-#include "../utils.h"
-
-void DynamicPostRenderer::setArgument(std::string argument)
-{
-	auto splitted = utils::split(argument, '|');
-	this->category = splitted[0];
-	if(splitted.size() >= 2)
-	{
-		this->templatepartname = splitted[1];
-	}
-	if(splitted.size() >= 3)
-	{
-		this->customlinkurl = splitted[2];
-	}
-}
-
-std::string DynamicPostRenderer::linkToPage(std::string page)
-{
-	if(this->customlinkurl.empty())
-	{
-		return this->urlProvider->page(page);
-	}
-	return utils::strreplace(this->customlinkurl, "{page}", page);
-}
-
-std::string DynamicPostRenderer::render()
-{
-	auto categoryDao = this->database->createCategoryDao();
-	auto pageDao = this->database->createPageDao();
-	auto revisionDao = this->database->createRevisionDao();
-	auto permissionDao = this->database->createPermissionsDao();
-
-	QueryOption option;
-	option.includeUnlisted = true;
-	auto members = categoryDao->fetchMembers(this->category, option);
-	std::vector<std::pair<std::string, time_t>> pageList;
-	for(const Page &member : members)
-	{
-		Permissions perms = permissionDao->find(member.name, this->userSession->user.login)
-								.value_or(this->userSession->user.permissions);
-		if(perms.canRead())
-		{
-			auto revision = revisionDao->getRevisionForPage(member.name, 1);
-			pageList.push_back({member.name, revision->timestamp});
-		}
-	}
-	std::sort(pageList.begin(), pageList.end(),
-			  [](std::pair<std::string, time_t> &a, std::pair<std::string, time_t> &b) { return a.second > b.second; });
-
-	std::string entry = this->templ->loadResolvedPart(this->templatepartname);
-	std::stringstream stream;
-	for(auto &pair : pageList)
-	{
-		std::optional<Revision> revision = revisionDao->getCurrentForPage(pair.first);
-		if(revision)
-		{
-			std::string link = linkToPage(pair.first);
-			Parser parser;
-
-			std::string date = utils::toISODateTime(revision->timestamp);
-			Varreplacer replacer{"{"};
-			replacer.addKeyValue("url", link);
-			replacer.addKeyValue("date", date);
-			replacer.addKeyValue("content", parser.parse(*pageDao, *this->urlProvider,
-														 parser.extractFirstTag("content", revision->content)));
-			stream << replacer.parse(entry);
-		}
-	}
-	return stream.str();
-}

dynamic/dynamicpostrenderer.h

@@ -1,18 +0,0 @@
-#ifndef DYNAMICPOSTRENDERER_H
-#define DYNAMICPOSTRENDERER_H
-#include "dynamiccontent.h"
-class DynamicPostRenderer : public DynamicContent
-{
-private:
-	std::string category;
-	std::string customlinkurl;
-	std::string templatepartname = "dynamic/categoryrendererentry";
-
-  public:
-	using DynamicContent::DynamicContent;
-	std::string render() override;
-	void setArgument(std::string argument) override;
-	std::string linkToPage(std::string page);
-};
-
-#endif // DYNAMICPOSTRENDERER_H

gateway/httpgateway.cpp

@@ -41,7 +41,7 @@ Request HttpGateway::convertRequest(httplib::Request request)
 	// TODO: this eats resources, where perhaps it does not need to. move it to request?
 	for(auto &it : request.params)
 	{
-		it.second = utils::html_xss(it.second);
+		it.second = utils::html_xss(std::string{it.second});
 	}
 	if(request.method == "GET")
 	{
@@ -83,8 +83,7 @@ void HttpGateway::work(RequestWorker &worker)
 {
 	httplib::Server server;
 	server.set_payload_max_length(this->maxPayloadLength);
-	auto handler = [&](const httplib::Request &req, httplib::Response &res)
+	auto handler = [&](const httplib::Request &req, httplib::Response &res) {
-	{
 		Request wikiRequest = convertRequest(req);
 		Logger::debug() << "httpgateway: received request " << wikiRequest;
 		Response wikiresponse = worker.processRequest(wikiRequest);

gateway/httpgateway.h

@@ -1,8 +1,5 @@
 #ifndef HTTPGATEWAY_H
 #define HTTPGATEWAY_H
-
-#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 65536
-
 #include <httplib.h>
 #include "gatewayinterface.h"
 #include "../requestworker.h"

grouper.h

@@ -1,26 +0,0 @@
-#include "utils.h"
-
-template<class G, class V, class C>
-class Grouper
-{
-	std::map<G, std::vector<const V*>, C> results;
-public:
-
-	Grouper(C c)
-	{
-		results = std::map<G, std::vector<const V*>, C>(c);
-	}
-
-	void group(const std::function<G(const V&)> &map, const std::vector<V> &values)
-	{
-		for(const V &v : values)
-		{
-			results[map(v)].push_back(&v);
-		}
-	}
-
-	std::map<G, std::vector<const V*>, C> &getResults()
-	{
-		return this->results;
-	}
-};

handlers/handler.cpp

@@ -34,7 +34,7 @@ void Handler::setGeneralVars(TemplatePage &page)
 }
 Response Handler::errorResponse(std::string errortitle, std::string errormessage, int status)
 {
-	TemplatePage error = this->templ->getPage("error");
+	TemplatePage &error = this->templ->getPage("error");
 	error.setVar("title", createPageTitle(errortitle));
 	error.setVar("errortitle", errortitle);
 	error.setVar("errormessage", errormessage);
@@ -53,7 +53,7 @@ std::string Handler::createPageTitle(std::string title)
 QueryOption Handler::queryOption(const Request &r, SORT_ORDER defaultSort) const
 {
 	QueryOption result;
-	result.includeUnlisted = false;
+	result.includeInvisible = false;
 	try
 	{
 		result.limit = utils::toUInt(r.get("limit"));
@@ -98,10 +98,7 @@ Response Handler::handle(const Request &r)
 
 Permissions Handler::effectivePermissions(std::string page)
 {
-	Permissions &userPerms = this->userSession->user.permissions;
+	return this->database->createPermissionsDao()
-	if(userPerms.isAdmin())
+		->find(page, this->userSession->user.login)
-	{
+		.value_or(this->userSession->user.permissions);
-		return userPerms;
-	}
-	return this->database->createPermissionsDao()->find(page, this->userSession->user.login).value_or(userPerms);
 }

handlers/handler.h

@@ -1,6 +1,5 @@
 #ifndef HANDLER_H
 #define HANDLER_H
-#include <memory>
 #include "../config.h"
 #include "../response.h"
 #include "../request.h"
@@ -10,12 +9,13 @@
 #include "../database/queryoption.h"
 #include "../logger.h"
 #include "../cache/icache.h"
-#include "../dynamic/dynamiccontent.h"
+#include "../iparser.h"
 
 class Handler
 {
   protected:
 	ICache *cache;
+	IParser *parser;
 	Template *templ;
 	Database *database;
 	Session *userSession;
@@ -28,7 +28,7 @@ class Handler
 
   public:
 	Handler(HandlerConfig &handlersConfig, Template &templ, Database &db, Session &userSession, UrlProvider &provider,
-			ICache &cache)
+			ICache &cache, IParser &parser)
 	{
 		this->handlersConfig = &handlersConfig;
 		this->templ = &templ;
@@ -36,15 +36,16 @@ class Handler
 		this->userSession = &userSession;
 		this->urlProvider = &provider;
 		this->cache = &cache;
+		this->parser = &parser;
 	}
 
 	virtual Response handle(const Request &r);
-	virtual Response handleRequest([[maybe_unused]] const Request &r)
+	virtual Response handleRequest(const Request &r)
 	{
 		return this->errorResponse("Invalid action", "This action is not implemented yet");
 	}
 
-	virtual bool canAccess([[maybe_unused]] const Permissions &perms)
+	virtual bool canAccess(const Permissions &perms)
 	{
 		return false;
 	}
@@ -56,12 +57,6 @@ class Handler
 	virtual ~Handler()
 	{
 	}
-
-	template <class T> inline std::shared_ptr<T> createDynamic()
-	{
-		return std::make_shared<T>(*this->templ, *this->database, *this->urlProvider);
-	}
-
 	Response errorResponse(std::string errortitle, std::string errormessage, int status = 200);
 	std::string createPageTitle(std::string append);
 };

handlers/handlerallcategories.cpp

@@ -32,7 +32,7 @@ Response HandlerAllCategories::handleRequest(const Request &r)
 			"No categories",
 			"This wiki does not have any categories defined yet or your query options did not yield any results");
 	}
-	TemplatePage searchPage = this->templ->getPage("allcategories");
+	TemplatePage &searchPage = this->templ->getPage("allcategories");
 	std::string body =
 		this->templ->renderSearch(resultList, [&](std::string str) { return this->urlProvider->category(str); });
 	searchPage.setVar("categorylist", body);

handlers/handlerallpages.cpp

@@ -19,8 +19,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 #include "handlerallpages.h"
-#include "../grouper.h"
-#include "../pagelistrenderer.h"
 
 Response HandlerAllPages::handleRequest(const Request &r)
 {
@@ -29,21 +27,17 @@ Response HandlerAllPages::handleRequest(const Request &r)
 		Response response;
 		auto pageDao = this->database->createPageDao();
 		QueryOption qo = queryOption(r);
-		std::vector<Page> pageList = pageDao->getPageList(qo);
+		auto resultList = pageDao->getPageList(qo);
-		if(pageList.size() == 0)
+		if(resultList.size() == 0)
 		{
 			return errorResponse("No pages", "This wiki does not have any pages yet");
 		}
-		
+		TemplatePage &searchPage = this->templ->getPage("allpages");
-		PageListRenderer pagelistrender(*this->templ, *this->urlProvider, *this->database);
+		std::string body = this->templ->renderSearch(resultList);
-		TemplatePage allPages = this->templ->getPage("allpages");
+		searchPage.setVar("pagelist", body);
-		allPages.setVar("pagelistcontent", pagelistrender.render(pageList, r.get("rendertype")));
+		searchPage.setVar("title", createPageTitle("All pages"));
-		allPages.setVar("pagelistletterlink", this->urlProvider->allPages(PageListRenderer::RENDER_GROUP_BY_LETTER));
+		setGeneralVars(searchPage);
-		allPages.setVar("pagelistcreationdatelink",  this->urlProvider->allPages(PageListRenderer::RENDER_GROUP_BY_CREATIONDATE));
+		response.setBody(searchPage.render());
-				
-		allPages.setVar("title", createPageTitle("All pages"));
-		setGeneralVars(allPages);
-		response.setBody(allPages.render());
 		response.setStatus(200);
 		return response;
 	}

handlers/handlercategory.cpp

@@ -19,7 +19,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 #include "handlercategory.h"
-#include "../pagelistrenderer.h"
 
 Response HandlerCategory::handleRequest(const Request &r)
 {
@@ -34,13 +33,9 @@ Response HandlerCategory::handleRequest(const Request &r)
 		}
 		QueryOption qo = queryOption(r);
 		auto resultList = categoryDao->fetchMembers(categoryname, qo);
-		TemplatePage searchPage = this->templ->getPage("show_category");
+		TemplatePage &searchPage = this->templ->getPage("show_category");
-		PageListRenderer pagelistrender(*this->templ, *this->urlProvider, *this->database);
+		std::string body = this->templ->renderSearch(resultList);
-
+		searchPage.setVar("pagelist", body);
-		std::string body = pagelistrender.render(resultList, r.get("rendertype"));
-		searchPage.setVar("pagelistcontent", body);
-		searchPage.setVar("pagelistletterlink", this->urlProvider->category(categoryname, PageListRenderer::RENDER_GROUP_BY_LETTER));
-		searchPage.setVar("pagelistcreationdatelink",  this->urlProvider->category(categoryname, PageListRenderer::RENDER_GROUP_BY_CREATIONDATE));
 		searchPage.setVar("categoryname", categoryname);
 		setGeneralVars(searchPage);
 		searchPage.setVar("title", createPageTitle("Category: " + categoryname));

handlers/handlerdefault.cpp

@@ -20,7 +20,7 @@ SOFTWARE.
 */
 #include "handlerdefault.h"
 
-Response HandlerDefault::handleRequest([[maybe_unused]] const Request &r)
+Response HandlerDefault::handleRequest(const Request &r)
 {
 	return Response::redirectTemporarily(this->urlProvider->index());
 }
@@ -29,7 +29,7 @@ HandlerDefault::~HandlerDefault()
 {
 }
 
-bool HandlerDefault::canAccess([[maybe_unused]] const Permissions &perms)
+bool HandlerDefault::canAccess(const Permissions &perms)
 {
 	return true;
 }

handlers/handlerfactory.cpp

@@ -33,8 +33,7 @@ SOFTWARE.
 #include "handlerhistory.h"
 #include "handlerpagedelete.h"
 #include "handlerusersettings.h"
-#include "handlerversion.h"
+
-#include "handlerfeedgenerator.h"
 std::unique_ptr<Handler> HandlerFactory::createHandler(const std::string &action, Session &userSession)
 {
 	if(action == "" || action == "index")
@@ -81,14 +80,6 @@ std::unique_ptr<Handler> HandlerFactory::createHandler(const std::string &action
 	{
 		return produce<HandlerUserSettings>(userSession);
 	}
-	if(action == "version")
-	{
-		return produce<HandlerVersion>(userSession);
-	}
-	if(action == "feed")
-	{
-		return produce<HandlerFeedGenerator>(userSession);
-	}
 
 	return produce<HandlerInvalidAction>(userSession);
 }

handlers/handlerfactory.h

@@ -10,15 +10,16 @@ class HandlerFactory
 	Database &db;
 	UrlProvider &urlProvider;
 	ICache &cache;
+	IParser &parser;
 
 	template <class T> inline std::unique_ptr<T> produce(Session &userSession)
 	{
-		return std::make_unique<T>(handlerConfig, templ, db, userSession, urlProvider, cache);
+		return std::make_unique<T>(handlerConfig, templ, db, userSession, urlProvider, cache, parser);
 	}
 
   public:
-	HandlerFactory(HandlerConfig &handlerConfig, Template &templ, Database &db, UrlProvider &urlprovider, ICache &cache)
+	HandlerFactory(HandlerConfig &handlerConfig, Template &templ, Database &db, UrlProvider &urlprovider, ICache &cache, IParser &parser)
-		: handlerConfig(handlerConfig), templ(templ), db(db), urlProvider(urlprovider), cache(cache)
+		: handlerConfig(handlerConfig), templ(templ), db(db), urlProvider(urlprovider), cache(cache), parser(parser)
 	{
 	}
 	std::unique_ptr<Handler> createHandler(const std::string &action, Session &userSession);

handlers/handlerfeedgenerator.cpp

@@ -1,157 +0,0 @@
-#include "handlerfeedgenerator.h"
-#include "../revisionrenderer.h"
-std::vector<HandlerFeedGenerator::EntryRevisionPair> HandlerFeedGenerator::fetchEntries(
-	std::vector<std::string> categories)
-{
-	auto revisionDao = this->database->createRevisionDao();
-	auto pageDao = this->database->createPageDao();
-	auto permissionDao = this->database->createPermissionsDao();
-
-	std::vector<EntryRevisionPair> result;
-	QueryOption option;
-	option.includeUnlisted = true;
-	// option.limit = 20;
-
-	auto comppage = [](const Page &a, const Page &b) { return a.name < b.name; };
-	std::set<Page, decltype(comppage)> members(comppage);
-	if(categories.empty())
-	{
-		auto pages = pageDao->getPageList(option);
-		std::copy(pages.begin(), pages.end(), std::inserter(members, members.end()));
-	}
-	else
-	{
-		auto categoryDao = this->database->createCategoryDao();
-		for(std::string cat : categories)
-		{
-			if(!categoryDao->find(cat))
-			{
-				throw std::runtime_error("No such category");
-			}
-			auto catmembers = categoryDao->fetchMembers(cat, option);
-			std::copy(catmembers.begin(), catmembers.end(), std::inserter(members, members.end()));
-		}
-	}
-	for(const Page &member : members)
-	{
-		if(member.feedlisted)
-		{
-			Permissions perms = permissionDao->find(member.name, this->userSession->user.login)
-									.value_or(this->userSession->user.permissions);
-			if(perms.canRead())
-			{
-				auto revision = revisionDao->getRevisionForPage(member.name, 1).value();
-				result.push_back({member, revision});
-			}
-		}
-	}
-	std::sort(result.begin(), result.end(),
-			  [](EntryRevisionPair &a, EntryRevisionPair &b) { return a.second.timestamp > b.second.timestamp; });
-
-	const int maxResults = 20;
-	if(result.size() > maxResults)
-	{
-		result.erase(result.begin() + maxResults - 1, result.end());
-	}
-
-	return result;
-}
-
-std::string HandlerFeedGenerator::generateAtom(const std::vector<HandlerFeedGenerator::EntryRevisionPair> &entries,
-											   std::string filter)
-{
-
-	std::stringstream stream;
-	// don't care about offset for now especially since "%z" does not return what we need exactly (with ':')
-	const std::string dateformat = "%Y-%m-%dT%T";
-
-	time_t newestPublished = 0;
-	std::string atomfooter = this->templ->loadResolvedPart("feeds/atomfooter");
-	auto revisionDao = this->database->createRevisionDao();
-	auto pageDao = this->database->createPageDao();
-
-	std::string subtitle = filter;
-	if(utils::trim(filter).empty())
-	{
-		subtitle = "All pages";
-	}
-
-	RevisionRenderer revisionRenderer{*this->templ, *this->database, *this->urlProvider, *this->userSession};
-
-	for(const EntryRevisionPair &entry : entries)
-	{
-		const Page &page = entry.first;
-		const Revision &initialRevision = entry.second;
-		Revision current = revisionDao->getCurrentForPage(page.name).value();
-		std::string url = this->urlProvider->rootUrl() + this->urlProvider->page(page.name);
-		if(initialRevision.timestamp > newestPublished)
-		{
-			newestPublished = initialRevision.timestamp;
-		}
-		std::string entryPublished = utils::formatLocalDate(initialRevision.timestamp, dateformat) + "Z";
-		std::string entryurl =
-			this->urlProvider->combine({this->urlProvider->rootUrl(), this->urlProvider->page(page.name)});
-		TemplatePage atomentry = this->templ->getPage("feeds/atomentry");
-		atomentry.setVar("entrytitle", page.title);
-		atomentry.setVar("entryurl", utils::html_xss(entryurl));
-		atomentry.setVar("entryid", utils::html_xss(entryurl));
-		atomentry.setVar("entrypublished", entryPublished);
-		atomentry.setVar("entryupdated", entryPublished);
-		atomentry.setVar("entrycontent", utils::html_xss(revisionRenderer.renderContent(current, page.title)));
-		stream << atomentry.render();
-	}
-	stream << atomfooter;
-	TemplatePage atomheader = this->templ->getPage("feeds/atomheader");
-	atomheader.setVar("subtitle", subtitle);
-	std::string selflink = utils::html_xss(this->urlProvider->atomFeed(filter));
-	atomheader.setVar("atomfeeduniqueid", selflink);
-	atomheader.setVar("atomselflink", selflink);
-	atomheader.setVar("atomfeedupdate", utils::formatLocalDate(newestPublished, dateformat) + "Z");
-	return atomheader.render() + stream.str();
-}
-
-Response HandlerFeedGenerator::handleRequest(const Request &r)
-{
-	Response response;
-	try
-	{
-		std::string type = r.get("type");
-		std::string categories = r.get("cats");
-		if(type == "atom")
-		{
-			std::string filter = categories;
-			Response result;
-			result.setStatus(200);
-			result.setContentType("application/atom+xml");
-			std::string cacheKey = "feed:atom:" + filter;
-			auto cached = this->cache->get(cacheKey);
-			if(cached)
-			{
-				result.setBody(cached.value());
-			}
-			else
-			{
-				auto entries = fetchEntries(utils::split(categories, ','));
-				std::string feed = generateAtom(entries, filter);
-				result.setBody(feed);
-				this->cache->put(cacheKey, feed);
-			}
-			response = result;
-		}
-		else
-		{
-			return errorResponse("Invalid feed type", "Unknown feed type, try atom", 400);
-		}
-	}
-	catch(std::runtime_error &e)
-	{
-		Logger::error() << "Error while serving feed: " << e.what();
-		return errorResponse("Error", "An error occured while trying to serve the feed", 500);
-	}
-	return response;
-}
-
-bool HandlerFeedGenerator::canAccess(const Permissions &perms)
-{
-	return true;
-}

handlers/handlerfeedgenerator.h

@@ -1,21 +0,0 @@
-#ifndef HANDLERFEEDGENERATOR_H
-#define HANDLERFEEDGENERATOR_H
-#include "handler.h"
-#include "../page.h"
-#include "../revision.h"
-class HandlerFeedGenerator : public Handler
-{
-	typedef std::pair<Page, Revision> EntryRevisionPair;
-
-  protected:
-	std::vector<EntryRevisionPair> fetchEntries(std::vector<std::string> categories);
-	std::string generateAtom(const std::vector<EntryRevisionPair> &entries, std::string atomtitle);
-	Response generateRss(const std::vector<EntryRevisionPair> &entries);
-
-  public:
-	using Handler::Handler;
-	Response handleRequest(const Request &r) override;
-	bool canAccess(const Permissions &perms) override;
-};
-
-#endif // HANDLERFEEDGENERATOR_H

handlers/handlerhistory.cpp

@@ -50,8 +50,7 @@ Response HandlerHistory::handleRequest(const Request &r)
 	std::vector<Revision> resultList;
 	auto revisionDao = this->database->createRevisionDao();
 
-	auto makeSortedLink = [&](unsigned int limit, unsigned int offset, unsigned int order)
+	auto makeSortedLink = [&](unsigned int limit, unsigned int offset, unsigned int order) {
-	{
 		if(!page.empty())
 		{
 			return this->urlProvider->pageHistorySort(page, limit, offset, order);
@@ -123,7 +122,7 @@ Response HandlerHistory::handleRequest(const Request &r)
 	return response;
 }
 
-bool HandlerHistory::canAccess([[maybe_unused]] const Permissions &perms)
+bool HandlerHistory::canAccess(const Permissions &perms)
 {
 	return true; // This is a lie but we need to this a little more fine grained here, which we do in the handleRequest
 }

handlers/handlerinvalidaction.cpp

@@ -20,12 +20,12 @@ SOFTWARE.
 */
 #include "handlerinvalidaction.h"
 
-Response HandlerInvalidAction::handleRequest([[maybe_unused]] const Request &r)
+Response HandlerInvalidAction::handleRequest(const Request &r)
 {
 	return errorResponse("Invalid action", "No action defined for this action");
 }
 
-bool HandlerInvalidAction::canAccess([[maybe_unused]] const Permissions &perms)
+bool HandlerInvalidAction::canAccess(const Permissions &perms)
 {
 	return true;
 }

handlers/handlerlogin.cpp

@@ -55,7 +55,7 @@ Response HandlerLogin::handleRequest(const Request &r)
 	{
 		page = "index";
 	}
-	TemplatePage loginTemplatePage = this->templ->getPage("login");
+	TemplatePage &loginTemplatePage = this->templ->getPage("login");
 	setGeneralVars(loginTemplatePage);
 	loginTemplatePage.setVar("loginurl", urlProvider->login(page));
 	loginTemplatePage.setVar("title", createPageTitle("Login"));
@@ -66,7 +66,7 @@ Response HandlerLogin::handleRequest(const Request &r)
 	return result;
 }
 
-bool HandlerLogin::canAccess([[maybe_unused]] const Permissions &perms)
+bool HandlerLogin::canAccess(const Permissions &perms)
 {
 	return true;
 }

handlers/handlerpage.cpp

@@ -26,20 +26,9 @@ Response HandlerPage::handle(const Request &r)
 	std::string pagename = r.get("page");
 	auto pageDao = this->database->createPageDao();
 	if(pagename.empty())
-	{
-		std::string title = r.get("title");
-		if(title.empty())
 	{
 		return errorResponse("No page given", "No page given to request");
 	}
-		title = utils::strreplace(title, "-", " ");
-		auto page = pageDao->findByTitle(title);
-		if(!page)
-		{
-			return errorResponse("No page by such title", "No page with such title exists");
-		}
-		pagename = page->name;
-	}
 
 	if(pageMustExist() && !pageDao->exists(pagename))
 	{
@@ -74,9 +63,8 @@ void HandlerPage::setPageVars(TemplatePage &page, std::string pagename)
 	if(!pagename.empty())
 	{
 		std::string headerlinks;
-		TemplatePage headerlink = this->templ->getPage("_headerlink");
+		TemplatePage &headerlink = this->templ->getPage("_headerlink");
-		auto addHeaderLink = [&headerlinks, &headerlink](std::string href, std::string value)
+		auto addHeaderLink = [&headerlinks, &headerlink](std::string href, std::string value) {
-		{
 			headerlink.setVar("href", href);
 			headerlink.setVar("value", value);
 			headerlinks += headerlink.render();

handlers/handlerpagedelete.cpp

@@ -45,7 +45,6 @@ Response HandlerPageDelete::handleRequest(PageDao &pageDao, std::string pagename
 		{
 			pageDao.deletePage(pagename);
 			this->cache->removePrefix("page:"); // TODO: overkill?
-			this->cache->removePrefix("feed:");
 			return Response::redirectTemporarily(this->urlProvider->index());
 		}
 		TemplatePage delPage = this->templ->getPage("page_deletion");

handlers/handlerpageedit.cpp

@@ -21,13 +21,11 @@ SOFTWARE.
 #include "handlerpageedit.h"
 #include "../database/exceptions.h"
 #include "../request.h"
+#include "../parserlegacy.h"
 
-#include "../parser.h"
+bool HandlerPageEdit::canAccess(std::string page)
-#include "../revisionrenderer.h"
-
-bool HandlerPageEdit::canAccess([[maybe_unused]] std::string page)
 {
-	return effectivePermissions(page).canEdit();
+	return this->userSession->user.permissions.canEdit();
 }
 
 bool HandlerPageEdit::pageMustExist()
@@ -43,7 +41,7 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		return errorResponse("No permission", "You don't have permission to create new pages");
 	}
 	auto revisiondao = this->database->createRevisionDao();
-	auto revision = revisiondao->getCurrentForPage(pagename);
+	auto revision = this->database->createRevisionDao()->getCurrentForPage(pagename);
 	std::string body;
 
 	unsigned int current_revision = 0;
@@ -52,16 +50,6 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		body = revision->content;
 		current_revision = revision->revision;
 	}
-	std::string from = r.get("frompage");
-	if(!from.empty())
-	{
-		if(!effectivePermissions(from).canRead())
-		{
-			return this->errorResponse("Permission denied",
-									   "No access permissions, so you can't use this page as a template");
-		}
-		body = revisiondao->getCurrentForPage(from)->content;
-	}
 	if(r.getRequestMethod() == "POST")
 	{
 		if(r.post("do") == "submit")
@@ -71,32 +59,13 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 
 			// TODO: must check, whether categories differ, and perhaps don't allow every user
 			// to set categories
-			Parser parser;
+			ParserLegacy parser;
 			std::vector<std::string> cats = parser.extractCategories(newContent);
 			try
 			{
 				this->database->beginTransaction();
-
 				std::string visiblecmd = parser.extractCommand("visible", newContent);
-				std::string listedcmd = parser.extractCommand("listed", newContent);
-				/* Backwarts compatibility */
-				if(listedcmd.empty())
-				{
-					listedcmd = visiblecmd;
-				}
-				std::string feedlistedcmd = parser.extractCommand("feedlisted", newContent);
-
 				std::string rename = parser.extractCommand("rename", newContent);
-				std::string customtitle = parser.extractCommand("pagetitle", newContent);
-				std::string parentpage = parser.extractCommand("parentpage", newContent);
-				std::vector<std::string> perms = parser.extractCommands("permissions", newContent);
-
-				if(parentpage != "" && !pageDao.find(parentpage))
-				{
-					return this->errorResponse("Invalid parent",
-											   "Specified parent page " + parentpage + " does not exist");
-				}
-
 				Page page;
 				std::optional<Page> currentPage = pageDao.find(pagename);
 				if(currentPage)
@@ -111,52 +80,9 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 					}
 					pagename = rename;
 				}
-
-				std::vector<std::pair<std::string, Permissions>> collectedPermissions;
-
-				auto permissionDao = this->database->createPermissionsDao();
-				for(const std::string &perm : perms)
-				{
-					auto splitted = utils::split(perm, '|');
-					if(splitted.size() != 2)
-					{
-						return this->errorResponse("Invalid command", "permissions command is misformated");
-					}
-					auto currentPermission = permissionDao->find(pagename, splitted[0]);
-
-					Permissions newPermissions = Permissions{splitted[1]};
-					if(!currentPermission || newPermissions != currentPermission.value())
-					{
-						if(!this->userSession->user.permissions.canSetPagePerms())
-						{
-							this->database->rollbackTransaction();
-							return errorResponse("Permission denied",
-												 "You don't have permission to change permissions. Don't touch the "
-												 "permission commands");
-						}
-					}
-					collectedPermissions.emplace_back(splitted[0], newPermissions);
-				}
-
-				if(this->userSession->user.permissions.canSetPagePerms())
-				{
-					permissionDao->clearForPage(pagename);
-					for(auto &perms : collectedPermissions)
-					{
-						permissionDao->save(pagename, perms.first, perms.second);
-					}
-				}
-
 				page.current_revision = current_revision;
-				page.listed = !(listedcmd == "0");
+				page.listed = !(visiblecmd == "0");
-				page.feedlisted = !(feedlistedcmd == "0");
 				page.name = pagename;
-				page.title = customtitle;
-				page.parentpage = parentpage;
-				if(page.title.empty())
-				{
-					page.title = page.name;
-				}
 				pageDao.save(page);
 
 				Revision newRevision;
@@ -169,11 +95,9 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 				pageDao.setCategories(pagename, cats);
 				this->database->commitTransaction();
 				this->cache->removePrefix("page:"); // TODO: overkill?
-				this->cache->removePrefix("feed:");
 			}
 			catch(const DatabaseException &e)
 			{
-				this->database->rollbackTransaction();
 				Logger::debug() << "Error saving revision: " << e.what();
 				return errorResponse("Database error", "A database error occured while trying to save this revision");
 			}
@@ -183,17 +107,13 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		if(r.post("do") == "preview")
 		{
 			std::string newContent = r.post("content");
-			Parser parser;
+			ParserLegacy parser;
-			std::string title = parser.extractCommand("pagetitle", newContent);
 			TemplatePage templatePage = this->templ->getPage("page_creation_preview");
 			templatePage.setVar("actionurl", urlProvider->editPage(pagename));
-
+			templatePage.setVar("preview_content", parser.parse(pageDao, *this->urlProvider, newContent));
-			RevisionRenderer revisionRenderer{*this->templ, *this->database, *this->urlProvider, *this->userSession};
-
-			templatePage.setVar("preview_content", revisionRenderer.renderContent(newContent));
 			templatePage.setVar("content", newContent);
 			setPageVars(templatePage, pagename);
-			templatePage.setVar("title", createPageTitle("Preview: " + title));
+			templatePage.setVar("title", createPageTitle("Preview: " + pagename));
 			templatePage.setVar("comment", r.post("comment"));
 			Response response;
 			response.setBody(templatePage.render());
@@ -201,7 +121,7 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		}
 	}
 
-	TemplatePage templatePage = this->templ->getPage("page_creation");
+	TemplatePage &templatePage = this->templ->getPage("page_creation");
 	templatePage.setVar("actionurl", urlProvider->editPage(pagename));
 	templatePage.setVar("content", body);
 	setPageVars(templatePage, pagename);

handlers/handlerpageview.cpp

@@ -21,13 +21,8 @@ SOFTWARE.
 #include "handlerpageview.h"
 #include "../database/exceptions.h"
 #include "../logger.h"
-#include "../parser.h"
+#include "../parserlegacy.h"
 #include "../htmllink.h"
-#include "../dynamic/dynamiccontentpostlist.h"
-#include "../dynamic/dynamiccontentincludepage.h"
-#include "../dynamic/dynamiccontentsetvar.h"
-#include "../dynamic/dynamiccontentgetvar.h"
-#include "../revisionrenderer.h"
 
 bool HandlerPageView::canAccess(std::string page)
 {
@@ -91,20 +86,19 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 
 	std::optional<Revision> revision;
 	std::string templatepartname;
-	auto revisionDao = this->database->createRevisionDao();
 	try
 	{
 		if(revisionid > 0)
 		{
 			if(!effectivePermissions(pagename).canSeePageHistory())
 			{
-				auto current = revisionDao->getCurrentForPage(pagename);
+				auto current = this->database->createRevisionDao()->getCurrentForPage(pagename);
 				if(current && current->revision > revisionid)
 				{
 					return errorResponse("Error", "You are not allowed to view older revisions of this page");
 				}
 			}
-			revision = revisionDao->getRevisionForPage(pagename, revisionid);
+			revision = this->database->createRevisionDao()->getRevisionForPage(pagename, revisionid);
 			if(!revision)
 			{
 				return errorResponse("Revision not found", "No such revision found");
@@ -124,7 +118,7 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 					return r;
 				}
 			}
-			revision = revisionDao->getCurrentForPage(pagename);
+			revision = this->database->createRevisionDao()->getCurrentForPage(pagename);
 			templatepartname = "page_view";
 		}
 	}
@@ -134,30 +128,52 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 		return errorResponse("Database error", "While trying to fetch revision, a database error occured");
 	}
 
-	Parser parser;
+	TemplatePage &page = this->templ->getPage(templatepartname);
+
+
 	Response result;
 	result.setStatus(200);
+	std::string indexcontent;
+	std::string parsedcontent;
 
-	RevisionRenderer revisionRenderer{*this->templ, *this->database, *this->urlProvider, *this->userSession};
+	if(revisionid > 0)
-
+	{
-	std::string customtitle = parser.extractCommand("pagetitle", revision->content);
+		indexcontent = createIndexContent(*parser, revision->content);
-	std::string parsedcontent = revisionRenderer.renderContent(revision.value(), customtitle);
+		parsedcontent = parser->parse(pageDao, *this->urlProvider, revision->content);
-	/* TODO: Dynamic includes not considered, probably fine in practise */
+	}
-	std::string indexcontent = createIndexContent(parser, revision->content);
+	else
-
+	{
+		std::string cachekeyindexcontent = "page:indexcontent:" + pagename;
+		std::string cachekeyparsedcontent = "page:parsedcontent:" + pagename;
+		auto cachedindexcontent = this->cache->get(cachekeyindexcontent);
+		auto cachedparsedcontent = this->cache->get(cachekeyparsedcontent);
+		if(cachedindexcontent)
+		{
+			indexcontent = *cachedindexcontent;
+		}
+		else
+		{
+			indexcontent = createIndexContent(*parser, revision->content);
+			this->cache->put(cachekeyindexcontent, indexcontent);
+		}
+		if(cachedparsedcontent)
+		{
+			parsedcontent = *cachedparsedcontent;
+		}
+		else
+		{
+			parsedcontent = parser->parse(pageDao, *this->urlProvider, revision->content);
+			this->cache->put(cachekeyparsedcontent, parsedcontent);
+		}
+	}
 	std::string revisionstr = std::to_string(revision->revision);
-	TemplatePage page = this->templ->getPage(templatepartname);
 	page.setVar("content", parsedcontent);
 	page.setVar("index", indexcontent);
 	page.setVar("editedby", revision->author);
-	page.setVar("editedon", utils::toISODateTime(revision->timestamp));
+	page.setVar("editedon", utils::toISODate(revision->timestamp));
 	page.setVar("historyurl", this->urlProvider->pageHistory(pagename));
 	page.setVar("revision", revisionstr);
 	setPageVars(page, pagename);
-	if(!customtitle.empty())
-	{
-		page.setVar("title", createPageTitle(customtitle));
-	}
 	std::string body = page.render();
 	if(revisionid == 0 && !this->userSession->loggedIn)
 	{

handlers/handlersearch.cpp

@@ -25,11 +25,7 @@ Response HandlerSearch::handleRequest(const Request &r)
 	std::string q = r.get("q");
 	if(q.empty())
 	{
-		TemplatePage searchForm = this->templ->getPage("searchform");
+		return errorResponse("Missing search term", "No search term supplied");
-		response.setBody(searchForm.render());
-		response.setStatus(200);
-		setGeneralVars(searchForm);
-		return response;
 	}
 
 	auto pageDao = this->database->createPageDao();
@@ -41,7 +37,7 @@ Response HandlerSearch::handleRequest(const Request &r)
 		{
 			return errorResponse("No results", "Your search for " + q + " did not yield any results.");
 		}
-		TemplatePage searchPage = this->templ->getPage("search");
+		TemplatePage &searchPage = this->templ->getPage("search");
 		std::string body = this->templ->renderSearch(resultList);
 		searchPage.setVar("pagelist", body);
 		searchPage.setVar("searchterm", q);

handlers/handlerusersettings.cpp

@@ -15,20 +15,19 @@ Response HandlerUserSettings::handleRequest(const Request &r)
 
 			if(newpassword != newpasswordconfirm)
 			{
-				// TODO: is not nice, users has to hit the back button...
+				//TODO: is not nice, users has to hit the back button...
 				return this->errorResponse("Passwords don't match", "The entered new passwords don't match");
 			}
 			auto userDao = this->database->createUserDao();
 			Authenticator authenticator(*userDao);
 
-			std::variant<User, AuthenticationError> authresult =
+			std::variant<User, AuthenticationError> authresult = authenticator.authenticate(this->userSession->user.login, oldpassword);
-				authenticator.authenticate(this->userSession->user.login, oldpassword);
 			if(std::holds_alternative<AuthenticationError>(authresult))
 			{
 				return this->errorResponse("Invalid current password", "The old password you entered is invalid");
 			}
 			Random r;
-			std::vector<char> salt = r.getRandom(AUTH_DEFAULT_SALT_SIZE);
+			std::vector<char> salt = r.getRandom(23);
 			User user = std::get<User>(authresult);
 			user.salt = salt;
 			user.password = authenticator.hash(newpassword, user.salt);
@@ -51,7 +50,7 @@ Response HandlerUserSettings::handleRequest(const Request &r)
 		}
 	}
 
-	TemplatePage userSettingsPage = this->templ->getPage("usersettings");
+	TemplatePage &userSettingsPage = this->templ->getPage("usersettings");
 	setGeneralVars(userSettingsPage);
 	userSettingsPage.setVar("usersettingsurl", urlProvider->userSettings());
 	userSettingsPage.setVar("title", createPageTitle("User settings - " + this->userSession->user.login));
@@ -62,7 +61,7 @@ Response HandlerUserSettings::handleRequest(const Request &r)
 	return result;
 }
 
-bool HandlerUserSettings::canAccess([[maybe_unused]] const Permissions &perms)
+bool HandlerUserSettings::canAccess(const Permissions &perms)
 {
 	return this->userSession->loggedIn;
 }

handlers/handlerversion.cpp

@@ -1,9 +0,0 @@
-#include "handlerversion.h"
-#include "../version.h"
-Response HandlerVersion::handleRequest([[maybe_unused]] const Request &r)
-{
-	Response response;
-	response.setContentType("text/plain");
-	response.setBody(get_version_string());
-	return response;
-}

handlers/handlerversion.h

@@ -1,18 +0,0 @@
-#ifndef HANDLERVERSION_H
-#define HANDLERVERSION_H
-#include "handler.h"
-class HandlerVersion : public Handler
-{
-  public:
-	using Handler::Handler;
-
-  public:
-	Response handleRequest(const Request &r) override;
-
-	bool canAccess([[maybe_unused]] const Permissions &perms) override
-	{
-		return true;
-	}
-};
-
-#endif // HANDLERVERSION_H

iparser.h

@@ -2,37 +2,22 @@
 #define IPARSER_H
 #include <vector>
 #include <string_view>
-#include <functional>
 #include "headline.h"
 #include "database/pagedao.h"
 #include "urlprovider.h"
+
+
 class IParser
 {
-  protected:
-	static std::string empty(std::string_view key, std::string_view content)
-	{
-		return "";
-	}
-
   public:
-	virtual std::string extractFirstTag(std::string tagname, const std::string &content) const = 0;
+	virtual std::string extractCommand(std::string cmdname, std::string content) const = 0;
-	virtual std::string extractCommand(std::string cmdname, const std::string &content) const = 0;
+	virtual std::vector<Headline> extractHeadlines(std::string content) const = 0;
-	virtual std::vector<std::string> extractCommands(std::string cmdname, const std::string &content) const = 0;
+	virtual std::string parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const = 0;
-
+	virtual std::vector<std::string> extractCategories(std::string content) const = 0;
-	virtual std::vector<Headline> extractHeadlines(const std::string &content) const = 0;
-	virtual inline std::string parse(const PageDao &pagedao, UrlProvider &provider, const std::string &content) const
-	{
-		return parse(pagedao, provider, content, empty);
-	}
-	virtual std::string parse(const PageDao &pagedao, UrlProvider &provider, const std::string &content,
-							  const std::function<std::string(std::string_view, std::string_view)> &callback) const = 0;
-
-	virtual std::string parseDynamics(
-		const std::string &content,
-		const std::function<std::string(std::string_view, std::string_view)> &callback) const = 0;
-	virtual std::vector<std::string> extractCategories(const std::string &content) const = 0;
 
 	virtual ~IParser(){};
 };
 
+
+
 #endif // PARSER_H

logger.h

@@ -7,8 +7,8 @@ class Logger
   private:
 	class LogEntry
 	{
-		bool headerSent = false;
+		bool headerSent;
-		std::ostream *out = nullptr;
+		std::ostream *out;
 		std::string prefix;
 
 	  public:

page.h

@@ -7,10 +7,7 @@ class Page
   public:
 	Page();
 	std::string name;
-	std::string title;
-	std::string parentpage;
 	bool listed;
-	bool feedlisted;
 	unsigned int current_revision;
 	unsigned int pageid;
 };

pagelistrenderer.cpp

@@ -1,66 +0,0 @@
-#include "pagelistrenderer.h"
-#include "grouper.h"
-
-PageListRenderer::PageListRenderer(Template &templ, UrlProvider &provider, Database &database)
-{
-	this->templ = &templ;
-	this->urlProvider = &provider;
-	this->database = &database;
-}
-
-std::string PageListRenderer::render(const std::vector<Page> &pagelist, std::string type) const
-{
-	TemplatePage pagelistrendergroup = this->templ->loadResolvedPart("pagelistrender_group");
-	TemplatePage pagelistlink = this->templ->loadResolvedPart("pagelistrender_link");
-
-
-	std::function<bool(const std::string &, const std::string &)> lesser = [](const std::string &a, const std::string &b) -> bool {
-		return a < b;
-	};
-
-	std::function<bool(const std::string &, const std::string &)> greater = [](const std::string &a, const std::string &b) -> bool {
-		return a > b;
-	};
-
-	using Grouper = Grouper<std::string, Page, std::function<bool(const std::string &,const std::string &)>>;
-
-	Grouper grouper = (type == "letter") ? Grouper(lesser) : Grouper(greater);
-	if(type == "letter")
-	{
-		auto az = [&](const Page &p) -> std::string {
-			int upper = toupper(p.title[0]); // TODO: this is not unicode safe.
-			return { (char)upper };
-		};
-		grouper.group(az, pagelist);
-	}
-	else
-	{
-		auto revisionDao = this->database->createRevisionDao();
-		auto creationdate = [&revisionDao](const Page &p) -> std::string {
-			return utils::formatLocalDate(revisionDao->getRevisionForPage(p.name, 1).value().timestamp, "%Y-%m");
-		};
-		grouper.group(creationdate, pagelist);
-	}
-
-	std::stringstream stream;
-	std::string lastGroup = "";
-
-	for(auto &entry : grouper.getResults())
-	{
-		std::string groupname = entry.first;
-		const std::vector<const Page*> &pages = entry.second;
-		if(lastGroup != groupname)
-		{
-			lastGroup = groupname;
-			pagelistrendergroup.setVar("groupname", groupname);
-			stream << pagelistrendergroup.render();
-		}
-		for(const Page *p : pages)
-		{
-			pagelistlink.setVar("inner", p->title);
-			pagelistlink.setVar("href", this->urlProvider->page(p->name));
-			stream << pagelistlink.render();
-		}
-	}
-	return stream.str();
-}

pagelistrenderer.h

@@ -1,27 +0,0 @@
-#ifndef PAGELISTRENDERER_H
-#define PAGELISTRENDERER_H
-#include "utils.h"
-#include "page.h"
-#include "template.h"
-#include "htmllink.h"
-#include "urlprovider.h"
-#include "database/database.h"
-
-class PageListRenderer
-{
-private:
-	Template *templ;
-	UrlProvider *urlProvider;
-	Database *database;
-
-public:
-	PageListRenderer(Template &templ, UrlProvider &provider, Database &database);
-
-	std::string render(const std::vector<Page> &pages, std::string type) const;
-
-	inline static const std::string RENDER_GROUP_BY_LETTER { "letter" };
-	inline static const std::string RENDER_GROUP_BY_CREATIONDATE { "creationdate" };
-
-
-};
-#endif

parser.cpp

@@ -1,241 +0,0 @@
-/* Copyright (c) 2018 Albert S.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-#include <regex>
-#include <iostream>
-#include <regex>
-#include <vector>
-#include <algorithm>
-#include <iterator>
-#include "parser.h"
-#include "utils.h"
-#include "htmllink.h"
-std::vector<Headline> Parser::extractHeadlines(const std::string &content) const
-{
-	std::vector<Headline> result;
-
-	std::string reg = R"(\[h(1|2|3)\](\[.*?\])*(.*?)(\[.*?\])*\[\/h\1\])";
-	std::regex headerfinder(reg);
-	auto begin = std::sregex_iterator(content.begin(), content.end(), headerfinder);
-	auto end = std::sregex_iterator();
-
-	for(auto it = begin; it != end; it++)
-	{
-		auto smatch = *it;
-		Headline h;
-		h.level = utils::toUInt(smatch.str(1));
-		h.title = smatch.str(3);
-		result.push_back(h);
-	}
-	return result;
-}
-
-std::vector<std::string> Parser::extractCategories(const std::string &content) const
-{
-	std::vector<std::string> result;
-	std::string reg = R"(\[category\](.*?)\[/category\])";
-	std::regex headerfinder(reg);
-	auto begin = std::sregex_iterator(content.begin(), content.end(), headerfinder);
-	auto end = std::sregex_iterator();
-
-	for(auto it = begin; it != end; it++)
-	{
-		auto smatch = *it;
-		result.emplace_back(smatch.str(1));
-	}
-	return result;
-}
-
-std::string Parser::extractFirstTag(std::string tagname, const std::string &content) const
-{
-	std::string cmd = "[" + tagname + "]";
-	std::string cmdend = "[/" + tagname + "]";
-	std::string_view view = content;
-	size_t pos = 0;
-	if((pos = view.find(cmd)) != std::string::npos)
-	{
-		view.remove_prefix(pos);
-		view.remove_prefix(cmd.size());
-		if((pos = view.find(cmdend)) != std::string::npos)
-		{
-			auto result = view.substr(0, pos);
-			return std::string{result};
-		}
-	}
-	return "";
-}
-
-std::string Parser::extractCommand(std::string cmdname, const std::string &content) const
-{
-
-	return extractFirstTag("cmd:" + cmdname, content);
-}
-
-std::vector<std::string> Parser::extractCommands(std::string cmdname, const std::string &content) const
-{
-	std::vector<std::string> result;
-
-	std::string cmd = "[cmd:" + cmdname + "]";
-	std::string cmdend = "[/cmd:" + cmdname + "]";
-
-	std::string_view view = content;
-	size_t pos = 0;
-	while((pos = view.find(cmd)) != std::string::npos)
-	{
-		view.remove_prefix(pos);
-		view.remove_prefix(cmd.size());
-		if((pos = view.find(cmdend)) != std::string::npos)
-		{
-			result.emplace_back(view.substr(0, pos));
-		}
-	}
-	return result;
-}
-
-std::string Parser::processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const
-{
-	std::string linktag = match.str(1);
-	std::string inside = match.str(2);
-
-	std::vector<std::string> splitted = utils::split(inside, '|');
-	HtmlLink htmllink;
-	if(splitted.size() == 2)
-	{
-		htmllink.innervalue = splitted[1];
-		htmllink.href = splitted[0];
-	}
-	else
-	{
-		htmllink.innervalue = inside;
-		htmllink.href = inside;
-	}
-
-	if(linktag == "wikilink")
-	{
-		if(pageDao.exists(htmllink.href))
-		{
-			htmllink.cssclass = "exists";
-		}
-		else
-		{
-			htmllink.cssclass = "notexists";
-		}
-
-		htmllink.href = urlProvider.page(htmllink.href);
-	}
-
-	return htmllink.render();
-}
-
-std::string Parser::processImage(std::smatch &match) const
-{
-	std::string tag = match.str(1);
-	std::string inside = match.str(2);
-	std::vector<std::string> splitted = utils::split(inside, '|');
-	std::string width;
-	std::string height;
-	std::string src;
-	if(splitted.size() == 3)
-	{
-		width = splitted[0];
-		height = splitted[1];
-		src = splitted[2];
-	}
-	else
-	{
-		src = splitted[0];
-	}
-	if(!width.empty() && !height.empty())
-	{
-		return "<img src=\"" + src + "\" width=\"" + width + "\" height=\"" + height + "\"/>";
-	}
-	return "<img src=\"" + src + "\"/>";
-}
-
-std::string Parser::parse(const PageDao &pagedao, UrlProvider &provider, const std::string &content,
-						  const std::function<std::string(std::string_view, std::string_view)> &callback) const
-{
-	std::string result;
-	// we don't care about commands, but we nevertheless replace them with empty strings
-	std::regex tagfinder(
-		R"(\[(b|i|u|s|li|p|br|ul|ol|code|blockquote|img|link|wikilink|h\d|cmd:visible|cmd:listed|cmd:feedlisted|cmd:rename|cmd:redirect|cmd:pagetitle|cmd:allowinclude|cmd:permissions|cmd:parentpage|content|category|dynamic:postlist|dynamic:includepage|dynamic:getvar|dynamic:setvar)*?\]((\s|\S)*?)\[/\1](\r\n)*)");
-
-	const std::string justreplace[] = {"b", "i", "u", "p", "br", "ul", "li", "ol"};
-
-	result = utils::regex_callback_replacer(
-		tagfinder, content,
-		[&](std::smatch &match)
-		{
-			std::string tag = match.str(1);
-			std::string content = match.str(2);
-
-			std::string newlines = match.str(4);
-			if(newlines == "\r\n")
-			{
-				newlines = "<br>";
-			}
-			if(tag != "code" && tag != "blockquote")
-			{
-				content = parse(pagedao, provider, content, callback);
-			}
-			/* [content] just helps extracting the actual content of a page, pretty much noop otherwise */
-			if(tag == "content")
-			{
-				return parse(pagedao, provider, content, callback);
-			}
-			if(std::find(std::begin(justreplace), std::end(justreplace), tag) != std::end(justreplace))
-			{
-				if(tag == "p" || tag == "br")
-				{
-					newlines = "";
-				}
-				return "<" + tag + ">" + content + "</" + tag + ">" + newlines;
-			}
-			if(tag == "link" || tag == "wikilink")
-			{
-				return this->processLink(pagedao, provider,
-										 match) +
-					   newlines; // TODO: recreate this so we don't check inside the function stuff again
-			}
-			if(tag == "img")
-			{
-				return this->processImage(match);
-			}
-			if(tag[0] == 'h')
-			{
-				return "<" + tag + " id='" + content + "'>" + content + "</" + tag + ">";
-			}
-			if(tag == "code" || tag == "blockquote")
-			{
-				return "<pre><" + tag + ">" + utils::strreplace(content, "\r\n", "\n") + "</" + tag + "></pre>";
-			}
-			return callback(tag, content);
-		});
-	result = utils::strreplace(result, "\r\n", "<br>");
-	return result;
-}
-
-std::string Parser::parseDynamics(const std::string &content,
-								  const std::function<std::string(std::string_view, std::string_view)> &callback) const
-{
-	std::regex tagfinder(R"(\[(dynamic:\w+)*?\]((\s|\S)*?)\[/\1])");
-	return utils::regex_callback_replacer(tagfinder, content,
-										  [&](std::smatch &match) { return callback(match.str(1), match.str(2)); });
-}

parser.h

@@ -1,28 +0,0 @@
-#ifndef PARSER_H
-#define PARSER_H
-#include "iparser.h"
-
-class Parser : public IParser
-{
-  private:
-	std::string processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const;
-	std::string processImage(std::smatch &match) const;
-
-  public:
-	std::string extractFirstTag(std::string tagname, const std::string &content) const override;
-	std::string extractCommand(std::string cmdname, const std::string &content) const override;
-	std::vector<std::string> extractCommands(std::string cmdname, const std::string &content) const override;
-	std::vector<Headline> extractHeadlines(const std::string &content) const override;
-	std::vector<std::string> extractCategories(const std::string &content) const override;
-	using IParser::parse;
-	virtual std::string parse(
-		const PageDao &pagedao, UrlProvider &provider, const std::string &content,
-		const std::function<std::string(std::string_view, std::string_view)> &callback) const override;
-	std::string parseDynamics(
-		const std::string &content,
-		const std::function<std::string(std::string_view, std::string_view)> &callback) const override;
-
-	using IParser::IParser;
-};
-
-#endif // PARSER_H

parserlegacy.cpp

@@ -0,0 +1,139 @@
+/* Copyright (c) 2018 Albert S.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#include <regex>
+#include <iostream>
+#include <regex>
+#include <vector>
+#include <algorithm>
+#include <iterator>
+#include "parserlegacy.h"
+#include "utils.h"
+#include "htmllink.h"
+std::vector<Headline> ParserLegacy::extractHeadlines(std::string content) const
+{
+	std::vector<Headline> result;
+	utils::regex_callback_extractor(std::regex(R"(\[h(1|2|3)\](.*?)\[/h\1\])"), content, [&](std::smatch &smatch) {
+		Headline h;
+		h.level = utils::toUInt(smatch.str(1));
+		h.title = smatch.str(2);
+		result.push_back(h);
+	});
+	return result;
+}
+
+std::vector<std::string> ParserLegacy::extractCategories(std::string content) const
+{
+	std::vector<std::string> result;
+	std::string reg = R"(\[category\](.*?)\[/category\])";
+	std::regex headerfinder(reg);
+	auto begin = std::sregex_iterator(content.begin(), content.end(), headerfinder);
+	auto end = std::sregex_iterator();
+
+	for(auto it = begin; it != end; it++)
+	{
+		auto smatch = *it;
+		result.emplace_back(smatch.str(1));
+	}
+	return result;
+}
+
+std::string ParserLegacy::extractCommand(std::string cmdname, std::string content) const
+{
+	std::string cmd = "[cmd:" + cmdname + "]";
+	std::string cmdend = "[/cmd:" + cmdname + "]";
+
+	std::string_view view = content;
+	size_t pos = 0;
+	if((pos = view.find(cmd)) != std::string::npos)
+	{
+		view.remove_prefix(pos);
+		view.remove_prefix(cmd.size());
+		if((pos = view.find(cmdend)) != std::string::npos)
+		{
+			auto result = view.substr(0, pos);
+			return std::string{result};
+		}
+	}
+	return "";
+}
+std::string ParserLegacy::processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const
+{
+	std::string linktag = match.str(1);
+	std::string inside = match.str(2);
+
+	std::vector<std::string> splitted = utils::split(inside, '|');
+	HtmlLink htmllink;
+	if(splitted.size() == 2)
+	{
+		htmllink.innervalue = splitted[1];
+		htmllink.href = splitted[0];
+	}
+	else
+	{
+		htmllink.innervalue = inside;
+		htmllink.href = inside;
+	}
+
+	if(linktag == "wikilink")
+	{
+		if(pageDao.exists(htmllink.href))
+		{
+			htmllink.cssclass = "exists";
+		}
+		else
+		{
+			htmllink.cssclass = "notexists";
+		}
+
+		htmllink.href = urlProvider.page(htmllink.href);
+	}
+
+	return htmllink.render();
+}
+
+std::string ParserLegacy::parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const
+{
+	std::string result;
+	// we don't care about commands, but we nevertheless replace them with empty strings
+	std::regex tagfinder(R"(\[(b|i|u|li||ul|ol|link|wikilink|h\d|cmd:rename|cmd:redirect|category)*?\]((\s|\S)*?)\[/\1])");
+	result = utils::regex_callback_replacer(tagfinder, content, [&](std::smatch &match) {
+		std::string tag = match.str(1);
+		std::string content = match.str(2);
+		std::string justreplace[] = {"b", "i", "u", "ul", "li", "ol"};
+		content = parse(pagedao, provider, content);
+		if(std::find(std::begin(justreplace), std::end(justreplace), tag) != std::end(justreplace))
+		{
+			return "<" + tag + ">" + content + "</" + tag + ">";
+		}
+		if(tag == "link" || tag == "wikilink")
+		{
+			return this->processLink(pagedao, provider,
+									 match); // TODO: recreate this so we don't check inside the function stuff again
+		}
+		if(tag[0] == 'h')
+		{
+			return "<" + tag + " id='" + content + "'>" + content + "</" + tag + ">";
+		}
+		return std::string("");
+	});
+	result = utils::strreplace(result, "\r\n", "<br>");
+	return result;
+}

parserlegacy.h

@@ -0,0 +1,19 @@
+#ifndef PARSER_H
+#define PARSER_H
+#include "iparser.h"
+
+class ParserLegacy : public IParser
+{
+  private:
+	std::string processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const;
+
+  public:
+	std::string extractCommand(std::string cmdname, std::string content) const;
+	std::vector<Headline> extractHeadlines(std::string content) const override;
+	std::vector<std::string> extractCategories(std::string content) const override;
+	std::string parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const override;
+	using IParser::IParser;
+	~ParserLegacy(){};
+};
+
+#endif // PARSER_H

parsermarkdown.cpp

@@ -0,0 +1,71 @@
+#include "parsermarkdown.h"
+#include "logger.h"
+#include "htmllink.h"
+
+std::string ParserMarkdown::processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const
+{
+	std::string inner = match.str(1);
+	std::string link = match.str(2);
+	HtmlLink htmllink;
+	htmllink.href = link;
+	htmllink.innervalue = inner;
+
+	if(link.find("http://") == 0 || link.find("https://") == 0)
+	{
+		return htmllink.render();
+	}
+
+	if(pageDao.exists(link))
+	{
+		htmllink.cssclass = "exists";
+	}
+	else
+	{
+		htmllink.cssclass = "notexists";
+	}
+
+	htmllink.href = urlProvider.page(htmllink.href);
+
+	return htmllink.render();
+}
+
+ParserMarkdown::ParserMarkdown()
+{
+}
+
+std::vector<Headline> ParserMarkdown::extractHeadlines(std::string content) const
+{
+	std::vector<Headline> result;
+	utils::regex_callback_extractor(std::regex(R"((#{1,6}) (.*))"), content, [&](std::smatch &smatch) {
+		Headline h;
+		h.level = smatch.str(1).length();
+		h.title = smatch.str(2);
+		result.push_back(h);
+	});
+	return result;
+}
+
+std::string ParserMarkdown::parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const
+{
+	std::shared_ptr<maddy::ParserConfig> config = std::make_shared<maddy::ParserConfig>();
+	auto maddy = std::make_shared<maddy::Parser>(config);
+
+	auto linkParser = std::make_shared<maddy::LinkParser>();
+	linkParser->setCallback([&](std::smatch &match) { return processLink(pagedao, provider, match); });
+	maddy->setLinkParser(linkParser);
+	// TODO: hack because the parser breaks if there is an \r
+	content = utils::strreplace(content, "\r", "");
+	std::stringstream s{content};
+	std::string result = maddy->Parse(s);
+	return result;
+}
+
+std::string ParserMarkdown::extractCommand(std::string cmdname, std::string content) const
+{
+	return "";
+}
+
+std::vector<std::string> ParserMarkdown::extractCategories(std::string content) const
+{
+	return { };
+}

parsermarkdown.h

@@ -0,0 +1,21 @@
+#ifndef PARSER_MARKDOWN_H
+#define PARSER_MARKDOWN_H
+
+#include "iparser.h"
+#include "maddy/parser.h"
+
+class ParserMarkdown : public IParser
+{
+private:
+	std::string processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const;
+
+public:
+	ParserMarkdown();
+	std::vector<Headline> extractHeadlines(std::string content) const;
+	std::string parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const;
+
+	std::string extractCommand(std::string cmdname, std::string content) const;
+	std::vector<std::string> extractCategories(std::string content) const;
+};
+
+#endif // PARSER_MARKDOWN_H

permissions.cpp

@@ -20,19 +20,6 @@ SOFTWARE.
 */
 #include "permissions.h"
 
-static const std::map<std::string, int> permmap = {{"can_nothing", PERM_CAN_NOTHING},
-												   {"can_read", PERM_CAN_READ},
-												   {"can_edit", PERM_CAN_EDIT},
-												   {"can_page_history", PERM_CAN_PAGE_HISTORY},
-												   {"can_global_history", PERM_CAN_GLOBAL_HISTORY},
-												   {"can_delete", PERM_CAN_DELETE},
-												   {"can_see_page_list", PERM_CAN_SEE_PAGE_LIST},
-												   {"can_create", PERM_CAN_CREATE},
-												   {"can_see_category_list", PERM_CAN_SEE_CATEGORY_LIST},
-												   {"can_see_links_here", PERM_CAN_SEE_LINKS_HERE},
-												   {"can_search", PERM_CAN_SEARCH},
-												   {"can_set_page_perms", PERM_CAN_SET_PAGE_PERMS}};
-
 Permissions::Permissions(int permissions)
 {
 	this->permissions = permissions;
@@ -49,20 +36,3 @@ Permissions::Permissions(const std::string &str)
 		}
 	}
 }
-
-std::string Permissions::toString(int perms)
-{
-	std::string result;
-	for(auto pair : permmap)
-	{
-		if(pair.second & perms)
-		{
-			result += pair.first + ",";
-		}
-	}
-	if(result.size() > 0)
-	{
-		result.pop_back();
-	}
-	return result;
-}

permissions.h

@@ -1,7 +1,6 @@
 #ifndef PERMISSIONS_H
 #define PERMISSIONS_H
 
-#define PERM_CAN_NOTHING 0
 #define PERM_CAN_READ 1 << 0
 #define PERM_CAN_EDIT 1 << 1
 #define PERM_CAN_PAGE_HISTORY 1 << 2
@@ -12,17 +11,23 @@
 #define PERM_CAN_SEE_CATEGORY_LIST 1 << 7
 #define PERM_CAN_SEE_LINKS_HERE 1 << 8
 #define PERM_CAN_SEARCH 1 << 9
-#define PERM_CAN_SET_PAGE_PERMS 1 << 10
-#define PERM_IS_ADMIN (1L<<31)-1
 
 #include <string>
 #include <map>
-
 class Permissions
-
 {
   private:
 	int permissions = 0;
+	const std::map<std::string, int> permmap = {{"can_read", PERM_CAN_READ},
+												{"can_edit", PERM_CAN_EDIT},
+												{"can_page_history", PERM_CAN_PAGE_HISTORY},
+												{"can_global_history", PERM_CAN_GLOBAL_HISTORY},
+												{"can_delete", PERM_CAN_DELETE},
+												{"can_see_page_list", PERM_CAN_SEE_PAGE_LIST},
+												{"can_create", PERM_CAN_CREATE},
+												{"can_see_category_list", PERM_CAN_SEE_CATEGORY_LIST},
+												{"can_see_links_here", PERM_CAN_SEE_LINKS_HERE},
+												{"can_search", PERM_CAN_SEARCH}};
 
   public:
 	Permissions()
@@ -57,16 +62,10 @@ class Permissions
 		return this->permissions;
 	}
 
-	bool canNothing() const
-	{
-		return this->permissions == PERM_CAN_NOTHING;
-	}
-
 	bool canRead() const
 	{
 		return this->permissions & PERM_CAN_READ;
 	}
-
 	bool canEdit() const
 	{
 		return this->permissions & PERM_CAN_EDIT;
@@ -103,28 +102,6 @@ class Permissions
 	{
 		return this->permissions & PERM_CAN_SEE_PAGE_LIST;
 	}
-
-	bool canSetPagePerms() const
-	{
-		return this->permissions & PERM_CAN_SET_PAGE_PERMS;
-	}
-
-	bool isAdmin() const
-	{
-		return this->permissions == PERM_IS_ADMIN;
-	}
-
-	std::string toString() const
-	{
-		return Permissions::toString(this->permissions);
-	}
-
-	static std::string toString(int perms);
-
-	bool operator==(const Permissions &o) const
-	{
-		return this->permissions == o.permissions;
-	}
 };
 
 #endif // PERMISSIONS_H

qswiki.cpp

@@ -25,26 +25,23 @@ SOFTWARE.
 #include <unistd.h>
 #include <sys/types.h>
 #include <filesystem>
-#include <getopt.h>
 #include "gateway/gatewayinterface.h"
 #include "gateway/gatewayfactory.h"
 #include "handlers/handlerfactory.h"
 #include "database/databasefactory.h"
 #include "config.h"
-#include "session.h"
 #include "template.h"
+#include "session.h"
 #include "logger.h"
 #include "urlprovider.h"
 #include "requestworker.h"
 #include "cache/fscache.h"
-#include "cache/nocache.h"
 #include "sandbox/sandboxfactory.h"
-#include "cli.h"
+#include "iparser.h"
-#include "cliconsole.h"
+#include "parserlegacy.h"
-#include "cliserver.h"
+#include "parsermarkdown.h"
-#include "version.h"
 
-void sigterm_handler([[maybe_unused]] int arg)
+void sigterm_handler(int arg)
 {
 	// TODO: proper shutdown.
 	exit(EXIT_SUCCESS);
@@ -63,83 +60,31 @@ void setup_signal_handlers()
 	}
 }
 
-#define OPT_PRINT_VERSION 23
-
-static struct option long_options[] = {{"cli", no_argument, 0, 'c'}, {"version", no_argument, 0, OPT_PRINT_VERSION}};
-
 std::unique_ptr<ICache> createCache(const ConfigVariableResolver &resolver)
 {
+
 	std::string path = resolver.getConfig("cache_fs_dir");
-	if(path == "")
+
-	{
-		return std::make_unique<StringCache>();
-	}
 	return std::make_unique<FsCache>(path);
 }
 
-std::thread background_worker;
+std::unique_ptr<IParser> createParser(const ConfigVariableResolver &resolver)
-void start_background_worker(Database &database, Config &config)
 {
-	background_worker = std::thread(
+	std::string parser = resolver.getConfig("parser");
-		[&database, &config]()
+	if(parser == "legacy")
 	{
-			while(true)
+		return std::make_unique<ParserLegacy>();
-			{
-				Logger::log() << "Executing background worker";
-
-				auto sessionDao = database.createSessionDao();
-				auto sessionList = sessionDao->fetch();
-				time_t now = time(NULL);
-
-				for(Session &sess : sessionList)
-				{
-					if(now - sess.creation_time > config.session_max_lifetime)
-					{
-						sessionDao->deleteSession(sess.token);
 	}
-				}
+	return std::make_unique<ParserMarkdown>();
-
-				std::this_thread::sleep_for(std::chrono::hours(1));
-			}
-		});
 }
 
 int main(int argc, char **argv)
 {
-
-	char *configfilepath = NULL;
-	int option;
-	int option_index;
-	bool cli_mode = false;
-
 	if(geteuid() == 0)
 	{
 		std::cerr << "Do not run this as root!" << std::endl;
 		return 1;
 	}
-
-	while((option = getopt_long(argc, argv, "cv", long_options, &option_index)) != -1)
-	{
-		switch(option)
-		{
-		case 'c':
-			cli_mode = true;
-			break;
-		case OPT_PRINT_VERSION:
-			std::cout << get_version_string() << std::endl;
-			exit(EXIT_SUCCESS);
-			break;
-		}
-	}
-
-	if(optind == argc)
-	{
-		std::cerr << "Missing config path" << std::endl;
-		return 1;
-	}
-
-	configfilepath = argv[optind++];
-
 	auto sandbox = createSandbox();
 	// TODO: do we want to keep it mandatory or configurable?
 	if(!sandbox->supported())
@@ -147,18 +92,35 @@ int main(int argc, char **argv)
 		Logger::error() << "Sandbox is not supported, exiting";
 		exit(EXIT_FAILURE);
 	}
+	if(!sandbox->enableForInit())
+	{
+		Logger::error() << "Sandboxing for init mode could not be activated.";
+		exit(EXIT_FAILURE);
+	}
+
 	if(argc < 2)
 	{
 		std::cerr << "no path to config file provided" << std::endl;
 		return 1;
 	}
-	std::string configpath = std::filesystem::absolute(configfilepath).string();
 
 	try
 	{
-		ConfigReader configreader(configpath);
+		ConfigReader configreader(argv[1]);
 		Config config = configreader.readConfig();
 
+		// TODO: config.connectiontring only works as long as we only support sqlite of course
+		if(!sandbox->enablePreWorker({
+			   config.configVarResolver.getConfig("cache_fs_dir"),
+			   config.templatepath,
+			   std::filesystem::path(config.logfile).parent_path(),
+			   std::filesystem::path(config.connectionstring).parent_path(),
+		   }))
+		{
+			Logger::error() << "Sandboxing for pre worker stage could not be activated.";
+			exit(EXIT_FAILURE);
+		}
+
 		setup_signal_handlers();
 
 		std::fstream logstream;
@@ -167,37 +129,6 @@ int main(int argc, char **argv)
 
 		auto database = createDatabase(config);
 
-		std::string socketPath = config.configVarResolver.getConfig("socketpath");
-		CLIHandler cliHandler(config, *database);
-
-		if(cli_mode)
-		{
-			CLIConsole console{cliHandler, socketPath};
-			console.startInteractive();
-			return 0;
-		}
-
-		// TODO: config.connectiontring only works as long as we only support sqlite of course
-		if(!sandbox->enable({
-			   config.configVarResolver.getConfig("cache_fs_dir"),
-			   config.templatepath,
-			   std::filesystem::path(config.logfile).parent_path(),
-			   std::filesystem::path(config.connectionstring).parent_path(),
-		   }))
-		{
-			Logger::error() << "Sandboxing for worker could not be enabled!";
-			exit(EXIT_FAILURE);
-		}
-
-		start_background_worker(*database.get(), config);
-
-		CLIServer cliServer{cliHandler};
-		if(!cliServer.detachServer(socketPath))
-		{
-			Logger::error() << "Error: Failed to detach unix socket server";
-			return 1;
-		}
-
 		// TODO: quite ugly, anon-handling must be rethought
 		auto userdao = database->createUserDao();
 		std::optional<User> anon = userdao->find(config.handlersConfig.anon_username);
@@ -213,19 +144,25 @@ int main(int argc, char **argv)
 		userdao->save(anon.value());
 		User::setAnon(anon.value());
 
-		MapCache<TemplatePage> mapCache;
+		Template siteTemplate{config.templateprefix, config.templatepath, config.urls, config.configVarResolver};
-		Template siteTemplate{config.templateprefix, config.templatepath, config.urls, config.configVarResolver,
-							  mapCache};
 		UrlProvider urlProvider{config.urls};
 
 		auto cache = createCache(config.configVarResolver);
 		cache->clear();
 
-		HandlerFactory handlerFactory{config.handlersConfig, siteTemplate, *database.get(), urlProvider, *cache.get()};
+		auto parser = createParser(config.configVarResolver);
+
+
+		HandlerFactory handlerFactory{config.handlersConfig, siteTemplate, *database.get(), urlProvider, *cache.get(), *parser.get()};
 		RequestWorker requestWorker{handlerFactory, database->createSessionDao(), siteTemplate};
 
 		auto interface = createGateway(config);
 
+		if(!sandbox->enableForWorker())
+		{
+			Logger::error() << "Sandboxing for worker could not be enabled!";
+			exit(EXIT_FAILURE);
+		}
 		interface->work(requestWorker);
 	}
 	catch(const std::exception &e)

request.cpp

@@ -40,7 +40,7 @@ std::pair<std::string, std::string> Request::createPairFromVar(std::string var)
 	else
 	{
 		std::string key = var.substr(0, equal);
-		std::string val = utils::html_xss(utils::urldecode(var.substr(equal + 1)));
+		std::string val = utils::html_xss(var.substr(equal + 1));
 		return std::make_pair(std::move(key), std::move(val));
 	}
 }
@@ -75,7 +75,7 @@ void Request::initPostMap(const std::string &url)
 void Request::initCookies(const std::string &cookiestr)
 {
 	// TODO: find out what it really should be, ";" or "; "?
-	std::regex regex{";+\\s?"};
+	std::regex regex { ";+\\s?" };
 	auto cookiesplitted = utils::split(cookiestr, regex);
 	for(const std::string &part : cookiesplitted)
 	{

requestworker.cpp

@@ -59,7 +59,7 @@ Response RequestWorker::processRequest(const Request &r)
 		if(session.loggedIn && session.csrf_token != r.post("csrf_token"))
 		{
 			// TODO: this is code duplication
-			TemplatePage error = this->templ->getPage("error");
+			TemplatePage &error = this->templ->getPage("error");
 			error.setVar("errortitle", "Invalid csrf token");
 			error.setVar("errormessage", "Invalid csrf token");
 			return {403, error.render()};

response.cpp

@@ -32,12 +32,12 @@ Response::Response(int http_status_code, std::string html)
 	this->html = std::move(html);
 }
 
-void Response::addHeader(std::string key, std::string value)
+void Response::addHeader(const std::string &key, const std::string &value)
 {
 	this->responseHeaders.insert(std::make_pair(key, value));
 }
 
-Response Response::redirectTemporarily(std::string url)
+Response Response::redirectTemporarily(const std::string &url)
 {
 	Response result;
 	result.addHeader("Location", url);

response.h

@@ -27,8 +27,8 @@ class Response
 		return this->html;
 	}
 
-	void addHeader(std::string key, std::string value);
+	void addHeader(const std::string &key, const std::string &value);
-	static Response redirectTemporarily(std::string url);
+	static Response redirectTemporarily(const std::string &url);
 
 	void setStatus(int status)
 	{

revisionrenderer.cpp

@@ -1,78 +0,0 @@
-#include "revisionrenderer.h"
-#include "templatepage.h"
-#include "dynamic/dynamiccontentpostlist.h"
-#include "dynamic/dynamiccontentincludepage.h"
-#include "dynamic/dynamiccontentgetvar.h"
-#include "dynamic/dynamiccontentsetvar.h"
-#include "dynamic/dynamicpostrenderer.h"
-#include "parser.h"
-#include "htmllink.h"
-
-std::string RevisionRenderer::dynamicCallback(std::string_view key, std::string_view value)
-{
-	if(key == "dynamic:postlist")
-	{
-		auto postlist = this->dynamicContentFactory.createDynamicContent<DynamicContentPostList>();
-		postlist->setArgument(std::string(value));
-		return postlist->render();
-	}
-	if(key == "dynamic:includepage")
-	{
-		auto includePage = this->dynamicContentFactory.createDynamicContent<DynamicContentIncludePage>();
-		includePage->setArgument(std::string(value));
-		return parser.parseDynamics(includePage->render(), std::bind(&RevisionRenderer::dynamicCallback, this,
-																	 std::placeholders::_1, std::placeholders::_2));
-	}
-	if(key == "dynamic:setvar")
-	{
-		auto setVar = this->dynamicContentFactory.createDynamicContent<DynamicContentSetVar>();
-		setVar->setMap(dynamicVarsMap);
-		setVar->setArgument(std::string(value));
-		return setVar->render();
-	}
-	if(key == "dynamic:getvar")
-	{
-		auto getVar = this->dynamicContentFactory.createDynamicContent<DynamicContentGetVar>();
-		getVar->setMap(dynamicVarsMap);
-		getVar->setArgument(std::string(value));
-		return getVar->render();
-	}
-	if(key == "dynamic:postrenderer")
-	{
-		auto renderer = this->dynamicContentFactory.createDynamicContent<DynamicPostRenderer>();
-		renderer->setArgument(std::string(value));
-		return renderer->render();
-	}
-	return std::string{};
-}
-
-std::string RevisionRenderer::renderContent(std::string content)
-{
-	dynamicVarsMap["pagetitle"] = parser.extractCommand("pagetitle", content);
-	dynamicVarsMap["createdon"] = utils::toISODate(time(NULL));
-	dynamicVarsMap["modifydatetime"] = utils::toISODateTime(time(NULL));
-
-	std::string resolvedContent = parser.parseDynamics(
-		content, std::bind(&RevisionRenderer::dynamicCallback, this, std::placeholders::_1, std::placeholders::_2));
-
-	return parser.parse(*this->db->createPageDao(), *this->urlProvider, resolvedContent);
-}
-
-std::string RevisionRenderer::renderContent(const Revision &r, std::string_view customTitle)
-{
-	auto revisionDao = this->db->createRevisionDao();
-	auto firstRevision = revisionDao->getRevisionForPage(r.page, 1);
-	if(!firstRevision)
-	{
-		throw std::runtime_error("Could not get first revision for page, which is odd. Solar flares?");
-	}
-
-	dynamicVarsMap["createdon"] = utils::toISODate(firstRevision.value().timestamp);
-	dynamicVarsMap["pagetitle"] = customTitle;
-	dynamicVarsMap["modifydatetime"] = utils::toISODateTime(r.timestamp);
-
-	std::string resolvedContent = parser.parseDynamics(
-		r.content, std::bind(&RevisionRenderer::dynamicCallback, this, std::placeholders::_1, std::placeholders::_2));
-
-	return parser.parse(*this->db->createPageDao(), *this->urlProvider, resolvedContent);
-}

revisionrenderer.h

@@ -1,29 +0,0 @@
-#ifndef REVISIONRENDERER_H
-#define REVISIONRENDERER_H
-#include "revision.h"
-#include "templatepage.h"
-#include "dynamic/dynamiccontentfactory.h"
-#include "iparser.h"
-#include "parser.h"
-class RevisionRenderer
-{
-private:
-	DynamicContentFactory dynamicContentFactory;
-	Database *db;
-	UrlProvider *urlProvider;
-	std::map<std::string, std::string> dynamicVarsMap;
-	
-	std::string dynamicCallback(std::string_view key, std::string_view value);
-	Parser parser;
-	
-public:
-	RevisionRenderer(Template &templ, Database &db, UrlProvider &urlProvider, Session &session) :dynamicContentFactory(templ, db, urlProvider, session)
-	{
-		this->db = &db;
-		this->urlProvider = &urlProvider;
-	}
-	std::string renderContent(std::string content);
-	std::string renderContent(const Revision &r, std::string_view customTitle);
-};
-
-#endif // REVISIONRENDERER_H