CCats/cli/src/cmdman.cpp

#include "../include/cmdman.h"
#include "../include/global.h"

#include <iostream>

CmdMan::CmdMan(FileMan &fm) : fileman(fm) {

  /* setup json stuff */
  Json::CharReaderBuilder rbuilder;
  wbuilder.settings_["indentation"] = "";
  reader = rbuilder.newCharReader();

  dologin = false;
  doversion = false;

  /* initialize execute command map */
  execmap["help"] = &CmdMan::cmdHelp;
  execmap["status"] = &CmdMan::cmdStatus;
  execmap["disconnect"] = &CmdMan::cmdDisconnect;
  execmap["put"] = &CmdMan::cmdPut;
  execmap["get"] = &CmdMan::cmdGet;
  execmap["list"] = &CmdMan::cmdList;
  execmap["version"] = &CmdMan::cmdVersion;
  execmap["login"] = &CmdMan::cmdLogin;
  execmap["putdata"] = &CmdMan::cmdPutdata;
  execmap["getdata"] = &CmdMan::cmdGetdata;

  /* initialize description map */
  helpmap["help"] = descHelp;
  helpmap["status"] = descStatus;
  helpmap["disconnect"] = descDisconnect;
  helpmap["put"] = descPut;
  helpmap["get"] = descGet;
  helpmap["list"] = descList;

  /* initialize handle command map */
  handlemap["status"] = &CmdMan::handleStatus;
  handlemap["close"] = &CmdMan::handleClose;
  handlemap["put"] = &CmdMan::handlePut;
  handlemap["get"] = &CmdMan::handleGet;
  handlemap["putdata"] = &CmdMan::handlePutdata;
  handlemap["getdata"] = &CmdMan::handleGetdata;
  handlemap["list"] = &CmdMan::handleList;
  handlemap["version"] = &CmdMan::handleVersion;
  handlemap["login"] = &CmdMan::handleLogin;
}

CmdMan::~CmdMan() { delete reader; }

CmdMan::CmdRet CmdMan::cmdHelp(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  map<string, string>::iterator it;
  for (it = helpmap.begin(); it != helpmap.end(); it++) {
    retval.msg.append(it->first);
    retval.msg.append(" - ");
    retval.msg.append(it->second);
    retval.msg.append("\n");
  }
  retval.type = notsend;
  return retval;
}

CmdMan::CmdRet CmdMan::cmdStatus(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;
  root["command"] = "status";
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  return retval;
}

CmdMan::CmdRet CmdMan::cmdDisconnect(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;
  root["command"] = "close";
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  return retval;
}

CmdMan::CmdRet CmdMan::cmdPut(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;

  bool opened = fileman.openPut(args[0]);
  if (opened) {
    root["command"] = "put";
    root["file"] = fileman.getPutName();
    root["size"] = fileman.getPutSize();
    root["chunks"] = fileman.getPutChunks();
    retval.type = send;
    retval.msg = Json::writeString(wbuilder, root);
  } else {
    retval.type = error;
    retval.msg = "couldnt open local file \"" + args[0] + "\"";
  }

  return retval;
}

CmdMan::CmdRet CmdMan::cmdPutdata(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;

  root["command"] = "putdata";
  root["file"] = fileman.getPutName();
  root["cancel"] = false;
  root["data"] = fileman.readBase64();
  root["remaining"] =
      fileman
          .getPutRemainingChunks(); // number already decremented by readBase64
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  return retval;
}

CmdMan::CmdRet CmdMan::cmdGet(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;

  bool opened = fileman.openGet(args[0]);
  if (opened) {
    root["command"] = "get";
    root["file"] = fileman.getGetName();
    retval.type = send;
    retval.msg = Json::writeString(wbuilder, root);
  } else {
    retval.type = error;
    retval.msg = "local file \"" + args[0] + "\" already exists";
  }

  return retval;
}

CmdMan::CmdRet CmdMan::cmdGetdata(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;

  root["command"] = "getdata";
  root["file"] = fileman.getGetName();
  root["chunk"] = fileman.getGetRemainingChunks();
  root["cancel"] = false;
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  return retval;
}

CmdMan::CmdRet CmdMan::cmdList(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;
  root["command"] = "list";
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  return retval;
}

CmdMan::CmdRet CmdMan::cmdListdata(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;
  root["command"] = "listdata";
  root["chunk"] = fileman.getListRemainingChunks();
  root["cancel"] = false;
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  return retval;
}

