Jaye Evins
8c8e447336
- Made greater use of smart pointers, eliminating many instances of manual memory management - Do not use pointers at all for many non-polymorphic classes - Assorted other code cleanup
718 lines
15 KiB
C++
718 lines
15 KiB
C++
/* Db.cpp
|
|
*
|
|
* Copyright (C) 2013-2016 Jaye Evins <evins@snaught.com>
|
|
*
|
|
* This file is part of gLabels-qt.
|
|
*
|
|
* gLabels-qt is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* gLabels-qt 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with gLabels-qt. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "Db.h"
|
|
|
|
#include "Config.h"
|
|
#include "StrUtil.h"
|
|
#include "FileUtil.h"
|
|
#include "Settings.h"
|
|
#include "XmlCategoryParser.h"
|
|
#include "XmlPaperParser.h"
|
|
#include "XmlTemplateParser.h"
|
|
#include "XmlTemplateCreator.h"
|
|
#include "XmlVendorParser.h"
|
|
|
|
#include <QDebug>
|
|
#include <QtGlobal>
|
|
|
|
#include <algorithm>
|
|
|
|
|
|
namespace glabels
|
|
{
|
|
namespace model
|
|
{
|
|
|
|
//
|
|
// Private
|
|
//
|
|
namespace
|
|
{
|
|
const QString empty = "";
|
|
|
|
bool partNameLessThan( const Template& a, const Template& b )
|
|
{
|
|
return StrUtil::comparePartNames( a.name(), b.name() ) < 0;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Static data
|
|
//
|
|
QList<Paper> Db::mPapers;
|
|
QMap<QString,Paper> Db::mPapersNameMap;
|
|
QMap<QString,Paper> Db::mPapersIdMap;
|
|
QStringList Db::mPaperIds;
|
|
QStringList Db::mPaperNames;
|
|
|
|
QList<Category> Db::mCategories;
|
|
QMap<QString,Category> Db::mCategoriesNameMap;
|
|
QMap<QString,Category> Db::mCategoriesIdMap;
|
|
QStringList Db::mCategoryIds;
|
|
QStringList Db::mCategoryNames;
|
|
|
|
QList<Vendor> Db::mVendors;
|
|
QMap<QString,Vendor> Db::mVendorsNameMap;
|
|
QStringList Db::mVendorNames;
|
|
|
|
QList<Template> Db::mTemplates;
|
|
QMap<QString,Template> Db::mTemplatesNameMap;
|
|
|
|
QMap<QString,Template> Db::mUserTemplatesNameMap;
|
|
|
|
|
|
void Db::init()
|
|
{
|
|
readPapers();
|
|
readCategories();
|
|
readVendors();
|
|
readTemplates();
|
|
}
|
|
|
|
|
|
const QList<Paper>& Db::papers()
|
|
{
|
|
return mPapers;
|
|
}
|
|
|
|
|
|
const QStringList& Db::paperIds()
|
|
{
|
|
return mPaperIds;
|
|
}
|
|
|
|
|
|
const QStringList& Db::paperNames()
|
|
{
|
|
return mPaperNames;
|
|
}
|
|
|
|
|
|
const QList<Category>& Db::categories()
|
|
{
|
|
return mCategories;
|
|
}
|
|
|
|
|
|
const QStringList& Db::categoryIds()
|
|
{
|
|
return mCategoryIds;
|
|
}
|
|
|
|
|
|
const QStringList& Db::categoryNames()
|
|
{
|
|
return mCategoryNames;
|
|
}
|
|
|
|
|
|
const QList<Vendor>& Db::vendors()
|
|
{
|
|
return mVendors;
|
|
}
|
|
|
|
|
|
const QStringList& Db::vendorNames()
|
|
{
|
|
return mVendorNames;
|
|
}
|
|
|
|
|
|
QList<Template> Db::templates()
|
|
{
|
|
auto list = mTemplates;
|
|
list.append( mUserTemplatesNameMap.values() );
|
|
|
|
std::stable_sort( list.begin(), list.end(), partNameLessThan );
|
|
|
|
return list;
|
|
}
|
|
|
|
|
|
const Paper Db::lookupPaperFromName( const QString& name )
|
|
{
|
|
if ( name.isEmpty() )
|
|
{
|
|
qWarning() << "NULL paper name.";
|
|
return Paper();
|
|
}
|
|
|
|
auto it = mPapersNameMap.find( name );
|
|
if ( it != mPapersNameMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
qWarning() << "Unknown paper name: " << name;
|
|
return Paper();
|
|
}
|
|
|
|
|
|
const Paper Db::lookupPaperFromId( const QString& id )
|
|
{
|
|
if ( id.isEmpty() )
|
|
{
|
|
qWarning() << "NULL paper id.";
|
|
return Paper();
|
|
}
|
|
|
|
auto it = mPapersIdMap.find( id );
|
|
if ( it != mPapersIdMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
qWarning() << "Unknown paper ID: " << id;
|
|
return Paper();
|
|
}
|
|
|
|
|
|
QString Db::lookupPaperIdFromName( const QString& name )
|
|
{
|
|
return lookupPaperFromName( name ).id();
|
|
}
|
|
|
|
|
|
QString Db::lookupPaperNameFromId( const QString& id )
|
|
{
|
|
return lookupPaperFromId( id ).name();
|
|
}
|
|
|
|
|
|
bool Db::isPaperIdKnown( const QString& id )
|
|
{
|
|
return mPapersIdMap.contains( id );
|
|
}
|
|
|
|
|
|
const Category Db::lookupCategoryFromName( const QString& name )
|
|
{
|
|
if ( name.isEmpty() )
|
|
{
|
|
qWarning() << "NULL category name.";
|
|
return Category();
|
|
}
|
|
|
|
auto it = mCategoriesNameMap.find( name );
|
|
if ( it != mCategoriesNameMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
qWarning() << "Unknown category name: \"%s\"." << name;
|
|
return Category();
|
|
}
|
|
|
|
|
|
const Category Db::lookupCategoryFromId( const QString& id )
|
|
{
|
|
if ( id.isEmpty() )
|
|
{
|
|
qWarning() << "NULL category id.";
|
|
return Category();
|
|
}
|
|
|
|
auto it = mCategoriesIdMap.find( id );
|
|
if ( it != mCategoriesIdMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
qWarning() << "Unknown category ID: \"%s\"." << id;
|
|
return Category();
|
|
}
|
|
|
|
|
|
QString Db::lookupCategoryIdFromName( const QString& name )
|
|
{
|
|
return lookupCategoryFromName( name ).id();
|
|
}
|
|
|
|
|
|
QString Db::lookupCategoryNameFromId( const QString& id )
|
|
{
|
|
return lookupCategoryFromId( id ).name();
|
|
}
|
|
|
|
|
|
bool Db::isCategoryIdKnown( const QString& id )
|
|
{
|
|
return mCategoriesIdMap.contains( id );
|
|
}
|
|
|
|
|
|
const Vendor Db::lookupVendorFromName( const QString& name )
|
|
{
|
|
if ( name.isEmpty() )
|
|
{
|
|
qWarning() << "NULL vendor name.";
|
|
return Vendor();
|
|
}
|
|
|
|
auto it = mVendorsNameMap.find( name );
|
|
if ( it != mVendorsNameMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
qWarning() << "Unknown vendor name: " << name;
|
|
return Vendor();
|
|
}
|
|
|
|
|
|
QString Db::lookupVendorUrlFromName( const QString& name )
|
|
{
|
|
return lookupVendorFromName( name ).url();
|
|
}
|
|
|
|
|
|
bool Db::isVendorNameKnown( const QString& name )
|
|
{
|
|
return mVendorsNameMap.contains( name );
|
|
}
|
|
|
|
|
|
const Template Db::lookupTemplateFromName( const QString& name )
|
|
{
|
|
if ( name.isEmpty() )
|
|
{
|
|
qWarning() << "NULL template name.";
|
|
return Template();
|
|
}
|
|
|
|
auto it = mTemplatesNameMap.find( name );
|
|
if ( it != mTemplatesNameMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
auto it2 = mUserTemplatesNameMap.find( name );
|
|
if ( it2 != mUserTemplatesNameMap.end() )
|
|
{
|
|
return *it2;
|
|
}
|
|
|
|
qWarning() << "Unknown template name: " << name;
|
|
return Template();
|
|
}
|
|
|
|
|
|
const Template Db::lookupTemplateFromBrandPart( const QString& brand, const QString& part )
|
|
{
|
|
if ( brand.isEmpty() || part.isEmpty() )
|
|
{
|
|
qWarning() << "NULL template brand and/or part.";
|
|
return Template();
|
|
}
|
|
|
|
auto name = Template::brandPartToName( brand, part );
|
|
|
|
auto it = mTemplatesNameMap.find( name );
|
|
if ( it != mTemplatesNameMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
auto it2 = mUserTemplatesNameMap.find( name );
|
|
if ( it2 != mUserTemplatesNameMap.end() )
|
|
{
|
|
return *it2;
|
|
}
|
|
|
|
qWarning() << "Unknown template brand, part: " << brand << ", " << part;
|
|
return Template();
|
|
}
|
|
|
|
|
|
const Template Db::lookupUserTemplateFromBrandPart( const QString& brand, const QString& part )
|
|
{
|
|
if ( brand.isEmpty() || part.isEmpty() )
|
|
{
|
|
qWarning() << "NULL template brand and/or part.";
|
|
return Template();
|
|
}
|
|
|
|
auto name = Template::brandPartToName( brand, part );
|
|
|
|
auto it = mUserTemplatesNameMap.find( name );
|
|
if ( it != mUserTemplatesNameMap.end() )
|
|
{
|
|
return *it;
|
|
}
|
|
|
|
qWarning() << "Unknown user template brand, part: " << brand << ", " << part;
|
|
return Template();
|
|
}
|
|
|
|
|
|
bool Db::isTemplateKnown( const QString& brand, const QString& part )
|
|
{
|
|
auto name = Template::brandPartToName( brand, part );
|
|
return mTemplatesNameMap.contains( name ) || mUserTemplatesNameMap.contains( name );
|
|
}
|
|
|
|
|
|
bool Db::isSystemTemplateKnown( const QString& brand, const QString& part )
|
|
{
|
|
auto name = Template::brandPartToName( brand, part );
|
|
return mTemplatesNameMap.contains( name );
|
|
}
|
|
|
|
|
|
bool Db::isUserTemplateKnown( const QString& brand, const QString& part )
|
|
{
|
|
auto name = Template::brandPartToName( brand, part );
|
|
return mUserTemplatesNameMap.contains( name );
|
|
}
|
|
|
|
|
|
QStringList Db::getNameListOfSimilarTemplates( const QString& name )
|
|
{
|
|
QStringList list;
|
|
|
|
auto tmplate1 = lookupTemplateFromName( name );
|
|
if ( tmplate1.isNull() )
|
|
{
|
|
qWarning() << "Unknown template name: " << name;
|
|
return list;
|
|
}
|
|
|
|
for ( auto& tmplate2 : templates() )
|
|
{
|
|
if ( tmplate1.name() != tmplate2.name() )
|
|
{
|
|
if ( tmplate1.isSimilarTo( tmplate2 ) )
|
|
{
|
|
list << tmplate2.name();
|
|
}
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
|
|
QString Db::userTemplateFileName( const QString& brand, const QString& part )
|
|
{
|
|
QString fileName = brand + "_" + part + ".template";
|
|
return FileUtil::userTemplatesDir().filePath( fileName );
|
|
}
|
|
|
|
|
|
void Db::registerUserTemplate( const Template& tmplate )
|
|
{
|
|
if ( isTemplateKnown( tmplate.brand(), tmplate.part() ) )
|
|
{
|
|
qWarning() << "Duplicate template name: " << tmplate.name();
|
|
return;
|
|
}
|
|
|
|
QString fileName = userTemplateFileName( tmplate.brand(), tmplate.part() );
|
|
|
|
// Write file
|
|
if ( XmlTemplateCreator().writeTemplate( tmplate, fileName ) )
|
|
{
|
|
// Add template to list of registered templates
|
|
mUserTemplatesNameMap[ tmplate.name() ] = tmplate;
|
|
mUserTemplatesNameMap[ tmplate.name() ].setFileName( fileName );
|
|
mUserTemplatesNameMap[ tmplate.name() ].setIsUserDefined( true );
|
|
|
|
Settings::addToRecentTemplateList( tmplate.name() );
|
|
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Problem writing user template" << fileName;
|
|
}
|
|
}
|
|
|
|
|
|
void Db::deleteUserTemplateByBrandPart( const QString& brand, const QString& part )
|
|
{
|
|
auto tmplate = lookupUserTemplateFromBrandPart( brand, part );
|
|
if ( !tmplate.isNull() && tmplate.isUserDefined() )
|
|
{
|
|
mUserTemplatesNameMap.remove( Template::brandPartToName( brand, part ) );
|
|
|
|
QFile( tmplate.fileName() ).remove();
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Not a user defined template:" << tmplate.name();
|
|
}
|
|
}
|
|
|
|
|
|
void Db::printKnownPapers()
|
|
{
|
|
qDebug() << "KNOWN PAPERS:";
|
|
|
|
for ( auto& paper : mPapers )
|
|
{
|
|
qDebug() << "paper "
|
|
<< "id=" << paper.id() << ", "
|
|
<< "name=" << paper.name() << ", "
|
|
<< "width=" << paper.width().pt() << "pts, "
|
|
<< "height=" << paper.height().pt() << "pts, "
|
|
<< "pwg_size=" << paper.pwgSize();
|
|
}
|
|
|
|
qDebug();
|
|
}
|
|
|
|
|
|
void Db::printKnownCategories()
|
|
{
|
|
qDebug() << "KNOWN CATEGORIES:";
|
|
|
|
for ( auto& category : mCategories )
|
|
{
|
|
qDebug() << "category "
|
|
<< "id=" << category.id() << ", "
|
|
<< "name=" << category.name();
|
|
}
|
|
|
|
qDebug();
|
|
}
|
|
|
|
|
|
void Db::printKnownVendors()
|
|
{
|
|
qDebug() << "KNOWN VENDORS:";
|
|
|
|
for ( auto& vendor : mVendors )
|
|
{
|
|
qDebug() << "vendor "
|
|
<< "name='" << vendor.name() << ", "
|
|
<< "url='" << vendor.url();
|
|
}
|
|
|
|
qDebug();
|
|
}
|
|
|
|
|
|
void Db::printKnownTemplates()
|
|
{
|
|
qDebug() << "KNOWN TEMPLATES:";
|
|
|
|
for ( auto& tmplate : mTemplates )
|
|
{
|
|
qDebug() << "template "
|
|
<< "brand=" << tmplate.brand() << ", "
|
|
<< "part=" << tmplate.part() << ", "
|
|
<< "description=" << tmplate.description();
|
|
}
|
|
|
|
qDebug();
|
|
}
|
|
|
|
|
|
void Db::readPapers()
|
|
{
|
|
readPapersFromDir( FileUtil::systemTemplatesDir() );
|
|
}
|
|
|
|
|
|
void Db::readPapersFromDir( const QDir& dir )
|
|
{
|
|
XmlPaperParser parser;
|
|
|
|
for ( auto fileName : dir.entryList( QDir::Files ) )
|
|
{
|
|
if ( fileName == "paper-sizes.xml" )
|
|
{
|
|
auto list = parser.readFile( dir.absoluteFilePath( fileName ) );
|
|
for ( auto& paper : list )
|
|
{
|
|
registerPaper( paper );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Db::registerPaper( const Paper& paper )
|
|
{
|
|
if ( !isPaperIdKnown( paper.id() ) )
|
|
{
|
|
mPapers.push_back( paper );
|
|
mPapersNameMap[ paper.name() ] = paper;
|
|
mPapersIdMap[ paper.id() ] = paper;
|
|
mPaperIds.push_back( paper.id() );
|
|
mPaperNames.push_back( paper.name() );
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Duplicate paper ID: " << paper.id();
|
|
}
|
|
}
|
|
|
|
|
|
void Db::readCategories()
|
|
{
|
|
readCategoriesFromDir( FileUtil::systemTemplatesDir() );
|
|
}
|
|
|
|
|
|
void Db::readCategoriesFromDir( const QDir& dir )
|
|
{
|
|
XmlCategoryParser parser;
|
|
|
|
for ( auto fileName : dir.entryList( QDir::Files ) )
|
|
{
|
|
if ( fileName == "categories.xml" )
|
|
{
|
|
auto list = parser.readFile( dir.absoluteFilePath( fileName ) );
|
|
for ( auto& category : list )
|
|
{
|
|
registerCategory( category );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Db::registerCategory( const Category& category )
|
|
{
|
|
if ( !isCategoryIdKnown( category.id() ) )
|
|
{
|
|
mCategories.push_back( category );
|
|
mCategoriesNameMap[ category.name() ] = category;
|
|
mCategoriesIdMap[ category.id() ] = category;
|
|
mCategoryIds.push_back( category.id() );
|
|
mCategoryNames.push_back( category.name() );
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Duplicate category ID: " << category.id();
|
|
}
|
|
}
|
|
|
|
|
|
void Db::readVendors()
|
|
{
|
|
readVendorsFromDir( FileUtil::systemTemplatesDir() );
|
|
}
|
|
|
|
|
|
void Db::readVendorsFromDir( const QDir& dir )
|
|
{
|
|
XmlVendorParser parser;
|
|
|
|
for ( auto fileName : dir.entryList( QDir::Files ) )
|
|
{
|
|
if ( fileName == "vendors.xml" )
|
|
{
|
|
auto list = parser.readFile( dir.absoluteFilePath( fileName ) );
|
|
for ( auto& vendor : list )
|
|
{
|
|
registerVendor( vendor );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Db::registerVendor( const Vendor& vendor )
|
|
{
|
|
if ( !isVendorNameKnown( vendor.name() ) )
|
|
{
|
|
mVendors.push_back( vendor );
|
|
mVendorsNameMap[ vendor.name() ] = vendor;
|
|
mVendorNames.push_back( vendor.name() );
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Duplicate vendor name: " << vendor.name();
|
|
}
|
|
}
|
|
|
|
|
|
void Db::readTemplates()
|
|
{
|
|
readTemplatesFromDir( FileUtil::systemTemplatesDir() );
|
|
readTemplatesFromDir( FileUtil::manualUserTemplatesDir() );
|
|
|
|
std::stable_sort( mTemplates.begin(), mTemplates.end(), partNameLessThan );
|
|
|
|
readUserTemplatesFromDir( FileUtil::userTemplatesDir() );
|
|
}
|
|
|
|
|
|
void Db::readTemplatesFromDir( const QDir& dir )
|
|
{
|
|
QStringList filters;
|
|
filters << "*-templates.xml" << "*.template";
|
|
|
|
XmlTemplateParser parser;
|
|
|
|
for ( auto& fileName : dir.entryList( filters, QDir::Files ) )
|
|
{
|
|
auto list = parser.readFile( dir.absoluteFilePath( fileName ) );
|
|
for ( auto& tmplate : list )
|
|
{
|
|
registerTemplate( tmplate );
|
|
}
|
|
|
|
list = parser.readEquivsFromFile( dir.absoluteFilePath( fileName ) );
|
|
for ( auto& tmplate : list )
|
|
{
|
|
registerTemplate( tmplate );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Db::registerTemplate( const Template& tmplate )
|
|
{
|
|
if ( !isTemplateKnown( tmplate.brand(), tmplate.part() ) )
|
|
{
|
|
mTemplates.push_back( tmplate );
|
|
mTemplatesNameMap[ tmplate.name() ] = tmplate;
|
|
}
|
|
else
|
|
{
|
|
qWarning() << "Duplicate template name: " << tmplate.name();
|
|
}
|
|
}
|
|
|
|
|
|
void Db::readUserTemplatesFromDir( const QDir& dir )
|
|
{
|
|
QStringList filters;
|
|
filters << "*-templates.xml" << "*.template";
|
|
|
|
XmlTemplateParser parser;
|
|
|
|
for ( auto& fileName : dir.entryList( filters, QDir::Files ) )
|
|
{
|
|
auto list = parser.readFile( dir.absoluteFilePath( fileName ) );
|
|
for ( auto& tmplate : list )
|
|
{
|
|
registerUserTemplate( tmplate );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|