CCats/daemon/src/JsonCommander.cpp

#include "../include/JsonCommander.h"
#include "../include/UserManager.h"
#include "../include/base64.h"

JsonCommander::JsonCommander(FileManager &fileManager)
    : fileManager(fileManager) {
  commandsMap["status"] = &JsonCommander::executeStatus;
  commandsMap["close"] = &JsonCommander::executeClose;
  commandsMap["list"] = &JsonCommander::executeList;
  commandsMap["listdata"] = &JsonCommander::executeListData;
  commandsMap["put"] = &JsonCommander::executePut;
  commandsMap["putdata"] = &JsonCommander::executePutdata;
  commandsMap["get"] = &JsonCommander::executeGet;
  commandsMap["getdata"] = &JsonCommander::executeGetdata;
}

JsonCommander::~JsonCommander() {}

JsonCommander::Response JsonCommander::execute(const Json::Value &message) {
  JsonCommander::Response response;

  Response (JsonCommander::*commandExecutor)(const Json::Value &) =
      commandsMap[message["command"].asString()];

  if (commandExecutor != nullptr) {
    response = (this->*commandExecutor)(message);
  } else {
    // command does not exist
    response.action = close;
  }

  return response;
}

JsonCommander::Response
JsonCommander::executeStatus(const Json::Value &message) {
  JsonCommander::Response response;
  response.action = send;
  response.json["command"] = "status";

  // answer a real status message
  std::string status;
  if (this->fileManager.isUploading() && this->fileManager.isDownloading()) {
    status = "download and upload running";
  } else if (this->fileManager.isUploading()) {
    status = "upload running";
  } else if (this->fileManager.isDownloading()) {
    status = "download running";
  } else {
    status = "ok";
  }

  response.json["response"] = status;

  return response;
}

JsonCommander::Response
JsonCommander::executeClose(const Json::Value &message) {
  JsonCommander::Response response;
  response.action = closeAndSend;
  response.json["command"] = "close";
  response.json["response"] = "bye";

  return response;
}

JsonCommander::Response JsonCommander::executeList(const Json::Value &message) {
  JsonCommander::Response response;
  response.action = send;
  response.json["command"] = "list";

  int chunks;
  if (fileManager.getRemainingListChunks() > 0) {
    response.json["accept"] = false;
    response.json["chunks"] = -1;
    response.json["items"] = -1;
    response.json["error"] = "there is already an open list command";
  } else if ((chunks = fileManager.openList()) ==
             -1) { // TODO do we need to check? maybe. Think about it
    response.json["accept"] = false;
    response.json["chunks"] = -1;
    response.json["items"] = -1;
    response.json["error"] = "there is a filename which is too long";
  } else {
    response.json["accept"] = true;
    response.json["chunks"] = chunks;
    response.json["items"] = fileManager.getListSize();
    response.json["error"] = "";
  }

  return response;
}

JsonCommander::Response
JsonCommander::executeListData(const Json::Value &message) {
  JsonCommander::Response response;
  response.action = send;
  response.json["command"] = "listdata";
  Json::Value array;

  const int remainingListchunks = fileManager.getRemainingListChunks();
  if (!message["chunk"].isInt() || !message["cancel"].isBool()) {
    response.action = closeAndSend;
    response.json["cancel"] = true;
    response.json["remaining"] = -1;
    response.json["names"] = Json::arrayValue;
    response.json["error"] = "incorrect listdata command request";
  } else if (remainingListchunks == 0) {
    response.json["cancel"] = true;
    response.json["remaining"] = -1;
    response.json["names"] = Json::arrayValue;
    response.json["error"] = "there are no chunks to send";
  } else if (message["cancel"].asBool()) {
    response.json["cancel"] = true;
    response.json["remaining"] =
        message["chunk"].asInt(); // so it can be associated to the request
    response.json["names"] = Json::arrayValue;
    response.json["error"] = "";
    fileManager.cancelList();
  } else if (remainingListchunks - 1 != message["chunk"].asInt()) {
    response.action = closeAndSend;
    response.json["cancel"] = true;
    response.json["remaining"] = -1;
    response.json["names"] = Json::arrayValue;
    response.json["error"] = "wrong chunk number";
  } else {
    std::vector<std::string> v = fileManager.getNextChunkFromList();
    for (int i = 0; i < v.size(); i++)
      array.append(v.at(i));
    response.json["remaining"] = message["chunk"].asInt();
    response.json["cancel"] = false;
    response.json["names"] = array;
    response.json["error"] = "";
  }

  return response;
}

