515 lines
17 KiB
C++
515 lines
17 KiB
C++
/*
|
|
Fannyapp - Application to view the cover plan of the Fanny-Leicht-Gymnasium ins Stuttgart Vaihingen, Germany
|
|
Copyright (C) 2019 Itsblue Development <development@itsblue.de>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published
|
|
by the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "headers/serverconn.h"
|
|
#define http https
|
|
|
|
ServerConn * pGlobalServConn = nullptr;
|
|
|
|
ServerConn::ServerConn(QObject *parent) : QObject(parent)
|
|
{
|
|
qDebug("+----- ServerConn constructor -----+");
|
|
pGlobalServConn = this;
|
|
|
|
this->fileHelper = new FileHelper();
|
|
connect(this->fileHelper, &FileHelper::shareError, [=](){qWarning() << "share error";});
|
|
connect(this->fileHelper, &FileHelper::shareFinished, [=](){qWarning() << "share finished";});
|
|
connect(this->fileHelper, &FileHelper::shareNoAppAvailable, [=](){qWarning() << "share no app available";});
|
|
|
|
// get local work path
|
|
#if defined (Q_OS_IOS)
|
|
QString docLocationRoot = QStandardPaths::standardLocations(QStandardPaths::DocumentsLocation).value(0);
|
|
qDebug() << "iOS: QStandardPaths::DocumentsLocation: " << docLocationRoot;
|
|
#elif defined(Q_OS_ANDROID)
|
|
QString docLocationRoot = QStandardPaths::standardLocations(QStandardPaths::AppDataLocation).value(0);
|
|
#else
|
|
QString docLocationRoot = QStandardPaths::standardLocations(QStandardPaths::AppDataLocation).value(0);
|
|
#endif
|
|
mDocumentsWorkPath = docLocationRoot.append("/tmp_pdf_files");
|
|
if (!QDir(mDocumentsWorkPath).exists()) {
|
|
if (!QDir("").mkpath(mDocumentsWorkPath)) {
|
|
pGlobalAppSettings->writeSetting("localDocPathError", "true");
|
|
}
|
|
}
|
|
|
|
// check login state
|
|
int perm = pGlobalAppSettings->loadSetting("permanent").toInt();
|
|
qDebug() << "+----- login state: " << perm << " -----+";
|
|
|
|
if(perm == 1){
|
|
// permanent login -> restore login
|
|
this->username = pGlobalAppSettings->loadSetting("username");
|
|
this->password = pGlobalAppSettings->loadSetting("password");
|
|
|
|
this->setState("loggedIn");
|
|
}
|
|
else {
|
|
this->setState("notLoggedIn");
|
|
}
|
|
}
|
|
|
|
int ServerConn::login(QString username, QString password, bool permanent)
|
|
{
|
|
|
|
// add the data to the request
|
|
QUrlQuery pdata;
|
|
pdata.addQueryItem("username", username);
|
|
pdata.addQueryItem("password", password);
|
|
|
|
// send the request
|
|
QVariantMap ret = this->senddata(QUrl("https://www.fanny-leicht.de/j34/templates/g5_helium/intern/events.php"), pdata);
|
|
|
|
if(ret["status"].toInt() == 200){
|
|
// if not 200 was returned -> user data was correct
|
|
// store username and password in the class variables
|
|
this->username = username;
|
|
this->password = password;
|
|
|
|
if(permanent){
|
|
// if the user wants to say logged in, store the username and password to the settings file
|
|
pGlobalAppSettings->writeSetting("permanent", "1");
|
|
pGlobalAppSettings->writeSetting("username", username);
|
|
pGlobalAppSettings->writeSetting("password", password);
|
|
}
|
|
|
|
// set state to loggedIn
|
|
this->setState("loggedIn");
|
|
|
|
qDebug() << "+----- logged in -----+";
|
|
|
|
// return success
|
|
return(200);
|
|
}
|
|
else {
|
|
// if not 200 was returned -> error -> return the return code
|
|
this->setState("notLoggedIn");
|
|
// -> reset the stored credentinals
|
|
pGlobalAppSettings->writeSetting("permanent", "0");
|
|
pGlobalAppSettings->writeSetting("username", "");
|
|
pGlobalAppSettings->writeSetting("password", "");
|
|
return(ret["status"].toInt());
|
|
}
|
|
}
|
|
|
|
int ServerConn::logout()
|
|
{
|
|
// reset the data stored in the class
|
|
this->username = "";
|
|
this->password = "";
|
|
|
|
// reset the data stored in the settings
|
|
pGlobalAppSettings->writeSetting("permanent", "0");
|
|
pGlobalAppSettings->writeSetting("username", "");
|
|
pGlobalAppSettings->writeSetting("password", "");
|
|
|
|
this->setState("notLoggedIn");
|
|
|
|
qDebug() << "+----- logout -----+";
|
|
|
|
// return success
|
|
return(200);
|
|
}
|
|
|
|
int ServerConn::getEvents(QString day)
|
|
{
|
|
// day: 0-today; 1-tomorrow
|
|
if(this->state != "loggedIn"){
|
|
return(401);
|
|
}
|
|
|
|
// add the data to the request
|
|
QUrlQuery pdata;
|
|
pdata.addQueryItem("username", this->username);
|
|
pdata.addQueryItem("password", this->password);
|
|
pdata.addQueryItem("mode", pGlobalAppSettings->loadSetting("teacherMode") == "true" ? "1":"0");
|
|
pdata.addQueryItem("day", day);
|
|
|
|
// send the request
|
|
QVariantMap ret = this->senddata(QUrl("https://www.fanny-leicht.de/j34/templates/g5_helium/intern/events.php"), pdata);
|
|
|
|
if(ret["status"].toInt() != 200){
|
|
// if the request didn't result in a success, clear the old events, as they are probaply incorrect and return the error code
|
|
this->m_events.clear();
|
|
|
|
if(ret["status"].toInt() == 401){
|
|
// if the stats code is 401 -> userdata is incorrect
|
|
qDebug() << "+----- checkconn: user data is incorrect -----+";
|
|
logout();
|
|
}
|
|
|
|
return ret["status"].toInt();
|
|
}
|
|
|
|
|
|
// get the filers list for later usage
|
|
QList<QStringList> filtersList = pGlobalAppSettings->readFilters();
|
|
|
|
// remove all elements from the filters list, that do not match the current mode ( teacher / student ) of the app
|
|
for(int i = 0; i < filtersList.length(); i++){
|
|
QStringList filterList = filtersList[i];
|
|
if( !(pGlobalAppSettings->loadSetting("teacherMode") == "true" ? filterList[2] == "t":filterList[2] == "s") ){
|
|
filtersList.removeAt(i);
|
|
i = i-1;
|
|
}
|
|
}
|
|
|
|
// list to be returned
|
|
QList<QStringList> tmpEvents;
|
|
QStringList tmpEventHeader;
|
|
|
|
//qDebug() << jsonString;
|
|
QJsonDocument jsonFilters = QJsonDocument::fromJson(ret["text"].toString().toUtf8());
|
|
|
|
// array with tghe whole response in it
|
|
QJsonObject JsonArray = jsonFilters.object();
|
|
|
|
// get the version of the json format
|
|
QString version = JsonArray.value("version").toString();
|
|
QStringList versionList = version.split(".");
|
|
if(versionList.length() < 3){
|
|
return(900);
|
|
}
|
|
|
|
int versionMajor = version.split(".")[0].toInt();
|
|
int versionMinor = version.split(".")[1].toInt();
|
|
//int versionRevision = version.split(".")[2].toInt();
|
|
|
|
if(versionMajor > this->apiVersion[0] || versionMinor > this->apiVersion[1]){
|
|
return(904);
|
|
}
|
|
|
|
// get parse the document out of the return
|
|
QJsonObject dataArray = JsonArray.value("data").toObject();
|
|
|
|
// get the header data
|
|
tmpEventHeader.append(dataArray.value("targetDate").toString());
|
|
tmpEventHeader.append(dataArray.value("refreshDate").toString());
|
|
tmpEventHeader.append(dataArray.value("stewardingClass").toString());
|
|
|
|
// expand the length of the header list to seven to prevent list out of range errors
|
|
while (tmpEventHeader.length() < 7) {
|
|
tmpEventHeader.append("");
|
|
}
|
|
|
|
// append the header to the temporyry event list
|
|
tmpEvents.append(tmpEventHeader);
|
|
|
|
// get the event data
|
|
QJsonArray eventsArray = dataArray.value("events").toArray();
|
|
|
|
for(int i=0; i<eventsArray.count(); i++){
|
|
// get the current event-list out of the array
|
|
QJsonArray eventArray = eventsArray[i].toArray();
|
|
|
|
// lst to store the current event
|
|
QStringList tmpEventList;
|
|
|
|
// extract values from array
|
|
foreach(const QJsonValue & key, eventArray){
|
|
// and append them to the temporyry list
|
|
tmpEventList.append(key.toString());
|
|
}
|
|
|
|
while (tmpEventList.length() < 7) {
|
|
// enshure that the list contains at least seven items (to prevent getting list out of range errors)
|
|
tmpEventList.append("");
|
|
}
|
|
|
|
if(filtersList.isEmpty()){
|
|
// if there are no filters append the event immideatly
|
|
tmpEvents.append(tmpEventList);
|
|
}
|
|
else {
|
|
// if there is at least one filter, check if the event matches it
|
|
foreach(QStringList filter, filtersList){
|
|
// go through all filters and check if one of them matches the event
|
|
// always append the first row, as it is the legend
|
|
|
|
if((tmpEventList[0].contains(filter[0]) && tmpEventList[0].contains(filter[1])) || i == 0){
|
|
// append the eventList to the temporary event list
|
|
tmpEvents.append(tmpEventList);
|
|
// terminate the loop
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// check if there is any valid data
|
|
if(tmpEvents.length() == 0 || tmpEvents.length() == 1) {
|
|
// no data was delivered at all -> the server encountered a parse error
|
|
tmpEvents.clear();
|
|
ret["status"].setValue(900);
|
|
}
|
|
else if(tmpEvents.length() == 2) {
|
|
// remove the last (in this case the second) element, as it is unnecessary (it is the legend -> not needed when there is no data)
|
|
tmpEvents.takeLast();
|
|
// set return code to 'no data' (901)
|
|
ret["status"].setValue(901);
|
|
}
|
|
|
|
this->m_events = tmpEvents;
|
|
return(ret["status"].toInt());
|
|
}
|
|
|
|
int ServerConn::openEventPdf(QString day) {
|
|
// day: 0-today; 1-tomorrow
|
|
if(this->state != "loggedIn"){
|
|
return 401;
|
|
}
|
|
|
|
if(pGlobalAppSettings->loadSetting("localDocPathError") == "true") {
|
|
// we have no local document path to work with -> this is not going to work!
|
|
return 905;
|
|
}
|
|
|
|
// add the data to the request
|
|
QUrlQuery pdata;
|
|
pdata.addQueryItem("username", this->username);
|
|
pdata.addQueryItem("password", this->password);
|
|
pdata.addQueryItem("mode", pGlobalAppSettings->loadSetting("teacherMode") == "true" ? "1":"0");
|
|
pdata.addQueryItem("day", day);
|
|
pdata.addQueryItem("asPdf", "true");
|
|
|
|
// send the request
|
|
QVariantMap ret = this->senddata(QUrl("https://www.fanny-leicht.de/j34/templates/g5_helium/intern/events.php"), pdata, true);
|
|
|
|
if(ret["status"].toInt() != 200){
|
|
// if the request didn't result in a success, clear the old events, as they are probaply incorrect and return the error code
|
|
this->m_events.clear();
|
|
|
|
if(ret["status"].toInt() == 401){
|
|
// if the stats code is 401 -> userdata is incorrect
|
|
qDebug() << "+----- checkconn: user data is incorrect -----+";
|
|
logout();
|
|
}
|
|
|
|
return ret["status"].toInt();
|
|
}
|
|
|
|
QString path = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
|
|
QString filname = (QString(pGlobalAppSettings->loadSetting("teacherMode") == "true" ? "l":"s") + QString(day == "0" ? "heute":"morgen" ));
|
|
QFile file(mDocumentsWorkPath + "/" + filname + ".pdf");
|
|
file.remove();
|
|
file.open(QIODevice::ReadWrite);
|
|
file.write(ret["data"].toByteArray());
|
|
file.close();
|
|
|
|
this->fileHelper->viewFile(mDocumentsWorkPath + "/" + filname + ".pdf", "SMorgen", "application/pdf", 1);
|
|
|
|
return 200;
|
|
}
|
|
|
|
int ServerConn::getFoodPlan()
|
|
{
|
|
// list with all data keys which need to be read from the API
|
|
QStringList foodplanDataKeys = { "cookteam", "date", "mainDish", "mainDishVeg", "garnish", "dessert" };
|
|
QString foodplanDateKey = "date";
|
|
|
|
QString url = "http://www.treffpunkt-fanny.de/images/stories/dokumente/Essensplaene/api/TFfoodplanAPI.php?dataCount=10&dataMode=days&dateFormat=U&dataFromTime=now";
|
|
// construct the URL with all requested fields
|
|
foreach(QString foodplanDataKey, foodplanDataKeys){
|
|
url.append("&fields[]="+foodplanDataKey);
|
|
}
|
|
|
|
QUrlQuery pdata;
|
|
// send the request to the server
|
|
QVariantMap ret = this->senddata(QUrl(url), pdata);
|
|
|
|
if(ret["status"].toInt() != 200){
|
|
// if the request didn't result in a success, return the error code
|
|
|
|
// if the request failed but there is still old data available
|
|
if(!this->m_weekplan.isEmpty()){
|
|
// set the status code to 902 (old data)
|
|
ret["status"].setValue(902);
|
|
}
|
|
|
|
return(ret["status"].toInt());
|
|
}
|
|
|
|
// list to be returned
|
|
// m_weekplan is a list, that contains a list for each day, which contains: cookteam, date, main dish, vagi main dish, garnish(Beilage) and Dessert.
|
|
QList<QStringList> tmpWeekplan;
|
|
|
|
//qDebug() << jsonString;
|
|
QJsonDocument jsonDoc = QJsonDocument::fromJson(ret["text"].toString().toUtf8());
|
|
//qDebug() << ret["text"].toString();
|
|
// array with the whole response in it
|
|
QJsonArray foodplanDays = jsonDoc.array();
|
|
|
|
foreach(QJsonValue foodplanDay, foodplanDays){
|
|
QStringList tmpFoodplanDayList;
|
|
|
|
foreach(QString foodplanDataKey, foodplanDataKeys){
|
|
QString dataValue = foodplanDay.toObject().value(foodplanDataKey).toString();
|
|
if(foodplanDataKey == foodplanDateKey){
|
|
QDateTime date;
|
|
date.setSecsSinceEpoch(uint(dataValue.toInt()));
|
|
date.setTimeSpec(Qt::UTC);
|
|
|
|
// get the current date and time
|
|
QDateTime currentDateTime = QDateTime::currentDateTimeUtc();
|
|
|
|
//---------- convert the date to a readable string ----------
|
|
QString readableDateString;
|
|
|
|
if(date.date() == currentDateTime.date()){
|
|
// the given day is today
|
|
readableDateString = "Heute";
|
|
}
|
|
else if (date.toTime_t() < ( currentDateTime.toTime_t() + ( 48 * 60 * 60 ) )) {
|
|
// the given day is tomorrow
|
|
readableDateString = "Morgen";
|
|
}
|
|
else {
|
|
readableDateString = date.toString("dddd, d.M.yy");
|
|
}
|
|
|
|
dataValue = readableDateString;
|
|
}
|
|
|
|
tmpFoodplanDayList.append( dataValue );
|
|
}
|
|
|
|
tmpWeekplan.append(tmpFoodplanDayList);
|
|
|
|
}
|
|
|
|
// write data to global foodplan
|
|
this->m_weekplan = tmpWeekplan;
|
|
|
|
// check if there is any valid data
|
|
if(this->m_weekplan.isEmpty()){
|
|
// no data
|
|
return(901);
|
|
}
|
|
|
|
// success
|
|
return(200);
|
|
}
|
|
|
|
QVariantMap ServerConn::senddata(QUrl serviceUrl, QUrlQuery pdata, bool raw)
|
|
{
|
|
// create network manager
|
|
QNetworkAccessManager * networkManager = new QNetworkAccessManager();
|
|
|
|
QVariantMap ret; //this is a custom type to store the return-data
|
|
|
|
// Create network request
|
|
QNetworkRequest request(serviceUrl);
|
|
request.setHeader(QNetworkRequest::ContentTypeHeader,
|
|
"application/x-www-form-urlencoded");
|
|
|
|
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
|
|
config.setProtocol(QSsl::TlsV1_2);
|
|
request.setSslConfiguration(config);
|
|
|
|
//send a POST request with the given url and data to the server
|
|
|
|
QNetworkReply *reply;
|
|
|
|
// loop to wait until the request has finished before processing the data
|
|
QEventLoop loop;
|
|
// timer to cancel the request after 3 seconds
|
|
QTimer timer;
|
|
timer.setSingleShot(true);
|
|
|
|
// quit the loop when the request finised
|
|
loop.connect(networkManager, SIGNAL(finished(QNetworkReply*)), SLOT(quit()));
|
|
// or the timer timed out
|
|
loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
|
|
// start the timer
|
|
timer.start(10000);
|
|
|
|
this->updateDownloadProgress(0, 1);
|
|
reply = networkManager->post(request, pdata.toString(QUrl::FullyEncoded).toUtf8());
|
|
connect(reply, &QNetworkReply::sslErrors, this, [=](){ reply->ignoreSslErrors(); });
|
|
|
|
connect(reply, SIGNAL(downloadProgress(qint64, qint64)),
|
|
this, SLOT(updateDownloadProgress(qint64, qint64)));
|
|
|
|
// start the loop
|
|
loop.exec();
|
|
|
|
if(!timer.isActive()) {
|
|
// timeout
|
|
return {{"status", 0}};
|
|
}
|
|
|
|
//get the status code
|
|
QVariant status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
|
|
|
|
ret.insert("status", status_code.toInt());
|
|
|
|
//get the full text response
|
|
if(!raw) {
|
|
ret.insert("text", QString::fromUtf8(reply->readAll()));
|
|
}
|
|
else {
|
|
ret.insert("data", reply->readAll());
|
|
}
|
|
|
|
// delete the reply object
|
|
reply->deleteLater();
|
|
|
|
// delete the newtwork access manager object
|
|
networkManager->deleteLater();
|
|
|
|
//return the data
|
|
return(ret);
|
|
}
|
|
|
|
void ServerConn::updateDownloadProgress(qint64 read, qint64 total)
|
|
{
|
|
double progress;
|
|
|
|
if(total <= 0)
|
|
progress = 0;
|
|
else
|
|
progress = (double(read) / double(total));
|
|
|
|
if(progress < 0)
|
|
progress = 0;
|
|
|
|
this->downloadProgress = progress;
|
|
emit this->downloadProgressChanged();
|
|
}
|
|
|
|
QString ServerConn::getState() {
|
|
return(this->state);
|
|
}
|
|
|
|
void ServerConn::setState(QString state) {
|
|
|
|
if(state != this->state){
|
|
qDebug() << "+----- serverconn has new state: " << state << " -----+";
|
|
this->state = state;
|
|
this->stateChanged(this->state);
|
|
}
|
|
}
|
|
|
|
double ServerConn::getDownloadProgress() {
|
|
return this->downloadProgress;
|
|
}
|
|
|
|
ServerConn::~ServerConn()
|
|
{
|
|
qDebug("+----- ServerConn destruktor -----+");
|
|
}
|