CmdMan::CmdRet CmdMan::execute(string cmd, vector<string> args) {
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  std::cerr << __PRETTY_FUNCTION__ << " using command \"" << cmd
            << "\" with arguments [ ";
  for (string s : args)
    std::cerr << s << " ";
  std::cerr << "]" << std::endl;
  map<string, CmdRet (CmdMan::*)(vector<string>)>::iterator it =
      execmap.find(cmd);
  string retmsg;
  if (it == execmap.end()) {
    return {error, string(__PRETTY_FUNCTION__) + " unknown command \"" + cmd +
                       "\".\ntype help to list available commands."};
  }
  return (this->*(execmap[cmd]))(args);
}

/* internal commands */
CmdMan::CmdRet CmdMan::cmdVersion(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;
  root["version"] = protocolVersion;
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  doversion = true;

  return retval;
}

CmdMan::CmdRet CmdMan::cmdLogin(vector<string> args) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  Json::Value root;
  root["user"] = args[0];
  root["pass"] = args[1];
  root["login"] = true;
  root["cancel"] = false;
  retval.type = send;
  retval.msg = Json::writeString(wbuilder, root);

  dologin = true;

  return retval;
}

/*
        handlemap["status"] = &CmdMan::handleDefault;
        handlemap["disconnect"] = &CmdMan::handleDefault;
        handlemap["put"] = &CmdMan::handleDefault;
        handlemap["get"] = &CmdMan::handleDefault;
        handlemap["list"] = NULL;
        handlemap["version"] = NULL;
        handlemap["login"] = NULL;
*/

CmdMan::CmdRet CmdMan::handle(Json::Value root) {
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  if (doversion)
    root["command"] = "version";
  else if (dologin)
    root["command"] = "login";
  std::cerr << __PRETTY_FUNCTION__ << " using json" << std::endl
            << root << std::endl;
  string retmsg;
  map<string, CmdRet (CmdMan::*)(Json::Value)>::iterator it =
      handlemap.find(root["command"].asString());
  if (it == handlemap.end()) {
    return {error, string(__PRETTY_FUNCTION__) + " unknown command \"" +
                       root["command"].asString() +
                       "\".\nensure code is implemented."};
  }
  return (this->*(handlemap[root["command"].asString()]))(root);
}

CmdMan::CmdRet CmdMan::handleStatus(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  retval.type = notsend;
  retval.msg = root["response"].asString();

  return retval;
}

CmdMan::CmdRet CmdMan::handleClose(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  retval.type = close;
  retval.msg = root["response"].asString();

  return retval;
}

CmdMan::CmdRet CmdMan::handlePut(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  if (!root["accept"].asBool()) {
    retval.type = error;
    retval.msg = "File upload request failed: Server reports: " +
                 root["error"].asString();
  } else if (root["file"].asString() != fileman.getPutName()) {
    retval.type = error;
    retval.msg = "File upload request failed: Server reports filename " +
                 root["file"].asString() + " but actual filename is " +
                 fileman.getPutName();
  } else {
    retval.type = send;
    retval.msg = "putdata";
  }

  return retval;
}

CmdMan::CmdRet CmdMan::handlePutdata(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  if (root["received"].asInt() != fileman.getPutRemainingChunks()) {
    // the number of remaining chunks received from the daemon does not equal
    // the number stored at the client side
    retval.type = error;
    retval.msg = std::string("File upload failed: Server reports number of "
                             "remaining chunks as ") +
                 std::to_string(root["received"].asInt()) +
                 " but actual number is " +
                 std::to_string(fileman.getPutRemainingChunks());
    fileman.cancelPut();
  } else if (root["cancel"].asBool()) {
    retval.type = error;
    retval.msg =
        "File upload cancelles: Server reports: " + root["error"].asString();
    fileman.cancelPut();
  } else if (root["file"].asString() != fileman.getPutName()) {
    retval.type = error;
    retval.msg = "File upload request failed: Server reports filename " +
                 root["file"].asString() + " but actual filename is " +
                 fileman.getPutName();
    fileman.cancelPut();
  } else {
    // sent successfully
    if (!root["received"].asInt()) {
      // everything sent
      retval.type = notsend;
      retval.msg = "succesfully uploaded file " + fileman.getPutName();
      fileman.closePut();
    } else {
      retval.type = send;
      retval.msg = "putdata";
    }
  }
  return retval;
}

