Older/WebApplication/view/BlogView.cpp

#include "BlogView.h"
#include "BlogLoginWidget.h"
#include "EditUsers.h"
#include "PostView.h"
#include "model/BlogSession.h"
#include "model/Post.h"
#include "model/Tag.h"
#include <Wt/WApplication.h>
#include <Wt/WContainerWidget.h>
#include <Wt/WPushButton.h>
#include <Wt/WStackedWidget.h>
#include <Wt/WText.h>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/split.hpp>

static int try_stoi(const std::string &v) {
    std::size_t pos;
    auto result = std::stoi(v, &pos);
    if (pos != v.length()) throw std::invalid_argument("stoi() of " + v + " failed");
    return result;
}

class BlogImpl : public Wt::WContainerWidget {
public:
    BlogImpl(const std::string &basePath, Wt::Dbo::SqlConnectionPool &connectionPool, const std::string &rssFeedUrl,
             BlogView *blogView)
        : m_basePath(basePath), m_rssFeedUrl(rssFeedUrl), m_session(connectionPool) {
        Wt::WApplication::instance()->internalPathChanged().connect(this, &BlogImpl::handlePathChange);
        m_loginStatus = this->addWidget(std::make_unique<Wt::WTemplate>(tr("blog-login-status")));
        m_panel = this->addWidget(std::make_unique<Wt::WStackedWidget>());
        m_items = this->addWidget(std::make_unique<Wt::WContainerWidget>());

        m_session.login().changed().connect(this, &BlogImpl::onUserChanged);

        auto loginWidget = std::make_unique<BlogLoginWidget>(m_session, basePath);
        m_loginWidget = loginWidget.get();
        m_loginWidget->hide();

        auto loginLink = std::make_unique<Wt::WText>(tr("login"));
        auto lPtr = loginLink.get();
        loginLink->setStyleClass("link");
        loginLink->clicked().connect(m_loginWidget, &WWidget::show);
        loginLink->clicked().connect(lPtr, &WWidget::hide);

        auto registerLink = std::make_unique<Wt::WText>(tr("Wt.Auth.register"));
        registerLink->setStyleClass("link");
        registerLink->clicked().connect(m_loginWidget, &BlogLoginWidget::registerNewUser);

        auto archiveLink =
            std::make_unique<Wt::WAnchor>(Wt::WLink(Wt::LinkType::InternalPath, m_basePath + "all"), tr("archive"));

        m_loginStatus->bindWidget("login", std::move(loginWidget));
        m_loginStatus->bindWidget("login-link", std::move(loginLink));
        m_loginStatus->bindWidget("register-link", std::move(registerLink));
        m_loginStatus->bindString("feed-url", m_rssFeedUrl);
        m_loginStatus->bindWidget("archive-link", std::move(archiveLink));

        onUserChanged();

        m_loginWidget->processEnvironment();
    }

protected:
    void handlePathChange(const std::string &) {
        Wt::WApplication *app = Wt::WApplication::instance();

        if (app->internalPathMatches(m_basePath)) {
            Wt::Dbo::Transaction t(m_session);

            std::string path = app->internalPathNextPart(m_basePath);

            m_items->clear();

            if (m_users) {
                m_users = 0;
            }

            if (path.empty())
                showPosts(m_session
                              .find<Post>("where state = ? "
                                          "order by date desc "
                                          "limit 10")
                              .bind(Post::Published),
                          m_items);

            else if (path == "author") {
                std::string author = app->internalPathNextPart(m_basePath + path + '/');
                Wt::Dbo::ptr<User> user = findUser(author);

                if (user)
                    showPosts(user);
                else
                    showError(tr("blog-no-author").arg(author));
            } else if (path == "edituser") {
                editUser(app->internalPathNextPart(m_basePath + path + '/'));
            } else if (path == "all") {
                showArchive(m_items);
            } else {
                std::string remainder = app->internalPath().substr(m_basePath.length());
                showPostsByDateTopic(remainder, m_items);
            }

            t.commit();
        }
    }

    void showArchive(WContainerWidget *parent) {
        static const char *dateFormat = "MMMM yyyy";

        parent->addWidget(std::make_unique<Wt::WText>(tr("archive-title")));

        Posts posts = m_session.find<Post>("order by date desc");

        Wt::WDateTime formerDate;
        for (auto post : posts) {
            if (post->state != Post::Published) continue;

            if (formerDate.isNull() || yearMonthDiffer(formerDate, post->date)) {
                Wt::WText *title =
                    parent->addWidget(std::make_unique<Wt::WText>(post->date.date().toString(dateFormat)));
                title->setStyleClass("archive-month-title");
            }

            Wt::WAnchor *a = parent->addWidget(std::make_unique<Wt::WAnchor>(
                Wt::WLink(Wt::LinkType::InternalPath, m_basePath + post->permaLink()), post->title));
            a->setInline(false);

            formerDate = post->date;
        }
    }

