Implement items() and addLink() in data source.

5 files changed, 155 insertions, 186 deletions

diff --git a/src/app.hpp b/src/app.hpp
index 092196c..09c7143 100644
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -27,6 +27,10 @@ public:
     std::string urlFor(const std::string& name, const std::string& arg="")
         const;
 
+    void handleIndex(Response& res) const;
+    void handleLogin(Response& res) const;
+    void handleOpenIDRedirect(const Request& req, Response& res) const;
+
 private:
     void setup() override;
 
diff --git a/src/app_test.cpp b/src/app_test.cpp
index a022611..06f2084 100644
--- a/src/app_test.cpp
+++ b/src/app_test.cpp
@@ -19,187 +19,46 @@ using ::testing::HasSubstr;
 using ::testing::FieldsAre;
 using ::testing::ContainsRegex;
 
-void PrintTo(const ShortLink& link, std::ostream* os)
-{
-    *os << "ShortLink(id: " << link.id
-        << ", shortcut: " << link.shortcut
-        << ", original_url: " << link.original_url
-        << ", type: " << link.type
-        << ", user_id: " << link.user_id
-        << ", user_name: " << link.user_name
-        << ", visits: " << link.visits
-        << ", time_creation: " << link.time_creation << ")";
-}
+// class UserAppTest : public testing::Test
+// {
+// protected:
+//     UserAppTest()
+//     {
+//         config.base_url = "http://localhost:8080/";
+//         config.listen_address = "localhost";
+//         config.listen_port = 8080;
+//         config.data_dir = ".";
 
