581 lines
23 KiB
C++
Executable File
581 lines
23 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* CodificationDataManagement - Import codification table csv data
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by hjl, SLSE, 2017-03-02
|
|
*/
|
|
|
|
#include "cod_csv_import.h"
|
|
#include "cod_numeral_code_model.h"
|
|
#include "cod_authentication_code_model.h"
|
|
#include "cod_logistical_terms_model.h"
|
|
#include "cod_phrase_table_model.h"
|
|
|
|
#include <LtsWidgets/lts_message_dialog.h>
|
|
|
|
#include <QFile>
|
|
#include <QFileDialog>
|
|
#include <QBuffer>
|
|
|
|
using namespace CodificationManagement;
|
|
|
|
|
|
CSVImport::CSVImport(NumeralCodeModel *numCodeModel,
|
|
AuthenticationCodeModel *authenticationCodeModel,
|
|
LogisticalTermsModel *logisticalTermsModel,
|
|
PhraseTableModel *phraseTableModel,
|
|
QString *note,
|
|
QWidget *parent)
|
|
: QWidget(parent)
|
|
, m_numCodeModel(numCodeModel)
|
|
, m_authenticationCodeModel(authenticationCodeModel)
|
|
, m_logisticalTermsModel(logisticalTermsModel)
|
|
, m_phraseTableModel(phraseTableModel)
|
|
, m_note(note)
|
|
, m_logger(getLogger("CodificationCSVImport"))
|
|
{
|
|
} // end of ctor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
CSVImport::CSVImportResult CSVImport::loadCSVDataByteArray(QByteArray content)
|
|
{
|
|
QBuffer buffer;
|
|
buffer.setBuffer(&content);
|
|
buffer.open(QIODevice::ReadOnly);
|
|
|
|
QByteArray qbaNumCodeHorizontalHeader; // <Numeral Code Horizontal Header>
|
|
QByteArray qbaNumCodeVerticalHeader; // <Numeral Code Vertical Header>
|
|
QByteArray qbaAuthenticationCodeMatrix; // <Authentication Code Matrix>
|
|
QByteArray qbaLogTermsTableHorizontalHeader; // <Logistical Terms Table Horizontal Header>
|
|
QByteArray qbaLogTermsTableVerticalHeader; // <Logistical Terms Table Vertical Header>
|
|
QByteArray qbaLogTermsTableMatrix; // <Logistical Terms Table Matrix>
|
|
QByteArray qbaPhraseTableMatrix; // <Phrase Table Matrix>
|
|
QByteArray qbaNote; // <Note>
|
|
QByteArray *qba;
|
|
|
|
qba = nullptr;
|
|
|
|
int desiredCvsSeperatorsPerLine = 0;
|
|
int csvKeywordCount = 0;
|
|
|
|
QByteArray qbaMergeQuotedEntriesPerLine;
|
|
|
|
bool isMergedLine = false;
|
|
|
|
while (!buffer.atEnd())
|
|
{
|
|
QByteArray qbaLine = buffer.readLine(); // '\n' in quoted Eintraegen wird hier als Line Ende interpretiert!!
|
|
|
|
// DEBUG_LOG(m_logger) << "qbaLine (raw): \"" << qbaLine << "\"";
|
|
|
|
// WindowsEnd -> UnixEnd
|
|
if (qbaLine.endsWith("\r\n"))
|
|
qbaLine.remove(qbaLine.lastIndexOf('\r'), 1);
|
|
|
|
if (qbaLine.startsWith("<"))
|
|
{
|
|
// alle ; Zeichen nach > abschneiden
|
|
int index = qbaLine.indexOf('>');
|
|
qbaLine.truncate(index + 1);
|
|
qbaLine.append('\n');
|
|
|
|
if (qbaLine == "<Numeral Code Horizontal Header>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaNumCodeHorizontalHeader;
|
|
desiredCvsSeperatorsPerLine = 12;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Numeral Code Vertical Header>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaNumCodeVerticalHeader;
|
|
desiredCvsSeperatorsPerLine = 0;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Authentication Code Matrix>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaAuthenticationCodeMatrix;
|
|
desiredCvsSeperatorsPerLine = 4;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Logistical Terms Table Horizontal Header>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaLogTermsTableHorizontalHeader;
|
|
desiredCvsSeperatorsPerLine = 4;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Logistical Terms Table Vertical Header>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaLogTermsTableVerticalHeader;
|
|
desiredCvsSeperatorsPerLine = 0;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Logistical Terms Table Matrix>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaLogTermsTableMatrix;
|
|
desiredCvsSeperatorsPerLine = 4;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Phrase Table Matrix>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaPhraseTableMatrix;
|
|
desiredCvsSeperatorsPerLine = 1;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
|
|
if (qbaLine == "<Note>\n")
|
|
{
|
|
DEBUG_LOG(m_logger) << "found " << qbaLine;
|
|
qba = &qbaNote;
|
|
desiredCvsSeperatorsPerLine = 0;
|
|
++csvKeywordCount;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (qba)
|
|
{
|
|
if (! qbaLine.contains('"') && ! isMergedLine)
|
|
{
|
|
// Zeile komplett uebernehmen ...
|
|
removeRedundantCvsSeperators(qbaLine, desiredCvsSeperatorsPerLine);
|
|
qba->append(qbaLine);
|
|
continue;
|
|
}
|
|
|
|
// moegliche Varianten (Betrachtung speziell fuer LogTermsTable) :
|
|
// a.) Zeile enthaelt (oeffnendes) " =>> isMergedLine = true setzen -> Zeile in Buf zwischenspeichern -> continue
|
|
// ... kann hier nur ein " enthalten, da der quoted Anteil mit \n endet !
|
|
// b.) naechste zeile enthaelt kein " =>> da isMergedLine == true, sind es quoted Daten -> Daten an Buf anhaengen -> continue
|
|
// c.) oder Zeile enthaelt (schliessendes) " =>> Daten bis " an Buf anhaengen
|
|
// ... und ggf weiteres (oeffnendes) " =>> Pruefen ob weiteres (oeffnendes) " vorhanden (das kann sein, wenn die Excelzeile weitere quoted Eintraege enthaelt)
|
|
// - wenn ja, restliche Zeichen an Buf anhaengen -> continue
|
|
// - wenn nein, restliche Zeichen an Buf anhaengen -> Zeile komplett...
|
|
// Gesammelte Zeile in qbaLine uebernehmen
|
|
// qbaLine = qbaMergeQuotedEntriesPerLine;
|
|
// qbaMergeQuotedEntriesPerLine.clear();
|
|
// isMergedLine = false setzen
|
|
// removeRedundantCvsSeperators(qbaLine, desiredCvsSeperatorsPerLine);
|
|
// qba->append(qbaLine);
|
|
|
|
// a.)
|
|
if (qbaLine.contains('"') && ! isMergedLine)
|
|
{
|
|
isMergedLine = true;
|
|
qbaMergeQuotedEntriesPerLine.append(qbaLine);
|
|
continue;
|
|
}
|
|
|
|
// b.) mehrzeiliges Quote...
|
|
if (! qbaLine.contains('"') && isMergedLine)
|
|
{
|
|
qbaMergeQuotedEntriesPerLine.append(qbaLine);
|
|
continue;
|
|
}
|
|
|
|
// c.)
|
|
if (qbaLine.contains('"') && isMergedLine)
|
|
{
|
|
// Daten bis incl. " an Buf anhaengen
|
|
int idx = qbaLine.indexOf('\"');
|
|
QByteArray qbaQuotedPart = qbaLine.left(idx + 1); // incl. "
|
|
qbaMergeQuotedEntriesPerLine.append(qbaQuotedPart);
|
|
|
|
// Rest der Zeile nach schliessenden "
|
|
QByteArray qbaRestLine = qbaLine.mid(idx + 1);
|
|
|
|
// Pruefen ob im Rest noch weiteres (oeffnendes) " vorhanden
|
|
if (! qbaRestLine.contains('"'))
|
|
{
|
|
// Gesamte CSV-Zeile fertig
|
|
qbaMergeQuotedEntriesPerLine.append(qbaRestLine);
|
|
// Gesammelte Zeile in qbaLine uebernehmen
|
|
qbaLine = qbaMergeQuotedEntriesPerLine;
|
|
|
|
// Merge Modus beenden und fuer naechsten vorbereiten
|
|
qbaMergeQuotedEntriesPerLine.clear();
|
|
isMergedLine = false;
|
|
|
|
// Zeile komplett uebernehmen ...
|
|
removeRedundantCvsSeperators(qbaLine, desiredCvsSeperatorsPerLine);
|
|
qba->append(qbaLine);
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
// Rest enthaelt noch ein oeffnendes ". Rest der Zeile an Buf anhaengen
|
|
qbaMergeQuotedEntriesPerLine.append(qbaRestLine);
|
|
continue;
|
|
}
|
|
}
|
|
} // if (qba)
|
|
} // while (!buffer.atEnd())
|
|
|
|
|
|
if (csvKeywordCount != 8)
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data failed! Invalid csvKeywordCount. Soll/Ist: 8/" << csvKeywordCount;
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data failed! Invalid number of cvs keywords."), tr("CSV Load Error"));
|
|
return CSVImportResult::LoadFailed;
|
|
}
|
|
|
|
// show load csv data blocks
|
|
DEBUG_LOG(m_logger) << "Load csv ready... ";
|
|
DEBUG_LOG(m_logger) << "\n-----------start show load csv data blocks -------------------------\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Numeral Code Horizontal Header>: \"" << qbaNumCodeHorizontalHeader << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Numeral Code Vertical Header>: \"" << qbaNumCodeVerticalHeader << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Authentication Code Matrix>: \"" << qbaAuthenticationCodeMatrix << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Logistical Terms Table Horizontal Header>: \"" << qbaLogTermsTableHorizontalHeader << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Logistical Terms Table Vertical Header>: \"" << qbaLogTermsTableVerticalHeader << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Logistical Terms Table Matrix>: \"" << qbaLogTermsTableMatrix << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Phrase Table Matrix>: \"" << qbaPhraseTableMatrix << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n<Block ... <Note>: \"" << qbaNote << "\"\n";
|
|
DEBUG_LOG(m_logger) << "\n-----------end of show load csv data blocks -------------------------\n";
|
|
|
|
// Numeral Code table
|
|
qbaNumCodeHorizontalHeader = qbaNumCodeHorizontalHeader.trimmed(); // remove last `\n`
|
|
if (checkNumCodeHorizontalHeader(qbaNumCodeHorizontalHeader))
|
|
m_numCodeModel->setColumnSelectionValuesCSV(QString::fromUtf8(qbaNumCodeHorizontalHeader));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
qbaNumCodeVerticalHeader = qbaNumCodeVerticalHeader.trimmed(); // remove last `\n`
|
|
if (checkNumCodeVerticalHeader(qbaNumCodeVerticalHeader))
|
|
m_numCodeModel->setRowSelectionValuesCSV(QString::fromUtf8(qbaNumCodeVerticalHeader));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
// Authentication table
|
|
qbaAuthenticationCodeMatrix = qbaAuthenticationCodeMatrix.trimmed(); // remove last `\n`
|
|
if (checkAuthenticationCodeMatrix(qbaAuthenticationCodeMatrix))
|
|
m_authenticationCodeModel->setMatrixValuesCSV(QString::fromUtf8(qbaAuthenticationCodeMatrix));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
// Logistical Terms table
|
|
qbaLogTermsTableHorizontalHeader = qbaLogTermsTableHorizontalHeader.trimmed(); // remove last `\n`
|
|
if (checkLogTermsTableHorizontalHeader(qbaLogTermsTableHorizontalHeader))
|
|
m_logisticalTermsModel->setColumnSelectionValuesCSV(QString::fromUtf8(qbaLogTermsTableHorizontalHeader));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
qbaLogTermsTableVerticalHeader = qbaLogTermsTableVerticalHeader.trimmed(); // remove last `\n`
|
|
if (checkLogTermsTableVerticalHeader(qbaLogTermsTableVerticalHeader))
|
|
m_logisticalTermsModel->setRowSelectionValuesCSV(QString::fromUtf8(qbaLogTermsTableVerticalHeader));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
qbaLogTermsTableMatrix = qbaLogTermsTableMatrix.trimmed(); // remove last `\n`
|
|
if (checkLogTermsTableMatrix(qbaLogTermsTableMatrix))
|
|
m_logisticalTermsModel->setMatrixValuesCSV(QString::fromUtf8(qbaLogTermsTableMatrix));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
// Phrase table
|
|
qbaPhraseTableMatrix = qbaPhraseTableMatrix.trimmed(); // remove last `\n`
|
|
if (checkPhraseTableMatrix(qbaPhraseTableMatrix))
|
|
m_phraseTableModel->setMatrixValuesCSV(QString::fromUtf8(qbaPhraseTableMatrix));
|
|
else
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
// Note
|
|
qbaNote = qbaNote.trimmed(); // remove last `\n`
|
|
removeQuotedCharInNote(qbaNote);
|
|
m_note->clear();
|
|
m_note->append(QString::fromUtf8(qbaNote));
|
|
return CSVImportResult::LoadOk;
|
|
}
|
|
|
|
|
|
CSVImport::CSVImportResult CSVImport::loadCSVData()
|
|
{
|
|
DEBUG_LOG(m_logger) << "loadCSVData()";
|
|
|
|
QFileDialog dialog;
|
|
dialog.setNameFilter(tr("CSV File (*.csv)"));
|
|
dialog.setAcceptMode(QFileDialog::AcceptOpen);
|
|
dialog.setDirectory(QLatin1String("../TMP"));
|
|
|
|
if (dialog.exec() == QDialog::Rejected)
|
|
return CSVImportResult::UserAbort;
|
|
|
|
const QStringList fileNames = dialog.selectedFiles();
|
|
if (fileNames.isEmpty())
|
|
return CSVImportResult::LoadFailed;
|
|
|
|
QFile file;
|
|
file.setFileName(fileNames.first());
|
|
|
|
if (!file.open(QFile::ReadOnly))
|
|
{
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("File is not accessible!"), tr("CSV Import Error"));
|
|
return CSVImportResult::LoadFailed;
|
|
}
|
|
QByteArray byteArray = file.readAll();
|
|
file.close();
|
|
//////////////////////
|
|
loadCSVDataByteArray(byteArray);
|
|
|
|
return CSVImportResult::LoadOk;
|
|
|
|
} // end of loadCSVData()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkNumCodeHorizontalHeader(const QByteArray &qbaNumCodeHorizontalHeader)
|
|
{
|
|
// Soll: 13 Zeichen in einer Zeile getrennt durch `;`
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaNumCodeHorizontalHeader << "\"";
|
|
DEBUG_LOG(m_logger) << "Data.size: Soll/Ist: 13 + 12 = 25/" << qbaNumCodeHorizontalHeader.size();
|
|
|
|
if (qbaNumCodeHorizontalHeader.size() == 25)
|
|
return true;
|
|
ERROR_LOG(m_logger) << "Load csv data 'Numeral Code Horizontal Header' failed!";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Numeral Code Horizontal Header' failed!"), tr("CSV Load Error"));
|
|
return false;
|
|
} // end of checkNumCodeHorizontalHeader()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkNumCodeVerticalHeader(const QByteArray &qbaNumCodeVerticalHeader)
|
|
{
|
|
// Soll: 13 Zeichen jeweils abgeschlossen mit `\n` (last `\n` removed)
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaNumCodeVerticalHeader << "\"";
|
|
DEBUG_LOG(m_logger) << "Data.size: Soll/Ist: 13 + 12 = 25/" << qbaNumCodeVerticalHeader.size();
|
|
|
|
if (qbaNumCodeVerticalHeader.size() == 25)
|
|
return true;
|
|
ERROR_LOG(m_logger) << "Load csv data 'Numeral Code Vertical Header' failed!";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Numeral Code Vertical Header' failed!"), tr("CSV Load Error"));
|
|
return false;
|
|
} // end of checkNumCodeVerticalHeader()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkAuthenticationCodeMatrix(QByteArray &qbaAuthenticationCodeMatrix)
|
|
{
|
|
// Soll: 13 Zeilen mit je 5x2 Zeichen getrennt durch `;` Zeile mit `\n` abgeschlossen (last `\n` removed)
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaAuthenticationCodeMatrix << "\"";
|
|
|
|
QByteArray qbaOutMatrix;
|
|
|
|
QList<QByteArray> qbaLinesList = qbaAuthenticationCodeMatrix.split('\n');
|
|
|
|
for (QByteArray &line : qbaLinesList)
|
|
{
|
|
QList<QByteArray> qbaLineList = line.split(';');
|
|
|
|
for (QByteArray &segment : qbaLineList)
|
|
{
|
|
if (segment.size() == 1) // fuehrende Null hinzufuegen
|
|
segment = segment.rightJustified(2, '0');
|
|
}
|
|
line = qbaLineList.join(';');
|
|
}
|
|
qbaOutMatrix = qbaLinesList.join('\n');
|
|
|
|
qbaAuthenticationCodeMatrix = qbaOutMatrix;
|
|
|
|
DEBUG_LOG(m_logger) << "Data.size: Soll/Ist: 13 * (5*2 + 4 + 1) -1 = 194 /" << qbaAuthenticationCodeMatrix.size();
|
|
|
|
if (qbaAuthenticationCodeMatrix.size() == 194)
|
|
return true;
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Authentication Code Matrix' failed!";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Authentication Code Matrix' failed!"), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
} // end of checkAuthenticationCodeMatrix()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkLogTermsTableHorizontalHeader(const QByteArray &qbaLogTermsTableHorizontalHeader)
|
|
{
|
|
// Soll: 5 Zeichen in einer Zeile getrennt durch `;`
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaLogTermsTableHorizontalHeader << "\"";
|
|
DEBUG_LOG(m_logger) << "Data.size: Soll/Ist: 5 + 4 = 9/" << qbaLogTermsTableHorizontalHeader.size();
|
|
|
|
if (qbaLogTermsTableHorizontalHeader.size() == 9)
|
|
return true;
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Logistical Terms Table Horizontal Header' failed!";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Logistical Terms Table Horizontal Header' failed!"), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
} // end of checkLogTermsTableHorizontalHeader()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkLogTermsTableVerticalHeader(const QByteArray &qbaLogTermsTableVerticalHeader)
|
|
{
|
|
// Soll: 5 Zeichen jeweils mit `\n` (last `\n` removed)
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaLogTermsTableVerticalHeader << "\"";
|
|
DEBUG_LOG(m_logger) << "Data.size: Soll/Ist: 5 + 4 = 9/" << qbaLogTermsTableVerticalHeader.size();
|
|
|
|
if (qbaLogTermsTableVerticalHeader.size() == 9)
|
|
return true;
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Logistical Terms Table Vertical Header' failed!";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Logistical Terms Table Vertical Header' failed!"), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
} // end of checkLogTermsTableVerticalHeader()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkLogTermsTableMatrix(const QByteArray &qbaLogTermsTableMatrix)
|
|
{
|
|
// Soll: 5 Zeilen mit jeweils 5 Eintraegen (jeweils max. 2 Zeilen je max 10 Zeichen) getrennt durch `;` jeweils abgeschlossen mit `\n` (last `\n` removed)
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaLogTermsTableMatrix << "\"";
|
|
|
|
// split funktioniert hier nicht wenn in einem quoted Eintrag '\n' vorkommt. -> eigene split Funktion verwenden
|
|
QStringList qsl = m_logisticalTermsModel->splitQuotedStringToRows(QString::fromLatin1(qbaLogTermsTableMatrix));
|
|
|
|
DEBUG_LOG(m_logger) << "Line entry size: Soll/Ist: 5/" << qsl.size();
|
|
|
|
// check number of seperators
|
|
if (qsl.size() == 5)
|
|
{
|
|
// Begrenzung auf 10 Zeichen per Zeile pruefen...
|
|
|
|
// QStringList aus den 25 Matrix Eintraegen erstellen
|
|
QString qsMatrix = qsl.join(QLatin1Char(';'));
|
|
QStringList qsl2 = qsMatrix.split(QLatin1Char(';'));
|
|
|
|
for (int i = 0; i < qsl2.size(); ++i)
|
|
{
|
|
const QString &qsEntry = qsl2.at(i);
|
|
|
|
if (! qsEntry.contains(QLatin1Char('\n')))
|
|
{
|
|
// non quoted
|
|
if (qsEntry.size() > 10)
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Logistical Terms Table Matrix' failed! Maximum number of 10 characters per entry line exceeded in cell " << i + 1;
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Logistical Terms Table Matrix' failed! Maximum number of 10 characters per entry line exceeded."), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
// quoted
|
|
if ((qsEntry.size() > 21) || (qsEntry.indexOf(QLatin1Char('\n')) > 10))
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Logistical Terms Table Matrix' failed! Maximum number of 10 characters per entry line exceeded in cell " << i + 1;
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Logistical Terms Table Matrix' failed! Maximum number of 10 characters per entry line exceeded."), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Logistical Terms Table Matrix' failed!";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Logistical Terms Table Matrix' failed!"), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
} // end of checkLogTermsTableMatrix()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::checkPhraseTableMatrix(const QByteArray &qbaPhraseTableMatrix)
|
|
{
|
|
// Soll: 13 Zeilen mit jeweils 2 Eintraegen (jeweils max. 15 Zeichen) getrennt durch `;` jeweils mit `\n` (last `\n` removed)
|
|
DEBUG_LOG(m_logger) << "Data: \"" << qbaPhraseTableMatrix << "\"";
|
|
|
|
const QList<QByteArray> qbaLinesList = qbaPhraseTableMatrix.split('\n');
|
|
|
|
// check number of seperators
|
|
if (qbaLinesList.size() != 13)
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Phrase Table Matrix' failed! Invalid Line entry size: Soll/Ist: 13/" << qbaLinesList.size();
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Phrase Table Matrix' failed! Invalid Line entry size."), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
|
|
// Inhalt darf nicht leer sein da das Speichern im Model indiziert auf Basis von 'split()' erfolgt. Bei leeren Eintraegen stimmt dann die Anzahl nicht!!
|
|
for (const QByteArray &line : qbaLinesList)
|
|
{
|
|
const QList<QByteArray> qbaLine = line.split(';');
|
|
if (qbaLine.size() == 2)
|
|
{
|
|
if (qbaLine.at(0).isEmpty() || qbaLine.at(1).isEmpty() || qbaLine.at(0).size() > 15 || qbaLine.at(1).size() > 15)
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Phrase Table Matrix' failed! Invalid number of entrys or entry size is < 1 or >> 15. ";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Phrase Table Matrix' failed! Invalid number of entrys or entry size is less than 1 or greater 15."), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << "Load csv data 'Phrase Table Matrix' failed! Invalid number of entrys or empty entry per line. ";
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Load csv data 'Phrase Table Matrix' failed! Invalid number of entrys or empty entry per line."), tr("CSV Load Error"));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
} // end of checkPhraseTableMatrix()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSVImport::removeQuotedCharInNote(QByteArray &qbaNote)
|
|
{
|
|
if (qbaNote.startsWith('"'))
|
|
qbaNote.remove(0, 1);
|
|
|
|
if (qbaNote.endsWith('"'))
|
|
qbaNote.remove(qbaNote.lastIndexOf('"'), 1);
|
|
|
|
} // end of removeQuotedCharInNote()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CSVImport::removeRedundantCvsSeperators(QByteArray &qbaLine, int desiredValue) const
|
|
{
|
|
int seperatorCnt = 0;
|
|
|
|
// check for csv seperators
|
|
for (const char c : qAsConst(qbaLine))
|
|
{
|
|
if (c == ';')
|
|
++seperatorCnt;
|
|
}
|
|
|
|
if (seperatorCnt < desiredValue)
|
|
{
|
|
ERROR_LOG(m_logger) << "Seperator values less than desired values.";
|
|
return false;
|
|
}
|
|
|
|
while (seperatorCnt > desiredValue)
|
|
{
|
|
qbaLine.remove(qbaLine.lastIndexOf(';'), 1);
|
|
--seperatorCnt;
|
|
}
|
|
DEBUG_LOG(m_logger) << "+++Data: \"" << qbaLine << "\"" << " Soll/Ist:: " << desiredValue << "/" << seperatorCnt;
|
|
return true;
|
|
} // end of removeRedundantCvsSeperators()
|
|
//-----------------------------------------------------------------------------
|
|
|