    bool yearMonthDiffer(const Wt::WDateTime &dt1, const Wt::WDateTime &dt2) {
        return dt1.date().year() != dt2.date().year() || dt1.date().month() != dt2.date().month();
    }

    Wt::Dbo::ptr<User> findUser(const std::string &name) {
        return m_session.find<User>("where name = ?").bind(name);
    }

    bool checkLoggedIn() {
        if (m_session.user()) return true;
        m_panel->show();
        if (!m_mustLoginWarning) {
            m_mustLoginWarning = m_panel->addWidget(std::make_unique<Wt::WTemplate>(tr("blog-mustlogin")));
        }
        m_panel->setCurrentWidget(m_mustLoginWarning);
        return false;
    }

    bool checkAdministrator() {
        if (m_session.user() && (m_session.user()->role == User::Admin)) return true;
        m_panel->show();
        if (!m_mustBeAdministratorWarning) {
            m_mustBeAdministratorWarning =
                m_panel->addWidget(std::make_unique<Wt::WTemplate>(tr("blog-mustbeadministrator")));
        }
        m_panel->setCurrentWidget(m_mustBeAdministratorWarning);
        return false;
    }

    void editUser(const std::string &ids) {
        if (!checkLoggedIn()) return;
        if (!checkAdministrator()) return;
        Wt::Dbo::dbo_traits<User>::IdType id = User::stringToId(ids);

        m_panel->show();
        try {
            Wt::Dbo::Transaction t(m_session);
            Wt::Dbo::ptr<User> target(m_session.load<User>(id));
            if (!m_userEditor) {
                m_userEditor = m_panel->addWidget(std::make_unique<EditUser>(m_session));
            }
            m_userEditor->switchUser(target);
            m_panel->setCurrentWidget(m_userEditor);
        } catch (Wt::Dbo::ObjectNotFoundException &) {
            if (!m_invalidUser) {
                m_invalidUser = m_panel->addWidget(std::make_unique<Wt::WTemplate>(tr("blog-invaliduser")));
            }
            m_panel->setCurrentWidget(m_invalidUser);
        }
    }

    void showPostsByDateTopic(const std::string &path, WContainerWidget *parent) {
        std::vector<std::string> parts;
        boost::split(parts, path, boost::is_any_of("/"));

        Wt::WDate lower, upper;
        try {
            int year = try_stoi(parts[0]);

            if (parts.size() > 1) {
                int month = try_stoi(parts[1]);

                if (parts.size() > 2) {
                    int day = try_stoi(parts[2]);

                    lower.setDate(year, month, day);
                    upper = lower.addDays(1);
                } else {
                    lower.setDate(year, month, 1);
                    upper = lower.addMonths(1);
                }
            } else {
                lower.setDate(year, 1, 1);
                upper = lower.addYears(1);
            }
        } catch (std::invalid_argument &) {
            showError(tr("blog-no-post"));
            return;
        }

        Posts posts = m_session
                          .find<Post>("where date >= ? "
                                      "and date < ? "
                                      "and (state = ? or author_id = ?)")
                          .bind(Wt::WDateTime(lower))
                          .bind(Wt::WDateTime(upper))
                          .bind(Post::Published)
                          .bind(m_session.user().id());

        if (parts.size() > 3) {
            std::string title = parts[3];

            for (auto post : posts)
                if (post->titleToUrl() == title) {
                    showPost(post, PostView::Detail, parent);
                    return;
                }

            showError(tr("blog-no-post"));
        } else {
            showPosts(posts, parent);
        }
    }

    void showPosts(Wt::Dbo::ptr<User> user) {
        showPosts(user->latestPosts(), m_items);
    }

    void showPosts(const Posts &posts, WContainerWidget *parent) {
        for (auto post : posts) showPost(post, PostView::Brief, parent);
    }

    void onUserChanged() {
        if (m_session.login().loggedIn())
            loggedIn();
        else
            loggedOut();
    }

