commit f12670e998440bc0f0484616cb81b81f81758767 Author: Christian Ehringfeld Date: Sun Sep 27 14:39:09 2015 +0200 some logger stuff diff --git a/EntityManager.pro b/EntityManager.pro index fed2331..4198d3d 100644 --- a/EntityManager.pro +++ b/EntityManager.pro @@ -114,3 +114,8 @@ win32-g++ { #QMAKE_CXXFLAGS += -Winit-self CONFIG(release, debug|release):DEFINES += QT_NO_DEBUG_OUTPUT + +DISTFILES += \ + README.md \ + LICENSE \ + Doxyfile diff --git a/README.md b/README.md index 2637616..54b63d7 100644 --- a/README.md +++ b/README.md @@ -46,6 +46,11 @@ http://jenkins.danfai.de/jenkins/job/cuteentitymanager/doxygen/ Tutorial(wip): https://synlos.net/redmine/projects/entitymanager/wiki/Tutorial +### Minimum requirements + +- GCC 4.8 or clang 3.3 +- >= Qt 5.4 +- any platform supported by Qt ## German Mit dem CuteEntityManager ist es möglich, Entities zu persistieren, zu diff --git a/samples/simple/main.cpp b/samples/simple/main.cpp index 677869e..8679736 100644 --- a/samples/simple/main.cpp +++ b/samples/simple/main.cpp @@ -20,5 +20,12 @@ int main(int argc, char *argv[]) { "Müsli")); auto ep = a.objectCast(); qDebug() << e->create(ep, true, true); + int i = 0; + + while(false); { + i++; + } + qDebug() << i; + return 0; } diff --git a/src/database.cpp b/src/database.cpp index 74b142f..f331c1b 100644 --- a/src/database.cpp +++ b/src/database.cpp @@ -21,18 +21,18 @@ using namespace CuteEntityManager; Database::Database(QSqlDatabase database, bool loggerActivated, bool logQueries, - bool logErrors) { + bool logErrors, MsgType type) { this->database = database; this->init(); this->connectionName = this->database.connectionName(); - this->initLogger(loggerActivated, logQueries, logErrors); + this->initLogger(loggerActivated, logQueries, logErrors, type); } Database::Database(QString databaseType, QString connectionName, QString hostname, QString databasename, QString username, QString password, qint64 port, bool loggerActivated, - bool logQueries, bool logErrors, QString databaseOptions) { + bool logQueries, bool logErrors, QString databaseOptions, MsgType type) { this->database = QSqlDatabase::addDatabase(databaseType, connectionName); this->connectionName = connectionName; if (!hostname.isEmpty()) { @@ -54,7 +54,7 @@ Database::Database(QString databaseType, QString connectionName, this->database.setConnectOptions(databaseOptions); } this->init(); - this->initLogger(loggerActivated, logQueries, logErrors); + this->initLogger(loggerActivated, logQueries, logErrors, type); } void Database::init() { @@ -63,12 +63,13 @@ void Database::init() { QSqlDriver::Transactions); } -void Database::initLogger(bool activated, bool logQueries, bool logErrors) { +void Database::initLogger(bool activated, bool logQueries, bool logErrors, + MsgType type) { this->logQueries = logQueries; this->logErrors = logErrors; if (activated) { this->logger = new Logger(QDir::currentPath() + "/db" + this->connectionName + - ".log"); + ".log", type); } } diff --git a/src/database.h b/src/database.h index d867981..2295af7 100644 --- a/src/database.h +++ b/src/database.h @@ -28,6 +28,11 @@ #include "enums/databasetype.h" #include "logger.h" namespace CuteEntityManager { +#ifdef QT_DEBUG +#define DEFAULTMSGTYPE MsgType::DEBUG +#else +#define DEFAULTMSGTYPE MsgType::CRITICAL +#endif class Database { private: QSqlDatabase database; @@ -35,20 +40,20 @@ class Database { bool supportTransactions; Logger *logger = nullptr; void init(); - void initLogger(bool activated, bool logQueries, bool logErrors); + void initLogger(bool activated, bool logQueries, bool logErrors, MsgType type); bool logQueries; bool logErrors; public: Database(QSqlDatabase database, bool loggerActivated = true, - bool logQueries = false, bool logErrors = true); + bool logQueries = false, bool logErrors = true,MsgType type= DEFAULTMSGTYPE); ~Database(); Database(QString databaseType, QString connectionName = QString(""), QString hostname = QString(""), QString databasename = QString("") , QString username = QString(""), QString password = QString(""), qint64 port = 0, bool loggerActivated = true, bool logQueries = false, - bool logErrors = true, QString databaseOptions = ""); + bool logErrors = true, QString databaseOptions = "",MsgType type= DEFAULTMSGTYPE); QSqlDatabase getDatabase(); QString getConnectionName(); QSqlQuery getQuery(); diff --git a/src/entityinspector.cpp b/src/entityinspector.cpp index ef316fc..e9c834a 100644 --- a/src/entityinspector.cpp +++ b/src/entityinspector.cpp @@ -19,8 +19,8 @@ #include using namespace CuteEntityManager; -EntityInspector::EntityInspector() { - this->initLogger(); +EntityInspector::EntityInspector(const MsgType msgType) { + this->initLogger(msgType); } EntityInspector::~EntityInspector() { @@ -34,8 +34,7 @@ bool EntityInspector::checkRegisteredEntities() { QStringList classes = EntityInstanceFactory::getRegisteredClasses(); QString msg = QDateTime::currentDateTime().toString(Qt::ISODate) + " - Start checking entities\n"; - qInfo() << msg; - this->logger->logMsg(msg); + this->logger->logMsg(msg, MsgType::INFO); bool ok = true; for (int i = 0; i < classes.size(); ++i) { bool r = this->checkEntity(classes.at(i)); @@ -45,56 +44,53 @@ bool EntityInspector::checkRegisteredEntities() { msg += classes.at(i) + " is erroneous!"; msg += "\n"; msg += "###############################\n"; - qWarning() << msg; + this->logger->logMsg(msg, MsgType::CRITICAL); ok = false; } else { msg = "Entity class " + classes.at(i) + " seems ok.\n"; - qInfo() << msg; + this->logger->logMsg(msg, MsgType::INFO); } - this->logger->logMsg(msg); } msg = QDateTime::currentDateTime().toString(Qt::ISODate) + " - End checking entities\n"; - qInfo() << msg; - this->logger->logMsg(msg); + this->logger->logMsg(msg, MsgType::INFO); return ok; } bool EntityInspector::checkEntity(QString name) { QString msg = "--------------------\n"; msg += "Checking " + name + " now.\n"; - qDebug() << msg; - auto entity = this->instantiateEntity(name, msg); + this->logger->logMsg(msg, MsgType::DEBUG); + auto entity = this->instantiateEntity(name); bool ok = true; if (entity) { - bool relations = this->verifyRelations(entity, msg); - bool pk = this->checkPrimaryKey(entity, msg); - this->verifyBlobAttributes(entity, msg); - this->verifyTransientAttributes(entity, msg); + bool relations = this->verifyRelations(entity); + bool pk = this->checkPrimaryKey(entity); + this->verifyBlobAttributes(entity); + this->verifyTransientAttributes(entity); ok = pk && relations; delete entity; entity = nullptr; } - this->logger->logMsg(msg); return ok; } -Entity *EntityInspector::instantiateEntity(const QString name, QString &msg) { +Entity *EntityInspector::instantiateEntity(const QString name) { auto entity = EntityInstanceFactory::createInstance(name); - QString internMsg = ""; + QString msg = ""; if (entity) { - internMsg = name + " is instantiable."; - qInfo() << internMsg; + msg = name + " is instantiable."; + this->logger->logMsg(msg, MsgType::INFO); } else { - internMsg = name + " is NOT instantiable!"; - qCritical() << internMsg; + msg = name + " is NOT instantiable!"; + this->logger->logMsg(msg, MsgType::CRITICAL); } - msg += internMsg + "\n"; return entity; } void EntityInspector::checkMetaProperties(QHash - &metaProperties, QString &msg, bool &ok, QHash &relations) { + &metaProperties, bool &ok, QHash &relations) { + QString msg = ""; for (auto i = metaProperties.constBegin(); i != metaProperties.constEnd(); ++i) { QString typeName = QString(i.value().typeName()); @@ -114,110 +110,108 @@ void EntityInspector::checkMetaProperties(QHash msg += i.key() + " must use QSharedPointer.\n"; } } + this->logger->logMsg(msg, MsgType::CRITICAL); } -bool EntityInspector::verifyRelations(Entity *&entity, QString &msg) { +bool EntityInspector::verifyRelations(Entity *&entity) { bool ok = true; auto metaProperties = EntityHelper::getMetaProperties(entity); auto relations = entity->getRelations(); - QString iMsg = ""; - this->checkMetaProperties(metaProperties, iMsg, ok, relations); + QString msg = ""; + this->checkMetaProperties(metaProperties, ok, relations); for (auto i = relations.constBegin(); i != relations.constEnd(); ++i) { - this->checkRelationTypos(i.key(), i.value(), iMsg, ok); + this->checkRelationTypos(i.key(), i.value(), ok); if (!metaProperties.contains(i.key())) { - iMsg += "For relation " + i.key() + " no property exists!"; + msg += "For relation " + i.key() + " no property exists!"; ok = false; } else { auto metaProperty = metaProperties.value(i.key()); if (!QString(metaProperty.typeName()).contains("QSharedPointer")) { - iMsg += "Property " + QString(metaProperty.name()) + - " must be a type like QList> or simply QSharedPointer."; + msg += "Property " + QString(metaProperty.name()) + + " must be a type like QList> or simply QSharedPointer."; } else { auto var = metaProperty.read(entity); - bool rel = this->checkRelation(var, i.value(), msg, metaProperty); + bool rel = this->checkRelation(var, i.value(), metaProperty); if (!rel) { ok = false; } else { - this->checkRelationMappings(metaProperty, i.value(), msg, ok); + this->checkRelationMappings(metaProperty, i.value(), ok); } } } } - if (!iMsg.isEmpty()) { - qCritical() << iMsg; - msg += iMsg; + if (!msg.isEmpty()) { + this->logger->logMsg(msg, MsgType::CRITICAL); } return ok; } -void EntityInspector::verifyTransientAttributes(Entity *&entity, QString &msg) { +void EntityInspector::verifyTransientAttributes(Entity *&entity) { auto metaProperties = EntityHelper::getMetaProperties(entity); auto relations = entity->getRelations(); auto transientAttributes = entity->getTransientAttributes(); auto blobs = entity->getBLOBColumns(); - QString iMsg = ""; + QString msg = ""; for (int i = 0; i < transientAttributes.size(); ++i) { QString attr = transientAttributes.at(i); if (!metaProperties.contains(attr)) { - iMsg += "No transient attribute called " + attr + ".\n"; + msg += "No transient attribute called " + attr + ".\n"; } if (relations.contains(transientAttributes.at(i))) { - iMsg += "A transient attribute should not be declared as relation: " + - attr + ".\n"; + msg += "A transient attribute should not be declared as relation: " + + attr + ".\n"; } if (blobs.contains(attr)) { - iMsg += "A transient attribute should not be declared as blob column: " + attr + - ".\n"; + msg += "A transient attribute should not be declared as blob column: " + attr + + ".\n"; } } - if (!iMsg.isEmpty()) { - qWarning() << iMsg; - msg += iMsg; + if (!msg.isEmpty()) { + this->logger->logMsg(msg, MsgType::WARNING); } } bool EntityInspector::checkRelation(const QVariant &entity, - const Relation &r, QString &msg, const QMetaProperty &property) const { - QString iMsg = ""; + const Relation &r, const QMetaProperty &property) const { + QString msg = ""; bool many = r.getType() == RelationType::MANY_TO_MANY || r.getType() == RelationType::ONE_TO_MANY; QString propType = QString(property.type()); bool canConvertList = entity.canConvert() || (many && propType.contains("QList")); if ((many && !canConvertList)) { - iMsg = "Relation type of " + r.getPropertyName() + - " must be MANY_TO_MANY or ONE_TO_MANY.\n"; - iMsg += "Or you can change the attribute type to QSharedPointer.\n"; + msg = "Relation type of " + r.getPropertyName() + + " must be MANY_TO_MANY or ONE_TO_MANY.\n"; + msg += "Or you can change the attribute type to QSharedPointer.\n"; } else if ((!many && canConvertList)) { - iMsg = "Relation type of " + r.getPropertyName() + - " must be MANY_TO_ONE or ONE_TO_ONE.\n"; - iMsg += "Or you can change the attribute type to QList>.\n"; + msg = "Relation type of " + r.getPropertyName() + + " must be MANY_TO_ONE or ONE_TO_ONE.\n"; + msg += "Or you can change the attribute type to QList>.\n"; } if (many && r.getType() == RelationType::ONE_TO_MANY && r.getMappedBy().isEmpty()) { - iMsg += "Relation " + r.getPropertyName() + - " needs a mappedBy attribute of the foreign class.\n"; + msg += "Relation " + r.getPropertyName() + + " needs a mappedBy attribute of the foreign class.\n"; } - if (!iMsg.isEmpty()) { - msg += iMsg; - qCritical() << iMsg; + if (!msg.isEmpty()) { + this->logger->logMsg(msg, MsgType::CRITICAL); return false; } return true; } void EntityInspector::checkRelationTypos(const QString &name, const Relation &r, - QString &msg, bool &ok) { + bool &ok) { if (name != r.getPropertyName()) { ok = false; - msg += "Relation " + name + " has a typo.\n"; - msg += "Name " + name + "and relation name " + r.getPropertyName() + - " are not equal.\n"; + this->logger->logMsg("Relation " + name + " has a typo.\n" + "Name " + name + + "and relation name " + r.getPropertyName() + + " are not equal.\n", MsgType::WARNING); } } void EntityInspector::checkRelationMappings(QMetaProperty &property, - const Relation &r, QString &msg, bool &ok) { + const Relation &r, bool &ok) { QString foreignEntityName = EntityInstanceFactory::extractEntityType( property.typeName()); auto foreignInstance = EntityInstanceFactory::createInstance(foreignEntityName); @@ -238,61 +232,60 @@ void EntityInspector::checkRelationMappings(QMetaProperty &property, } if (r.getMappedBy().isEmpty()) { if (foundMappedBy == 0) { - msg += "Optional: The relation " + r.getPropertyName() + - " is not mapped in foreign class " + foreignEntityName + - ". You could map it.\n"; + this->logger->logMsg("Optional: The relation " + r.getPropertyName() + + " is not mapped in foreign class " + foreignEntityName + + ". You could map it.\n", MsgType::INFO); } else if (foundMappedBy > 1) { - msg += "The relation " + r.getPropertyName() + " is mapped several times (" + - QString::number(foundMappedBy) + ") by foreign class " + foreignEntityName + - ". You should map it only once!\n"; + this->logger->logMsg("The relation " + r.getPropertyName() + + " is mapped several times (" + + QString::number(foundMappedBy) + ") by foreign class " + foreignEntityName + + ". You should map it only once!\n", MsgType::WARNING); ok = false; } } else if (!foundForeignMappedRelation) { - msg += "Relation " + r.getPropertyName() + " with mappedBy attribute " + - r.getMappedBy() + " has no mapped relation in " + foreignEntityName + - " class!\n"; + this->logger->logMsg("Relation " + r.getPropertyName() + + " with mappedBy attribute " + + r.getMappedBy() + " has no mapped relation in " + foreignEntityName + + " class!\n", MsgType::CRITICAL); ok = false; } delete foreignInstance; foreignInstance = nullptr; } else { - msg += "Can't create object for property/relation " + r.getPropertyName() + - "!\n"; - msg += "Classname: " + foreignEntityName + "\n"; - msg += "Is the class registered?\n"; + this->logger->logMsg("Can't create object for property/relation " + + r.getPropertyName() + + "\n" + "Classname: " + foreignEntityName + "\n" + "Is the class registered?\n", + MsgType::CRITICAL); ok = false; } } -bool EntityInspector::checkPrimaryKey(Entity *&entity, QString &msg) { +bool EntityInspector::checkPrimaryKey(Entity *&entity) { QString pk = entity->getPrimaryKey(); auto metaprops = EntityHelper::getMetaProperties(entity); - QString iMsg = ""; bool ok = true; if (!metaprops.contains(pk)) { ok = false; - iMsg = "Property " + pk + - " for primary key not exists. Please check your getPrimaryKey() method!\n"; + this->logger->logMsg("Property " + pk + + " for primary key not exists. Please check your getPrimaryKey() method!\n", + MsgType::CRITICAL); } - qCritical() << iMsg; - msg += iMsg; return ok; } -void EntityInspector::verifyBlobAttributes(Entity *&entity, QString &msg) { +void EntityInspector::verifyBlobAttributes(Entity *&entity) { auto metaprops = EntityHelper::getMetaProperties(entity); auto blobs = entity->getBLOBColumns(); - QString iMsg = ""; + QString msg = ""; for (int i = 0; i < blobs.size(); ++i) { QString name = blobs.at(i); if (!metaprops.contains(name)) { - iMsg += "For blob column " + name + " no property exists.\n"; + msg += "For blob column " + name + " no property exists.\n"; } } - qWarning() << iMsg; - msg += iMsg; + this->logger->logMsg(msg, MsgType::WARNING); } -void EntityInspector::initLogger() { - this->logger = new Logger(QDir::currentPath() + "/entity.log"); +void EntityInspector::initLogger(const MsgType msgType) { + this->logger = new Logger(QDir::currentPath() + "/entity.log", msgType); } diff --git a/src/entityinspector.h b/src/entityinspector.h index 72e6cda..ec207b3 100644 --- a/src/entityinspector.h +++ b/src/entityinspector.h @@ -30,26 +30,26 @@ namespace CuteEntityManager { */ class EntityInspector { public: - EntityInspector(); + EntityInspector(const MsgType msgType = MsgType::DEBUG); ~EntityInspector(); bool checkRegisteredEntities(); bool checkEntity(QString name); private: - Entity *instantiateEntity(const QString name, QString &msg); - bool verifyRelations(Entity *&entity, QString &msg); - void verifyTransientAttributes(Entity *&entity, QString &msg); - bool checkRelation(const QVariant &entity, const Relation &r, QString &msg, + Entity *instantiateEntity(const QString name); + bool verifyRelations(Entity *&entity); + void verifyTransientAttributes(Entity *&entity); + bool checkRelation(const QVariant &entity, const Relation &r, const QMetaProperty &property) const; - void checkRelationTypos(const QString &name, const Relation &r, QString &msg, + void checkRelationTypos(const QString &name, const Relation &r, bool &ok); void checkRelationMappings(QMetaProperty &property, const Relation &r, - QString &msg, bool &ok); - bool checkPrimaryKey(Entity *&entity, QString &msg); - void verifyBlobAttributes(Entity *&entity, QString &msg); + bool &ok); + bool checkPrimaryKey(Entity *&entity); + void verifyBlobAttributes(Entity *&entity); void checkMetaProperties(QHash &metaProperties, - QString &msg, bool &ok, QHash &relations); - void initLogger(); + bool &ok, QHash &relations); + void initLogger(const MsgType msgType); Logger *logger = nullptr; }; } diff --git a/src/entitymanager.cpp b/src/entitymanager.cpp index b9c1f07..682e63f 100644 --- a/src/entitymanager.cpp +++ b/src/entitymanager.cpp @@ -180,26 +180,15 @@ bool EntityManager::save(QSharedPointer &entity, ignoreHasChanged, validate, relationsIgnoreHasChanged); } -EntityManager::EntityManager(QSqlDatabase database, - bool logQueries, const bool inspectEntities) : QObject() { - auto db = new Database(database, true, logQueries); +EntityManager::EntityManager(QSqlDatabase database, bool logQueries, + const bool inspectEntities, + MsgType logActions) : QObject() { + auto db = new Database(database, true, logQueries, true, logActions); this->db = QSharedPointer(db); - this->init(inspectEntities); + this->init(inspectEntities,logActions); } -EntityManager::EntityManager(const QString &databaseType, QString databasename , - QString hostname, QString username, QString password, QString port, - bool logQueries, QString databaseOptions, - const bool inspectEntities) : QObject() { - auto db = new Database(databaseType, this->createConnection(), hostname, - databasename, username, - password, - port.toInt(), true, logQueries, true, databaseOptions); - this->db = QSharedPointer(db); - this->init(inspectEntities); -} - -void EntityManager::init(bool inspect) { +void EntityManager::init(bool inspect,const MsgType msgType) { auto schema = Database::getSchema(Database::getDatabaseType( this->db->getDatabase().driverName()), this->db); this->schema = QSharedPointer(schema); @@ -207,15 +196,24 @@ void EntityManager::init(bool inspect) { this->queryInterpreter = QSharedPointer(new QueryInterpreter( this->schema->getQueryBuilder())); this->appendToInstanceList(); -#ifdef QT_DEBUG - inspect = true; -#endif if (inspect) { - EntityInspector inspector = EntityInspector(); + EntityInspector inspector = EntityInspector(msgType); inspector.checkRegisteredEntities(); } } +EntityManager::EntityManager(const QString &databaseType, QString databasename, + QString hostname, QString username, QString password, QString port, + bool logQueries, QString databaseOptions, const bool inspectEntities, + CuteEntityManager::MsgType logActions) : QObject() { + auto db = new Database(databaseType, this->createConnection(), hostname, + databasename, username, + password, + port.toInt(), true, logQueries, true, databaseOptions, logActions); + this->db = QSharedPointer(db); + this->init(inspectEntities,logActions); +} + EntityManager::~EntityManager() { EntityManager::removeConnectionName(this->db->getConnectionName()); EntityManager::instances.remove(this->objectName()); diff --git a/src/entitymanager.h b/src/entitymanager.h index 0ae9bb9..3baed58 100644 --- a/src/entitymanager.h +++ b/src/entitymanager.h @@ -35,6 +35,14 @@ #include "querybuilder.h" #include "validators/errormsg.h" namespace CuteEntityManager { +#ifdef QT_DEBUG +#define DEFAULTMSGTYPE MsgType::DEBUG +#define INSPECTENTITIES true +#else +#define DEFAULTMSGTYPE MsgType::CRITICAL +#define INSPECTENTITIES false +#endif + class Logger; class QueryInterpreter; @@ -110,12 +118,15 @@ class EntityManager : public QObject { bool hasChanged(QSharedPointer &entity); public: - EntityManager(QSqlDatabase database, bool logQueries = false, const bool inspectEntities = false); + EntityManager(QSqlDatabase database, bool logQueries = false, + const bool inspectEntities = INSPECTENTITIES, + MsgType logActions = DEFAULTMSGTYPE); EntityManager(const QString &databaseType, QString databasename = "" , QString hostname = "", QString username = "", QString password = "", QString port = "", bool logQueries = false, - QString databaseOptions = "", const bool inspectEntities = false); + QString databaseOptions = "", const bool inspectEntities = INSPECTENTITIES, + MsgType logActions = DEFAULTMSGTYPE); virtual ~EntityManager(); static QStringList getConnectionNames(); static void removeConnectionName(const QString &name); @@ -256,7 +267,7 @@ class EntityManager : public QObject { return newList; } - void init(bool inspect); + void init(bool inspect, const MsgType msgType); QList > findAll(const QSharedPointer &e); void resolveRelations(const QSharedPointer &entity, const QHash &map, const bool refresh = false); diff --git a/src/logger.cpp b/src/logger.cpp index 1c0be6e..5850c57 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -20,8 +20,10 @@ #include using namespace CuteEntityManager; -Logger::Logger(QString path) { + +Logger::Logger(QString path, MsgType min) { this->path = path; + this->minimum = min; } Logger::~Logger() { @@ -38,32 +40,30 @@ void Logger::lastError(const QSqlQuery &q, bool logQuery) { QString msg = "{" + QString("\"time\":\"") + QDateTime::currentDateTime().toString(Qt::ISODate) + QString("\"") + errorMsg; msg += this->generateLogMsg(q) + "}"; - this->logMsg(msg); - if (errorMsg.isEmpty()) { - qDebug() << msg.replace("\"", "'"); - } else { - qWarning() << msg.replace("\"", "'"); - } + this->logMsg(msg, errorMsg.isEmpty() ? MsgType::DEBUG : MsgType::WARNING); } } } void Logger::lastError(const QSqlError &e) { if (e.isValid()) { - this->logMsg(this->generateLogMsg(e)); + this->logMsg(this->generateLogMsg(e), MsgType::WARNING); } } -void Logger::logMsg(const QString &value) { - QFile log(this->getPath()); - log.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append); - log.seek(log.size()); - QTextStream stream(&log); - stream.setCodec("UTF-8"); - stream << value; - stream << "\n"; - stream.flush(); - log.close(); +void Logger::logMsg(const QString &value, const MsgType type) { + if (!value.isEmpty() && this->shouldBeLogged(type)) { + this->outputToConsole(type, value); + QFile log(this->getPath()); + log.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append); + log.seek(log.size()); + QTextStream stream(&log); + stream.setCodec("UTF-8"); + stream << value; + stream << "\n"; + stream.flush(); + log.close(); + } } QString Logger::generateLogMsg(const QSqlQuery &q, bool withValues) const { @@ -87,6 +87,52 @@ QString Logger::generateLogMsg(const QSqlQuery &q, bool withValues) const { return r; } +bool Logger::shouldBeLogged(const MsgType &type) const { + switch (type) { + case MsgType::DEBUG: + return this->minimum == MsgType::DEBUG; + case MsgType::INFO: + return this->minimum == MsgType::DEBUG || this->minimum == MsgType::INFO; + case MsgType::WARNING: + return this->minimum == MsgType::DEBUG || this->minimum == MsgType::INFO + || this->minimum == MsgType::WARNING; + case MsgType::CRITICAL: + return this->minimum == MsgType::DEBUG || this->minimum == MsgType::INFO + || this->minimum == MsgType::WARNING || this->minimum == MsgType::CRITICAL; + default: + return true; + break; + } +} + +void Logger::outputToConsole(const MsgType &type, const QString &msg) const { + switch (type) { + case MsgType::DEBUG: + qDebug() << msg; + break; + case MsgType::INFO: + qInfo() << msg; + break; + case MsgType::WARNING: + qWarning() << msg; + break; + case MsgType::CRITICAL: + qCritical() << msg; + break; + case MsgType::FATAL: + qFatal(msg.toUtf8().constData()); + break; + } +} + +MsgType Logger::getMinimum() const { + return minimum; +} + +void Logger::setMinimum(const MsgType &value) { + minimum = value; +} + QString Logger::getPath() { if (this->path.isEmpty()) { this->path = this->defaultPath(); diff --git a/src/logger.h b/src/logger.h index 7ddd22c..a2d99c5 100644 --- a/src/logger.h +++ b/src/logger.h @@ -21,9 +21,18 @@ #include #include namespace CuteEntityManager { + +enum class MsgType { DEBUG, INFO, WARNING, CRITICAL, FATAL}; + class Logger { +#ifdef QT_DEBUG +#define DEFAULTMSGTYPE MsgType::DEBUG +#else +#define DEFAULTMSGTYPE MsgType::CRITICAL +#endif + public: - Logger(QString path = ""); + Logger(QString path = "", MsgType min = DEFAULTMSGTYPE); ~Logger(); QString defaultPath() const; @@ -31,14 +40,21 @@ class Logger { void lastError(const QSqlQuery &q, bool logQuery = false); QString getPath(); void setPath(const QString &value); - void logMsg(const QString &value); + void logMsg(const QString &value, const MsgType type = MsgType::DEBUG); + + MsgType getMinimum() const; + void setMinimum(const MsgType &value); protected: QString generateLogMsg(const QSqlError &e) const; QString generateLogMsg(const QSqlQuery &q, bool withValues = true) const; + bool shouldBeLogged(const MsgType &type) const; + void outputToConsole(const MsgType &type, const QString &msg) const; + private: QString path; + MsgType minimum; }; } #endif // LOGGER_H