path: root/src/GetEssen.cpp

#include "GetEssen.hpp"

#include "sqdb.hpp"
#include "Utilities.hpp"

using std::string;

bool
Handler::MensaHandler::db_update_mensa_message(const int &mensaID, const ptime &mensaDatum, const std::vector<crow::json::wvalue> &message) {
    sqdb::Db db("../main.sqlite");

    std::string messageFromJSON;
    for (auto &mes : message){
        messageFromJSON.append(mes.keys().at(0));
    }


    string newTime = to_simple_string(ptime(boost::posix_time::second_clock::local_time()));
    string mensaDatumString =
            std::to_string(mensaDatum.date().year()) + "-" + mensaDatum.date().month().as_short_string() + "-" +
            std::to_string(mensaDatum.date().day().as_number());
    sqdb::QueryStr str;
    db.Query(str.Format(
            SQDB_MAKE_TEXT("update mensa set Message = '%s', LastModified = '%s' where ID = %i and Datum = '%s';"),
            messageFromJSON.c_str(), newTime.c_str(), mensaID, mensaDatumString.c_str())).Next();
    return true;
}

bool
Handler::MensaHandler::db_insert_mensa_message(const int &mensaID, const ptime &mensaDatum, const string &message) {
    sqdb::Db db("../main.sqlite");
    string newTime = to_simple_string(ptime(boost::posix_time::second_clock::local_time()));
    string mensaDatumString =
            std::to_string(mensaDatum.date().year()) + "-" + mensaDatum.date().month().as_short_string() + "-" +
            std::to_string(mensaDatum.date().day().as_number());
    sqdb::QueryStr str;
    db.Query(str.Format(SQDB_MAKE_TEXT("insert into mensa values(%i, '%s', '%s', '%s');"), mensaID, message.c_str(),
                        mensaDatumString.c_str(), newTime.c_str())).Next();
    return true;
}

Handler::MensaHandler::MensaEssen
Handler::MensaHandler::db_get_mensa_message(const int &mensaID, const ptime &mensaDatum) {
    MensaEssen out;
    sqdb::Db db("../main.sqlite");

    sqdb::QueryStr str;
    string mensaDatumString =
            std::to_string(mensaDatum.date().year()) + "-" + mensaDatum.date().month().as_short_string() + "-" +
            std::to_string(mensaDatum.date().day().as_number());
    sqdb::Statement s = db.Query(
            str.Format(SQDB_MAKE_TEXT("SELECT * from mensa WHERE Datum = '%s' AND ID = %i;"), mensaDatumString.c_str(),
                       mensaID));

    try {
        if (s.Next()) {
            int ID = s.GetField(0);
            auto tmpData = crow::json::load(s.GetField(1).GetString());
            auto Message = tmpData;
            string Datum = s.GetField(2);
            string LastModified = s.GetField(3);


            ptime LMDate(boost::posix_time::time_from_string(LastModified));

            out.ID = ID;
            out.Message.push(Message);
            out.Datum = mensaDatum;
            out.LastModified = LMDate;
            return out;
        }
    } catch (sqdb::Exception &exception) {
        std::cerr << "Error code: " << exception.GetErrorCode() << " Error Message: " << exception.GetErrorMsg()
                  << std::endl;
    }
    out.ID = -2;
    return out;
}