-class UserAppTest : public testing::Test
-{
-protected:
-    UserAppTest()
-    {
-        config.base_url = "http://localhost:8080/";
-        config.listen_address = "localhost";
-        config.listen_port = 8080;
-        config.data_dir = ".";
+//         auto auth = std::make_unique<mw::AuthMock>();
 
-        auto auth = std::make_unique<mw::AuthMock>();
+//         mw::UserInfo expected_user;
+//         expected_user.name = "mw";
+//         expected_user.id = "mw";
+//         mw::Tokens token;
+//         token.access_token = "aaa";
+//         EXPECT_CALL(*auth, getUser(std::move(token)))
+//             .Times(::testing::AtLeast(0))
+//             .WillRepeatedly(Return(expected_user));
+//         auto data = std::make_unique<DataSourceMock>();
+//         data_source = data.get();
 
-        mw::UserInfo expected_user;
-        expected_user.name = "mw";
-        expected_user.id = "mw";
-        mw::Tokens token;
-        token.access_token = "aaa";
-        EXPECT_CALL(*auth, getUser(std::move(token)))
-            .Times(::testing::AtLeast(0))
-            .WillRepeatedly(Return(expected_user));
-        auto data = std::make_unique<DataSourceMock>();
-        data_source = data.get();
+//         app = std::make_unique<App>(config, std::move(data), std::move(auth));
+//     }
 
-        app = std::make_unique<App>(config, std::move(data), std::move(auth));
-    }
+//     Configuration config;
+//     std::unique_ptr<App> app;
+//     const DataSourceMock* data_source;
+// };
 
-    Configuration config;
-    std::unique_ptr<App> app;
-    const DataSourceMock* data_source;
-};
-
-TEST_F(UserAppTest, CanDenyAccessToLinkList)
-{
-    EXPECT_TRUE(mw::isExpected(app->start()));
-    {
-        mw::HTTPSession client;
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res, client.get(
-            mw::HTTPRequest("http://localhost:8080/_/links")));
-        EXPECT_EQ(res->status, 401);
-    }
-    app->stop();
-    app->wait();
-}
-
-TEST_F(UserAppTest, CanHandleLinkList)
-{
-    std::vector<ShortLink> links;
-    ShortLink link0;
-    link0.shortcut = "link0";
-    link0.original_url = "a";
-    link0.id = 1;
-    link0.user_id = "mw";
-    link0.user_name = "mw";
-    link0.type = ShortLink::NORMAL;
-    ShortLink link1;
-    link1.shortcut = "link1";
-    link1.original_url = "b";
-    link1.id = 2;
-    link1.user_id = "mw";
-    link1.user_name = "mw";
-    link1.type = ShortLink::REGEXP;
-    links.push_back(std::move(link0));
-    links.push_back(std::move(link1));
-
-    EXPECT_CALL(*data_source, getAllLinks("mw"))
-        .WillOnce(Return(std::move(links)));
-
-    EXPECT_TRUE(mw::isExpected(app->start()));
-    {
-        mw::HTTPSession client;
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res, client.get(
-            mw::HTTPRequest("http://localhost:8080/_/links")
-            .addHeader("Cookie", "shrt-access-token=aaa")));
-        EXPECT_EQ(res->status, 200) << "Response body: " << res->payloadAsStr();
-        EXPECT_THAT(res->payloadAsStr(), ContainsRegex("<td>a</td>[[:space:]]*<td>-</td>"));
-        EXPECT_THAT(res->payloadAsStr(), ContainsRegex("<td>b</td>[[:space:]]*<td>✅</td>"));
-    }
-    app->stop();
-    app->wait();
-}
-
-TEST_F(UserAppTest, CanDenyAccessToNewLink)
-{
-    EXPECT_TRUE(mw::isExpected(app->start()));
-    {
-        mw::HTTPSession client;
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res, client.get(
-            mw::HTTPRequest("http://localhost:8080/_/new-link")));
-        EXPECT_EQ(res->status, 401);
-    }
-    app->stop();
-    app->wait();
-}
-
-TEST_F(UserAppTest, CanHandleNewLink)
-{
-    EXPECT_TRUE(mw::isExpected(app->start()));
-    {
-        mw::HTTPSession client;
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res, client.get(
-            mw::HTTPRequest("http://localhost:8080/_/new-link")
-            .addHeader("Cookie", "shrt-access-token=aaa")));
-        EXPECT_EQ(res->status, 200);
-        EXPECT_THAT(res->payloadAsStr(), HasSubstr("Create a New Link"));
-    }
-    app->stop();
-    app->wait();
-}
-
-TEST_F(UserAppTest, CanDenyAccessToCreateLink)
-{
-    EXPECT_TRUE(mw::isExpected(app->start()));
-    {
-        mw::HTTPSession client;
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res, client.post(
-            mw::HTTPRequest("http://localhost:8080/_/create-link")));
-        EXPECT_EQ(res->status, 401);
-    }
-    app->stop();
-    app->wait();
-}
-
-TEST_F(UserAppTest, CanDenyHandleCreateLink)
-{
-    EXPECT_CALL(*data_source, addLink(
-        FieldsAre(
-            _,                  // id
-            "abc",              // shortcut
-            "http://darksair.org", // original_url
-            ShortLink::NORMAL,     // type
-            "mw",                  // user_id
-            "",                  // user_name
-            _,                     // visits
-            _)))                   // time_creation
-        .WillOnce(Return(mw::E<void>()));
-
-    EXPECT_CALL(*data_source, addLink(
-        FieldsAre(
-            _,                  // id
-            "xyz",              // shortcut
-            "http://mws.rocks", // original_url
-            ShortLink::REGEXP,     // type
-            "mw",                  // user_id
-            "",                  // user_name
-            _,                     // visits
-            _)))                   // time_creation
-        .WillOnce(Return(mw::E<void>()));
-
-    EXPECT_TRUE(mw::isExpected(app->start()));
-    {
-        mw::HTTPSession client;
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res1, client.post(
-            mw::HTTPRequest("http://localhost:8080/_/create-link")
-            .setPayload("shortcut=abc&original_url=http%3A%2F%2Fdarksair%2Eorg"
-                        "&regexp=off")
-            .addHeader("Cookie", "shrt-access-token=aaa")
-            .setContentType("application/x-www-form-urlencoded")));
-        EXPECT_EQ(res1->status, 302);
-        EXPECT_EQ(res1->header.at("Location"), "http://localhost:8080/");
-
-        ASSIGN_OR_FAIL(const mw::HTTPResponse* res2, client.post(
-            mw::HTTPRequest("http://localhost:8080/_/create-link")
-            .setPayload("shortcut=xyz&original_url=http%3A%2F%2Fmws%2Erocks"
-                        "&regexp=on")
-            .addHeader("Cookie", "shrt-access-token=aaa")
-            .setContentType("application/x-www-form-urlencoded")));
-        EXPECT_EQ(res2->status, 302);
-        EXPECT_EQ(res2->header.at("Location"), "http://localhost:8080/");
-    }
-    app->stop();
-    app->wait();
-}
+// TEST_F(UserAppTest, CanDenyAccessToLinkList)
+// {
+//     EXPECT_TRUE(mw::isExpected(app->start()));
+//     {
+//         mw::HTTPSession client;
+//         ASSIGN_OR_FAIL(const mw::HTTPResponse* res, client.get(
+//             mw::HTTPRequest("http://localhost:8080/_/links")));
+//         EXPECT_EQ(res->status, 401);
+//     }
+//     app->stop();
+//     app->wait();
+// }
diff --git a/src/data.cpp b/src/data.cpp
index 78cb500..d6c4c5f 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -1,3 +1,4 @@
+#include <format>
 #include <memory>
 #include <string>
 #include <expected>