    void editUsers() {
        m_panel->show();

        if (!m_users) {
            m_users = m_panel->addWidget(std::make_unique<EditUsers>(m_session, m_basePath));
            bindPanelTemplates();
        }

        m_panel->setCurrentWidget(m_users);
    }
    BlogSession &session() {
        return m_session;
    }
    void loggedIn() {
        Wt::WApplication::instance()->changeSessionId();

        refresh();

        m_loginStatus->resolveWidget("login")->show();
        m_loginStatus->resolveWidget("login-link")->hide();
        m_loginStatus->resolveWidget("register-link")->hide();

        auto profileLink = std::make_unique<Wt::WText>(tr("profile"));
        profileLink->setStyleClass("link");
        profileLink->clicked().connect(this, &BlogImpl::editProfile);

        Wt::Dbo::ptr<User> user = session().user();

        if (user->role == User::Admin) {
            auto editUsersLink = std::make_unique<Wt::WText>(tr("edit-users"));
            editUsersLink->setStyleClass("link");
            editUsersLink->clicked().connect(this, &BlogImpl::editUsers);
            m_loginStatus->bindWidget("userlist-link", std::move(editUsersLink));

            auto authorPanelLink = std::make_unique<Wt::WText>(tr("author-post"));
            authorPanelLink->setStyleClass("link");
            authorPanelLink->clicked().connect(this, &BlogImpl::authorPanel);
            m_loginStatus->bindWidget("author-panel-link", std::move(authorPanelLink));
        } else {
            m_loginStatus->bindEmpty("userlist-link");
            m_loginStatus->bindEmpty("author-panel-link");
        }

        m_loginStatus->bindWidget("profile-link", std::move(profileLink));

        bindPanelTemplates();
    }

    void loggedOut() {
        m_loginStatus->bindEmpty("profile-link");
        m_loginStatus->bindEmpty("author-panel-link");
        m_loginStatus->bindEmpty("userlist-link");

        m_loginStatus->resolveWidget("login")->hide();
        m_loginStatus->resolveWidget("login-link")->show();
        m_loginStatus->resolveWidget("register-link")->show();

        refresh();
        m_panel->hide();
    }

    void editProfile() {
        m_loginWidget->letUpdatePassword(m_session.login().user(), true);
    }

    void showError(const Wt::WString &msg) {
        m_items->addWidget(std::make_unique<Wt::WText>(msg));
    }

    void authorPanel() {
        m_panel->show();
        if (!m_authorPanel) {
            m_authorPanel = m_panel->addWidget(std::make_unique<Wt::WTemplate>(tr("blog-author-panel")));
            bindPanelTemplates();
        }
        m_panel->setCurrentWidget(m_authorPanel);
    }

    void showPost(const Wt::Dbo::ptr<Post> post, PostView::RenderType type, Wt::WContainerWidget *parent) {
        parent->addWidget(std::make_unique<PostView>(m_session, m_basePath, post, type));
    }

    void newPost() {
        Wt::Dbo::Transaction t(m_session);

        authorPanel();
        WContainerWidget *unpublishedPosts = m_authorPanel->resolve<WContainerWidget *>("unpublished-posts");

        Wt::Dbo::ptr<Post> post(std::make_unique<Post>());

        Post *p = post.modify();
        p->state = Post::Unpublished;
        p->author = m_session.user();
        p->title = "Title";
        p->briefSrc = "Brief ...";
        p->bodySrc = "Body ...";

        showPost(post, PostView::Edit, unpublishedPosts);

        t.commit();
    }

    void bindPanelTemplates() {
        if (!m_session.user()) return;

        Wt::Dbo::Transaction t(m_session);

        if (m_authorPanel) {
            auto newPost = std::make_unique<Wt::WPushButton>(tr("new-post"));
            newPost->clicked().connect(this, &BlogImpl::newPost);
            auto unpublishedPosts = std::make_unique<Wt::WContainerWidget>();
            showPosts(m_session.user()->allPosts(Post::Unpublished), unpublishedPosts.get());

            m_authorPanel->bindString("user", m_session.user()->name);
            m_authorPanel->bindInt("unpublished-count", (int)m_session.user()->allPosts(Post::Unpublished).size());
            m_authorPanel->bindInt("published-count", (int)m_session.user()->allPosts(Post::Published).size());
            m_authorPanel->bindWidget("new-post", std::move(newPost));
            m_authorPanel->bindWidget("unpublished-posts", std::move(unpublishedPosts));
        }

        t.commit();
    }

private:
    std::string m_basePath, m_rssFeedUrl;
    BlogSession m_session;
    BlogLoginWidget *m_loginWidget = nullptr;
    Wt::WStackedWidget *m_panel = nullptr;
    Wt::WTemplate *m_authorPanel = nullptr;
    EditUsers *m_users = nullptr;
    EditUser *m_userEditor = nullptr;
    Wt::WTemplate *m_mustLoginWarning = nullptr;
    Wt::WTemplate *m_mustBeAdministratorWarning = nullptr;
    Wt::WTemplate *m_invalidUser = nullptr;
    Wt::WTemplate *m_loginStatus = nullptr;
    WContainerWidget *m_items = nullptr;
};

BlogView::BlogView(const std::string &basePath, Wt::Dbo::SqlConnectionPool &db, const std::string &rssFeedUrl)
    : WCompositeWidget(), m_userChanged() {
    m_impl = setImplementation(std::make_unique<BlogImpl>(basePath, db, rssFeedUrl, this));
}