JsonCommander::Response JsonCommander::executePut(const Json::Value &message) {
  JsonCommander::Response response;
  response.json["command"] = "put";
  response.json["file"] = message["file"].asString();

  if (!message["file"].isString() || !message["size"].isInt() ||
      !message["chunks"].isInt()) {
    // if request is incomplete close connection
    response.action = closeAndSend;
    response.json["accept"] = false;
    response.json["error"] = "incorrect put command request";
  } else if (fileManager.isUploading()) {
    // if an upload is alread running deny request
    response.action = send;
    response.json["accept"] = false;
    response.json["error"] = "upload already running";
  } else if (message["chunks"].asInt() <= 0) {
    response.action = send;
    response.json["accept"] = false;
    response.json["error"] = "there must be at least one chunk";
  } else if (fileManager.checkFilename(message["file"].asString())) {
    // accept request
    response.action = send;

    bool opened = fileManager.openPutFile(message["file"].asString());
    if (opened) {
      response.json["accept"] = true;
      response.json["error"] = "";
      this->putFileReceived = message["chunks"].asInt();
    } else {
      response.json["accept"] = false;
      response.json["error"] = "file already exists";
    }

  } else {
    // deny request if file name is not valid
    response.action = send;
    response.json["accept"] = false;
    response.json["error"] = "invalid file name";
  }

  return response;
}

JsonCommander::Response
JsonCommander::executePutdata(const Json::Value &message) {
  JsonCommander::Response response;
  response.json["command"] = "putdata";
  response.json["file"] = message["file"].asString();
  response.json["received"] = message["remaining"].asInt();

  if (!message["file"].isString() || !message["data"].isString() ||
      !message["remaining"].isInt() || !message["cancel"].isBool()) {
    // if request is incomplete close connection
    response.action = closeAndSend;
    response.json["cancel"] = true;
    response.json["error"] = "incorrect putdata command request";

    this->fileManager.cancelPut();

  } else if (!fileManager.isUploading()) {
    // no upload running -> command
    response.action = send;
    response.json["cancel"] = true;
    response.json["error"] = "no upload running";
  } else if (message["cancel"].asBool()) {
    response.action = send;
    response.json["cancel"] = true;
    response.json["error"] = "";

    this->fileManager.cancelPut();

  } else if (message["file"].asString().compare(
                 fileManager.getPutBaseFileName()) == 0) {

    if (--this->putFileReceived == message["remaining"].asInt()) {
      // accept request
      response.action = send;
      response.json["cancel"] = false;
      response.json["error"] = "";

      const std::vector<char> data =
          base64::decodeVector(message["data"].asString());

      fileManager.writePut(data);

      this->putFileReceived = message["remaining"].asInt();

      if (this->putFileReceived == 0) {
        // close file after last chunk was received
        this->fileManager.closePutFile();
      }

    } else {
      // wrong remaining number
      response.action = send;
      response.json["cancel"] = true;
      response.json["error"] = "wrong remaining number";

      this->fileManager.cancelPut();
    }
  } else {
    // wrong file name
    response.action = send;
    response.json["cancel"] = true;
    response.json["error"] = "another file was already being uploaded";

    this->fileManager.cancelPut();
  }

  return response;
}

JsonCommander::Response JsonCommander::executeGet(const Json::Value &message) {
  JsonCommander::Response response;
  response.json["command"] = "get";
  response.json["file"] = message["file"].asString();

  if (!message["file"].isString()) {
    // if request is incomplete close connection
    response.action = closeAndSend;
    response.json["accept"] = false;
    response.json["chunks"] = -1;
    response.json["error"] = "incorrect get command request";
  } else if (fileManager.isDownloading()) {
    // if an upload is alread running deny request
    response.action = send;
    response.json["accept"] = false;
    response.json["chunks"] = -1;
    response.json["error"] = "download already running";
  } else if (fileManager.checkFilename(message["file"].asString())) {
    // accept request
    response.action = send;

    bool opened = fileManager.openGetFile(message["file"].asString(),
                                          this->getFileRemaining);
    if (opened) {
      response.json["accept"] = true;
      response.json["chunks"] = this->getFileRemaining;
      response.json["error"] = "";
    } else {
      response.json["accept"] = false;
      response.json["chunks"] = -1;
      response.json["error"] = "file does not exist";
    }

  } else {
    // deny request if file name is not valid
    response.action = send;
    response.json["accept"] = false;
    response.json["chunks"] = -1;
    response.json["error"] = "invalid file name";
  }

  return response;
}