@@ -8,8 +9,33 @@
 
 #include "data.hpp"
 
+// id, owner_id, parent_id, name, url, desc, visibility, time.
+#define LINK_TUPLE_TYPES int64_t,int64_t,int64_t,std::string,std::string,std::string,int,int64_t
+
 namespace
 {
+using LinkTuple = std::tuple<LINK_TUPLE_TYPES>;
+LinkItem linkFromTuple(const LinkTuple& t)
+{
+    LinkItem l;
+    l.id = std::get<0>(t);
+    l.owner_id = std::get<1>(t);
+    int64_t p = std::get<2>(t);
+    if(p == 0)
+    {
+        l.parent_id = std::nullopt;
+    }
+    else
+    {
+        l.parent_id = p;
+    }
+    l.name = std::get<3>(t);
+    l.url = std::get<4>(t);
+    l.description = std::get<5>(t);
+    l.visibility = static_cast<LinkItem::Visibility>(std::get<6>(t));
+    l.time = mw::secondsToTime(std::get<7>(t));
+    return l;
+}
 
 } // namespace
 
@@ -18,7 +44,7 @@ DataSourceSQLite::fromFile(const std::string& db_file)
 {
     auto data_source = std::make_unique<DataSourceSQLite>();
     ASSIGN_OR_RETURN(data_source->db, mw::SQLite::connectFile(db_file));
-
+    DO_OR_RETURN(data_source->db->execute("PRAGMA foreign_keys = ON;"));
     // Perform schema upgrade here.
     //
     // data_source->upgradeSchema1To2();
@@ -30,11 +56,12 @@ DataSourceSQLite::fromFile(const std::string& db_file)
         "(id INTEGER PRIMARY KEY, openid_uid TEXT, name TEXT);"));
     DO_OR_RETURN(data_source->db->execute(
         "CREATE TABLE IF NOT EXISTS LinkItems "
-        "(id INTEGER PRIMARY KEY,"
-        " FOREIGN KEY(owner_id) REFERENCES Users(id) NOT NULL,"
-        " FOREIGN KEY(parent_id) REFERENCES LinkItems(id),"
+        "(id INTEGER PRIMARY KEY, owner_id INTEGER NOT NULL,"
+        " parent_id INTEGER,"
         " name TEXT NOT NULL, url TEXT, description TEXT,"
-        " visibility INTEGER NOT NULL, time INTEGER NOT NULL);"));
+        " visibility INTEGER NOT NULL, time INTEGER NOT NULL,"
+        " FOREIGN KEY(owner_id) REFERENCES Users(id),"
+        " FOREIGN KEY(parent_id) REFERENCES LinkItems(id));"));
     return data_source;
 }
 
@@ -52,3 +79,54 @@ mw::E<void> DataSourceSQLite::setSchemaVersion(int64_t v) const
 {
     return db->execute(std::format("PRAGMA user_version = {};", v));
 }