std::vector<crow::json::wvalue> Handler::MensaHandler::getEssen(const int mensa_ID, const int offset) {
    std::vector<crow::json::wvalue> reply_vec;

    if (offset >= 0) {
        if (offset > 28) {
            reply_vec.emplace_back(Response::create_text(
                    "Ich fühle mich geschmeichelt, dass du denkst, dass ich so weit in die Zukunft gucken kann (0 bis 28 Tage)"));
            return reply_vec;
        }

        ptime datumNow = boost::posix_time::second_clock::local_time();
        ptime datumEssen = datumNow + (boost::gregorian::days(offset));

        MensaEssen Essen = db_get_mensa_message(mensa_ID, datumEssen);
        if (Essen.ID == -2) { // SQL got nothing back :/
            //log("sql got nothing back!");
            return getEssenOnline(mensa_ID, datumEssen);
        }

        if (Essen.LastModified + boost::posix_time::hours(2) < datumNow) { // LastModified is more than 2 hours old
            if (downloadMensaFile(mensa_ID, datumEssen) != CURLE_OK) {
                std::cerr << "Error downloading file" << std::endl;
                reply_vec.emplace_back(Response::create_text("Error downloading file!"));
                return reply_vec;
            }

            db_update_mensa_message(mensa_ID, datumEssen, read_mensa_message_from_file(mensa_ID));
        }
        return parseEssen(db_get_mensa_message(mensa_ID, datumEssen));
    }

    reply_vec.emplace_back(Response::create_text(
            "Wer denkst du bin ich? Ein Zeitreisender?\nIch kann zwar in die Zukunft gucken, aber nur 28 Tage"));
    return reply_vec;
}

std::vector<crow::json::wvalue> Handler::MensaHandler::read_mensa_message_from_file(const int &mensa_id_file) {
    std::vector<crow::json::wvalue> reply_vec;
    crow::json::wvalue test;

    string s;
    bool serious = false;

    std::ifstream inFile(std::to_string(mensa_id_file));
    while (std::getline(inFile, s)) {
        //out += mensa;
        if (s.find("15.png") != string::npos && serious) {
            string vegan;

            int vegan_byte[4] = {0xF0, 0x9F, 0x8C, 0xB1};
            for (int i : vegan_byte) {
                vegan += (char) i;
            }

            reply_vec.emplace_back(Response::create_text(vegan));
        }

        if (s.find("1.png") != string::npos && serious) {
            string vegetarian;

            int vegetarian_byte[4] = {0xF0, 0x9F, 0x8C, 0xBD};
            for (int i : vegetarian_byte) {
                vegetarian += (char) i;
            }

            reply_vec.emplace_back(Response::create_text(vegetarian));
        }
        if (s.find("splIcon") != string::npos && serious && s.find("1.png") == string::npos &&
            s.find("15.png") == string::npos) {
            string emptyEmoji;
            int emptyEmoji_byte[6] = {0xE2, 0x98, 0xA3, 0xEF, 0xB8, 0x8F};
            for (int i : emptyEmoji_byte) {
                emptyEmoji += (char) i;
            }

            reply_vec.emplace_back(Response::create_text(emptyEmoji));
        }

        if (s.find("splGroup\"") != string::npos) { //Getting the Category of the Meal
            for (int i = 0, j = 0; (unsigned) i < s.length(); ++i) {
                if (s.at(i) == '>') {
                    j = i + 1;
                }
                if (s.at(i) == '<' && j != 0) {
                    s = s.substr(j, i - j);
                    j = 0;
                }

            }
            serious = (s == "Aktionen" || s == "Essen" || s == "Beilagen");
            if (serious) {
                std::vector<crow::json::wvalue> bold;
                bold.emplace_back(Response::create_annotation(Response::AnnotationType::bold));
                reply_vec.emplace_back(Response::create_text("\n"));
                reply_vec.emplace_back(Response::create_text(s, std::move(bold)));
            }
        }

        if (s.find("class=\"bold\"") != string::npos && serious) { //Getting the Meal
            for (int i = 0, j = 0; (unsigned) i < s.length(); ++i) {
                if (s.at(i) == '>') {
                    j = i + 1;
                    //logStatus("Zeichen > gefunden in Position" + std::std::to_string(i));
                }
                if (s.at(i) == '<' && j != 0) {
                    s = s.substr(j, i - j);
                    j = 0;
                }
            }
            reply_vec.emplace_back(Response::create_text("\t" + s));
        }

        if (s.find("euro;") != string::npos && serious) { // getting the price of each Meal
            for (int i = 0, j = 0; (unsigned) i < s.length(); ++i) {
                if (s.at(i) == ';') {
                    j = i + 1;
                }
                if (s.at(i) == '/') {
                    s = s.substr(j, i - j);
                    j = 0;
                }
            }
            std::vector<crow::json::wvalue> bold;
            bold.emplace_back(Response::create_annotation(Response::AnnotationType::bold));
            reply_vec.emplace_back(Response::create_text("\t"));
            reply_vec.emplace_back(Response::create_text(s, std::move(bold)));
            reply_vec.emplace_back(Response::create_text("€\n"));
        }
    }

    if (reply_vec.empty()) {
        reply_vec.emplace_back(Response::create_text("Heute kein Essen"));
    }

    return reply_vec;
}