CmdMan::CmdRet CmdMan::handleGet(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  if (!root["accept"].asBool()) {
    retval.type = error;
    retval.msg = "File download request failed: Server reports: " +
                 root["error"].asString();
  } else if (root["file"].asString() != fileman.getGetName()) {
    retval.type = error;
    retval.msg = "File download request failed: Server reports filename " +
                 root["file"].asString() + " but actual filename is " +
                 fileman.getGetName();
  } else {
    fileman.setGetChunks(root["chunks"].asInt());
    retval.type = send;
    retval.msg = "getdata";
  }

  return retval;
}

CmdMan::CmdRet CmdMan::handleGetdata(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  // the passed number of recieved chunks should equal the number of sent chunks
  if (root["remaining"].asInt() != fileman.getGetRemainingChunks()) {
    retval.type = error;
    retval.msg = std::string("File download failed: Server reports number of "
                             "remaining chunks as ") +
                 std::to_string(root["remaining"].asInt()) +
                 " but actual number is " +
                 std::to_string(fileman.getGetRemainingChunks());
    fileman.cancelGet();
  } else if (root["cancel"].asBool()) {
    retval.type = error;
    retval.msg =
        "File download cancelled: Server reports: " + root["error"].asString();
    fileman.cancelGet();
  } else if (root["file"].asString() != fileman.getGetName()) {
    retval.type = error;
    retval.msg = "File download failed: Server reports filename " +
                 root["file"].asString() + " but actual filename is " +
                 fileman.getGetName();
    fileman.cancelGet();
  } else {
    fileman.writeBase64(root["data"].asString());
    // loaded successfully
    if (fileman.getGetRemainingChunks() < 0) {
      // everything sent
      retval.type = notsend;
      retval.msg = "succesfully downloaded file " + fileman.getGetName();
      fileman.closeGet();
    } else {
      retval.type = send;
      retval.msg = "getdata";
    }
  }
  return retval;
}

CmdMan::CmdRet CmdMan::handleList(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  if (!root["accept"].asBool()) {
    retval.type = error;
    retval.msg = "File listing request failed: Server reports: " +
                 root["error"].asString();
  } else {
    fileman.setListChunks(root["chunks"].asInt());
    retval.type = send;
    retval.msg = "listdata";
  }

  return retval;
}

CmdMan::CmdRet CmdMan::handleListdata(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;
  vector<string> toadd;

  // the passed number of recieved chunks should equal the number of sent chunks
  if (root["remaining"].asInt() != fileman.getListRemainingChunks()) {
    retval.type = error;
    retval.msg = std::string("File listing failed: Server reports number of "
                             "remaining chunks as ") +
                 std::to_string(root["remaining"].asInt()) +
                 " but actual number is " +
                 std::to_string(fileman.getListRemainingChunks());
    fileman.cancelList();
  } else if (root["cancel"].asBool()) {
    retval.type = error;
    retval.msg =
        "File listing cancelled: Server reports: " + root["error"].asString();
    fileman.cancelList();
  } else {
    for (Json::Value i : root["names"])
      toadd.push_back(i.asString());
    fileman.putListData(toadd);
    // loaded successfully
    if (!fileman.getListRemainingChunks()) {
      // everything sent
      retval.type = notsend;
      retval.msg = "Files on server:\n";
      for (string s : fileman.getListData())
        retval.msg += s + "\n";
      fileman.closeList();
    } else {
      retval.type = send;
      retval.msg = "listdata";
    }
  }
  return retval;
}

CmdMan::CmdRet CmdMan::handleVersion(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  if (!root["accept"].asBool()) {
    retval.type = error;
    retval.msg = "Version check failed: Server reports " +
                 root["version"].asString() + " but client is version " +
                 protocolVersion;
  } else {
    retval.type = seton;
    retval.msg = "Version check ok.";
    doversion = false;
  }

  return retval;
}

CmdMan::CmdRet CmdMan::handleLogin(Json::Value root) {
  CmdRet retval;
  std::cerr << __PRETTY_FUNCTION__ << " begin" << std::endl;

  if (!root["accept"].asBool()) {
    retval.type = error;
    retval.msg = "Login failed: " + root["error"].asString();
  } else {
    retval.type = seton;
    retval.msg = "Login ok.";
    dologin = false;
  }

  return retval;
}