+
+mw::E<std::vector<LinkItem>>
+DataSourceSQLite::items(std::optional<int64_t> parent)
+{
+    std::vector<LinkTuple> links;
+    if(!parent.has_value())
+    {
+        // Querying root-level links.
+        ASSIGN_OR_RETURN(links, (db->eval<LINK_TUPLE_TYPES>(
+            "SELECT id, owner_id, parent_id, name, url, description, visibility,"
+            " time from LinkItems WHERE parent_id IS NULL;")));
+    }
+    else
+    {
+        ASSIGN_OR_RETURN(mw::SQLiteStatement stat, db->statementFromStr(
+            "SELECT id, owner_id, parent_id, name, url, description, visibility,"
+            " time from LinkItems WHERE parent_id = ?;"));
+        DO_OR_RETURN(stat.bind<int64_t>(*parent));
+        ASSIGN_OR_RETURN(links, (db->eval<LINK_TUPLE_TYPES>(std::move(stat))));
+    }
+    std::vector<LinkItem> result;
+    for(const LinkTuple& t : links)
+    {
+        result.push_back(linkFromTuple(t));
+    }
+    return result;
+}
+
+mw::E<int64_t> DataSourceSQLite::addLink(LinkItem&& link)
+{
+    ASSIGN_OR_RETURN(mw::SQLiteStatement sql, db->statementFromStr(
+        "INSERT INTO LinkItems (id, owner_id, parent_id, name, url,"
+        " description, visibility, time) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"));
+    if(link.parent_id.has_value())
+    {
+        DO_OR_RETURN(sql.bind(
+            std::nullopt, link.owner_id, *link.parent_id, link.name, link.url,
+            link.description, static_cast<int>(link.visibility),
+            mw::timeToSeconds(mw::Clock::now())));
+    }
+    else
+    {
+        DO_OR_RETURN(sql.bind(
+            std::nullopt, link.owner_id, std::nullopt, link.name, link.url,
+            link.description, static_cast<int>(link.visibility),
+            mw::timeToSeconds(mw::Clock::now())));
+    }
+
+    DO_OR_RETURN(db->execute(std::move(sql)));
+    return db->lastInsertRowID();
+}
diff --git a/src/data.hpp b/src/data.hpp
index dc64e6f..006f1f2 100644
--- a/src/data.hpp
+++ b/src/data.hpp
@@ -43,7 +43,8 @@ public:
     // help with database migration.
     virtual mw::E<int64_t> getSchemaVersion() const = 0;
 
-    virtual std::vector<LinkItem> items(std::optional<int64_t> parent) = 0;
+    virtual mw::E<std::vector<LinkItem>> items(std::optional<int64_t> parent) = 0;
+    virtual mw::E<int64_t> addLink(LinkItem&& link) = 0;
 
 protected:
     virtual mw::E<void> setSchemaVersion(int64_t v) const = 0;
@@ -62,6 +63,9 @@ public:
 
     mw::E<int64_t> getSchemaVersion() const override;
 
+    mw::E<std::vector<LinkItem>> items(std::optional<int64_t> parent) override;
+    mw::E<int64_t> addLink(LinkItem&& link) override;
+
     // Do not use.
     DataSourceSQLite() = default;
 
diff --git a/src/data_test.cpp b/src/data_test.cpp
index f1a1a1c..633a102 100644
--- a/src/data_test.cpp
+++ b/src/data_test.cpp
@@ -10,8 +10,32 @@
 
 using ::testing::IsEmpty;
 
-TEST(DataSource, CanAddAndDeleteLink)
+TEST(DataSource, CanAddLink)
 {
     ASSIGN_OR_FAIL(std::unique_ptr<DataSourceSQLite> data,
                    DataSourceSQLite::newFromMemory());
+    LinkItem l0;
+    l0.owner_id = 1;
+    l0.parent_id = std::nullopt;
+    l0.name = "aaa";
+    l0.url = "bbb";
+    l0.description = "ccc";
+    l0.visibility = LinkItem::PUBLIC;
+
+    LinkItem l1;
+    l1.owner_id = 1;
+    l1.parent_id = 1;
+    l1.name = "ddd";
+    l1.url = "eee";
+    l1.description = "fff";
+    l1.visibility = LinkItem::PRIVATE;
+
+    ASSIGN_OR_FAIL(int64_t l0id, data->addLink(std::move(l0)));
+    EXPECT_EQ(l0id, 1);
+    ASSIGN_OR_FAIL(int64_t l1id, data->addLink(std::move(l1)));
+    EXPECT_EQ(l1id, 2);
+    ASSIGN_OR_FAIL(auto ls, data->items(1));
+    ASSERT_EQ(ls.size(), 1);
+    EXPECT_EQ(ls[0].parent_id, 1);
+    EXPECT_EQ(ls[0].visibility, LinkItem::PRIVATE);
 }