std::vector<crow::json::wvalue> Handler::MensaHandler::parseEssen(MensaEssen Essen) {
    std::vector<crow::json::wvalue> reply_vec;
    std::vector<crow::json::wvalue> bold;
    bold.emplace_back(Response::create_annotation(Response::AnnotationType::bold));

    switch (Essen.ID) {
        case mensa::Adlershof:
            reply_vec.emplace_back(std::move(Response::create_text("Mensa Adlershof", std::move(bold))));
            break;
        case mensa::Nord:
            reply_vec.emplace_back(std::move(Response::create_text("Mensa Nord", std::move(bold))));
            break;
        case mensa::Sued :
            reply_vec.emplace_back(std::move(Response::create_text("Mensa Süd", std::move(bold))));
            break;
        default:
            reply_vec.emplace_back(std::move(Response::create_text("unbekannte Mensa", std::move(bold))));
            break;
    }

    reply_vec.emplace_back(Response::create_text(
            std::to_string(Essen.Datum.date().day().as_number()) + "." +
            std::to_string(Essen.Datum.date().month().as_number()) + "." +
            std::to_string(Essen.Datum.date().year()) + ":\n"));

    while (!Essen.Message.empty()) {
        reply_vec.emplace_back(std::move(Essen.Message.front()));
        Essen.Message.pop();
    }

    reply_vec.emplace_back(Response::create_text("\n(Stand: " + to_simple_string(Essen.LastModified) + ")\n"));

    return reply_vec;
}

std::vector<crow::json::wvalue>
Handler::MensaHandler::getEssenOnline(int mensa_ID, boost::posix_time::ptime datumEssen) {
    if (downloadMensaFile(mensa_ID, datumEssen) != CURLE_OK) {
        std::cerr << "Error downloading file" << std::endl;
        std::vector<crow::json::wvalue> reply_vec;
        reply_vec.emplace_back(Response::create_text("Error downloading file!"));
        return reply_vec;
    }

    std::string jsonMessage;
    for (auto &mes : read_mensa_message_from_file(mensa_ID)){
        jsonMessage.append(crow::json::dump(mes));
    }

    db_insert_mensa_message(mensa_ID, datumEssen, jsonMessage);

    return parseEssen(db_get_mensa_message(mensa_ID, datumEssen));
}

Handler::json Handler::mensaHandler(const std::string &arguments, const std::string &session, void *payload) {
    (void) payload;
    Handler::MensaHandler::mensa Mensa_ID;

    auto args = tokenizeArguments(arguments);

    std::string mensa_name = (!args.empty() ? args.at(0) : "adlershof");
    std::string offset_request = (args.size() > 1 ? args.at(1) : "0");

    if (mensa_name == "adlershof") {
        Mensa_ID = Handler::MensaHandler::mensa::Adlershof;
    } else if (mensa_name == "nord") {
        Mensa_ID = Handler::MensaHandler::mensa::Nord;
    } else if (mensa_name == "sued" || mensa_name == "süd") {
        Mensa_ID = Handler::MensaHandler::mensa::Sued;
    } else {
        Mensa_ID = Handler::MensaHandler::mensa::Adlershof;
    }

    int offset = std::stoi(offset_request);

    return Response::create_response(getEssen(Mensa_ID, offset));
}