Publishing with dialogs

README.md

@@ -33,3 +33,4 @@ This module enables bot to publish to PubSub nodes
 
 #### Commands:
 - **to** `node@service` `title`\n`article`: Publishes `article` to the `node` of the `service`
+- **dialog**: opens an interactive dialog to do the same thing command `to` does

module/publish.cpp

@@ -5,6 +5,9 @@
 
 #include <exception>
 
+#define ADDR ", it should look like this \"node@service.provicer.zone\""
+#define CANCEL "send \"cancel\" to end the dialog"
+
 Module::Publish::Publish(const std::shared_ptr<Core>& core, const Config::Module& conf):
     Module(core, conf, "Publish")
 {}
@@ -12,6 +15,10 @@ Module::Publish::Publish(const std::shared_ptr<Core>& core, const Config::Module
 Module::Publish::~Publish() noexcept {}
 
 Shared::Result Module::Publish::message(const std::shared_ptr<::Actor>& actor, std::string_view view) {
+    Shared::Result result = handleDialog(actor, view);
+    if (result != Shared::unhandled)
+        return result;
+
     std::string_view command = pop(view);
 
     if (command == "to") {
@@ -24,11 +31,76 @@ Shared::Result Module::Publish::message(const std::shared_ptr<::Actor>& actor, s
             return Shared::error;
 
         return to(address, head, view);
+    } else if (command == "dialog") {
+        if (!hasPermission("publish", actor))
+            return Shared::forbidden;
+        
+        dialogs.emplace(actor->jid, Dialog::Stage::address);
+        core->send(actor->jid, "Please provide an address where the publication should take place" ADDR);
+
+        return Shared::grab;
     }
 
     return Shared::unhandled;
 }
 
+void Module::Publish::cancelDialog(const std::shared_ptr<::Actor>& actor) {
+    dialogs.erase(actor->jid);
+}
+
+Shared::Result Module::Publish::handleDialog(const std::shared_ptr<::Actor>& actor, std::string_view message) {
+    std::map<std::string, Dialog>::iterator itr = dialogs.find(actor->jid);
+    if (itr == dialogs.end())
+        return Shared::unhandled;
+
+    Dialog& dialog = itr->second;
+    switch (dialog.stage) {
+        case Dialog::Stage::address:
+            return dialogAddress(itr->first, dialog, message);
+        case Dialog::Stage::title:
+            return dialogTitle(itr->first, dialog, message);
+        case Dialog::Stage::article:
+            return dialogArticle(itr->first, dialog, message);
+    }
+
+    return Shared::error;
+}
+
+Shared::Result Module::Publish::dialogAddress(const std::string& jid, Dialog& dialog, std::string_view address) {
+    std::string_view node = pop(address, '@');
+    if (node.empty() || address.empty()) {
+        warn("Malformed address in \"dialog\" method");
+        core->send(jid, "The address you've sent is malformed" ADDR ", try again or " CANCEL);
+
+        return Shared::grab;
+    }
+
+    dialog.node = node;
+    dialog.service = address;
+    dialog.stage = Dialog::Stage::title;
+    core->send(jid, "Now please provide the title for your publication or " CANCEL);
+
+    return Shared::grab;
+}
+
+Shared::Result Module::Publish::dialogTitle(const std::string& jid, Dialog& dialog, std::string_view title) {
+    dialog.title = title;
+    dialog.stage = Dialog::Stage::article;
+
+    core->send(jid, "Now please provide the body for your publication or " CANCEL);
+
+    return Shared::grab;
+}
+
+Shared::Result Module::Publish::dialogArticle(const std::string& jid, Dialog& dialog, std::string_view article) {
+    core->send(jid, "Publishing...");
+
+    core->publish(dialog.service, dialog.node, dialog.title, std::string(article));
+    dialogs.erase(jid);
+
+    return Shared::success;
+}
+
 Shared::Result Module::Publish::to(std::string_view address, std::string_view title, std::string_view body) {
     std::string_view node = pop(address, '@');
     if (node.empty() || address.empty()) {
@@ -47,3 +119,17 @@ Shared::Result Module::Publish::to(std::string_view address, std::string_view ti
 
     return Shared::error;
 }
+
+Module::Publish::Dialog::Dialog():
+    stage(Stage::address),
+    node(),
+    service(),
+    title()
+{}
+
+Module::Publish::Dialog::Dialog(Stage stage):
+    stage(stage),
+    node(),
+    service(),
+    title()
+{}

module/publish.h

@@ -3,6 +3,9 @@
 
 #pragma once
 
+#include <map>
+#include <string>
+
 #include "shared/definitions.h"
 #include "shared/result.h"
 #include "shared/utils.h"
@@ -12,14 +15,37 @@
 namespace Module {
 
 class Publish : public Module {
+    struct Dialog {
+        enum class Stage {
+            address,
+            title,
+            article
+        };
+
+        Dialog();
+        Dialog(Stage stage);
+        
+        Stage stage;
+        std::string node;
+        std::string service;
+        std::string title;
+    };
 public:
     Publish(const std::shared_ptr<Core>& core, const Config::Module& conf);
     ~Publish() noexcept;
 
-    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, std::string_view view) override;
+    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, std::string_view message) override;
+    virtual void cancelDialog(const std::shared_ptr<::Actor>& actor) override;
+
+private:
+    Shared::Result handleDialog(const std::shared_ptr<::Actor>& actor, std::string_view message);
+    Shared::Result dialogAddress(const std::string& jid, Dialog& dialog, std::string_view address);
+    Shared::Result dialogTitle(const std::string& jid, Dialog& dialog, std::string_view title);
+    Shared::Result dialogArticle(const std::string& jid, Dialog& dialog, std::string_view article);
 
 private:
     Shared::Result to(std::string_view address, std::string_view title, std::string_view body);
+    std::map<std::string, Dialog> dialogs;
 };
 
 }