JsonCommander::Response
JsonCommander::executeGetdata(const Json::Value &message) {
  JsonCommander::Response response;
  response.json["command"] = "getdata";
  response.json["file"] = message["file"].asString();
  response.json["remaining"] = message["chunk"].asInt();

  if (!message["file"].isString() || !message["chunk"].isInt() ||
      !message["cancel"].isBool()) {
    // if request is incomplete close connection
    response.action = closeAndSend;
    response.json["cancel"] = true;
    response.json["data"] = "";
    response.json["error"] = "incorrect putdata command request";

    this->fileManager.closeGetFile();

  } else if (!fileManager.isDownloading()) {
    // no upload running -> command
    response.action = send;
    response.json["cancel"] = true;
    response.json["data"] = "";
    response.json["error"] = "no download running";
  } else if (message["cancel"].asBool()) {
    response.action = send;
    response.json["cancel"] = true;
    response.json["data"] = "";
    response.json["error"] = "";

    this->fileManager.closeGetFile();

  } else if (message["file"].asString().compare(
                 fileManager.getGetBaseFileName()) == 0) {

    if (--this->getFileRemaining == message["chunk"].asInt()) {
      // accept request
      response.action = send;
      response.json["cancel"] = false;
      response.json["error"] = "";

      const std::vector<char> data = fileManager.readGet();
      response.json["data"] = base64::encodeVector(data);

      fileManager.writePut(data);

      if (this->getFileRemaining == 0) {
        // close file after last chunk was sent
        this->fileManager.closeGetFile();
      }

    } else {
      // wrong chunk number
      response.action = send;
      response.json["cancel"] = true;
      response.json["data"] = "";
      response.json["error"] = "wrong chunk number";

      this->fileManager.closeGetFile();
    }
  } else {
    // wrong file name
    response.action = send;
    response.json["cancel"] = true;
    response.json["data"] = "";
    response.json["error"] = "another file was already being downloaded";

    this->fileManager.closeGetFile();
  }

  return response;
}

JsonCommander::Response JsonCommander::testVersion(const Json::Value &message) {
  JsonCommander::Response response;
  response.json["version"] = this->protocolVersion;

  // check version string is the same
  if (message["version"].asString().compare(this->protocolVersion) == 0) {
    response.action = send;
    response.json["accept"] = true;
  } else {
    response.action = closeAndSend;
    response.json["accept"] = false;
  }

  return response;
}

JsonCommander::Response JsonCommander::checkLogin(const Json::Value &message) {
  JsonCommander::Response response;

  if (!message["login"].isBool() || !message["user"].isString() ||
      !message["pass"].isString() || !message["cancel"].isBool()) {
    // invalid login request
    response.action = closeAndSend;
    response.json["accept"] = false;
    response.json["error"] = "invalid login request";
  } else if (message["cancel"].asBool()) {
    response.action = close;

  } else if (message["login"].asBool() &&
             UserManager::isAllowed(message["user"].asString(),
                                    message["pass"].asString())) {
    // credential check
    response.action = send;
    response.json["accept"] = true;
    response.json["error"] = "";
  } else if (!message["login"].asBool()) {
    // add user. Check if already exists before
    if (!UserManager::addUser(message["user"].asString(),
                              message["pass"].asString())) {
      response.action = closeAndSend;
      response.json["accept"] = false;
      response.json["error"] = "user does already exist";
    } else {
      response.action = send;
      response.json["accept"] = true;
      response.json["error"] = "";
    }

  } else {
    // reject user
    response.action = closeAndSend;
    response.json["accept"] = false;
    response.json["error"] = "wrong username or password";
  }

  return response;
}