path: root/filestreemodel.cpp

/*
  This program 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
  2 of the License, or (at your option) any later version.
*/

#include <QSqlQuery>
#include <QLocale>
#include <QIcon>
#include <QFileInfo>
#include <QFile>

#include "filestreemodel.h"
#include "smtreeitem.h"
#include "helper.h"

FilesTreeModel::FilesTreeModel(QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mMode(Normal){
	//database setup
	mDb = QSqlDatabase::database("treedb");
	mUpdateDvdQuery = new QSqlQuery(mDb);
	mUpdateDvdQuery->prepare("UPDATE files SET idvd = :dvd WHERE ifiles_id = :id");
	mUpdateQualityQuery = new QSqlQuery(mDb);
	mUpdateQualityQuery->prepare("UPDATE files SET siquality = :quality WHERE ifiles_id = :id");
	mInsertFileQuery = new QSqlQuery(mDb);
	mInsertFileQuery->prepare("INSERT INTO files(iseriespart_id, tfilename, cmd5sum, bisize, idvd, sifiletype, sifileno, siquality) VALUES(:seriespartid, :fname, :md5, :size, :dvd, :type, :fileno, :quality)");
	mFilesQuery = new QSqlQuery(mDb);
	mFilesQuery->prepare("SELECT tfilename, cmd5sum FROM files WHERE iseriespart_id = :id");
	mDeleteFileQuery = new QSqlQuery(mDb);
	mDeleteFileQuery->prepare("DELETE FROM files WHERE ifiles_id = :id");

	//file types
	mFileTypes.insert(1, "Movie");
	mFileTypes.insert(2, tr("Front cover"));
	mFileTypes.insert(3, tr("Back cover"));
	mFileTypes.insert(4, tr("General cover"));

	//cover types
	mCoverTypes = mFileTypes;
	mCoverTypes.remove(1);

	//mode names
	mModeNames.insert(Normal, "Normal");
	mModeNames.insert(Archived, "Archived");
	mModeNames.insert(Local, "Local");
}

FilesTreeModel::~FilesTreeModel(){
	delete mUpdateDvdQuery;
	delete mUpdateQualityQuery;
	delete mInsertFileQuery;
	delete mFilesQuery;
	delete mDeleteFileQuery;
	mDb = QSqlDatabase();
}

const QString FilesTreeModel::modeName(int mode) const{
	if(mode == -1){
		return mModeNames.value(mMode);
	}
	return mModeNames.value(mode);
}

void FilesTreeModel::setIds(const QList<int> &seriesPartIds){
	QStringList ids;
	foreach(int s, seriesPartIds){
		ids << QString::number(s);
	}
	QString query = QString("SELECT iseriespart_id, tfilename, cmd5sum, bisize, idvd, sifiletype, sifileno, siquality, ifiles_id, series.tseries_name, seriesparts.iseriespart FROM files, seriesparts, series WHERE iseriespart_id IN (%1) AND files.iseriespart_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id ORDER BY tfilename, sifileno ASC").arg(ids.join(","));
	QSqlQuery filesQuery(mDb);
	filesQuery.prepare(query);
	populate(filesQuery);
}

void FilesTreeModel::setMode(int mode){
	QSqlQuery modeQuery(mDb);
	bool queryOk = false;
	switch(mode){
		case Local:
			queryOk = modeQuery.prepare("SELECT iseriespart_id, tfilename, cmd5sum, bisize, idvd, sifiletype, sifileno, siquality, ifiles_id, series.tseries_name, seriesparts.iseriespart FROM files, seriesparts, series WHERE files.idvd = -1 AND files.sifiletype = 1 AND files.iseriespart_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id");
			break;
		case Archived:
			queryOk = modeQuery.prepare("SELECT iseriespart_id, tfilename, cmd5sum, bisize, idvd, sifiletype, sifileno, siquality, ifiles_id, series.tseries_name, seriesparts.iseriespart FROM files, seriesparts, series WHERE files.idvd != -1 AND files.iseriespart_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id");
			break;
		default:
			;
	}
	if(queryOk){
		populate(modeQuery);
	}
	mMode = mode;
}

QVariant FilesTreeModel::data(const QModelIndex &index, int role) const{
	if(!index.isValid()){
		return QVariant();
	}

	SmTreeItem *item = static_cast<SmTreeItem*>(index.internalPointer());

	if(role == Qt::DisplayRole){
		//if(index.column())
		if(index.column() == DvdNo){
			if(index.data(FileTypeRole) == QVariant()){
				return QVariant();
			}
			if(item->data(DvdNo).toInt() == -1){
				return QString(tr("(local)"));
			}else{
				QString retval = QString(tr("DVD #%1")).arg(item->data(DvdNo).toInt());
				return retval;
			}
		}
		if(index.column() == PartNo){
			if(item->data(PartNo).toInt() == -1){
				return QVariant();
			}
		}
		if(index.column() == Quality){
			if(item->data(Quality).toInt() < 1){
				return QVariant();
			}
			return item->data(Quality);
		}
		return item->data(index.column());
	}
	if(role == Qt::EditRole){
		return item->data(index.column());
	}
	if(role == Qt::DecorationRole){
		if(index.column() == 0){
			return QIcon(":/dildo.png");
		}
	}
	if(role == Qt::TextAlignmentRole){
		if(index.column() > 0 && index.column() < 4){
			return Qt::AlignRight;
		}
	}
	if(role == Qt::ForegroundRole){
		if(index.column() == SizeDisplay){
			if(item->data(Size).toLongLong() > Q_INT64_C(2147483648)){
				return QColor(Qt::red);
			}
			return QColor(Qt::green);
		}
	}
	if(role == FileNameRole){
		return item->data(FileName);
	}
	if(role == FullPathRole){
		return item->data(FullPath);
	}
	if(role == SizeRole){
		return item->data(Size);
	}
	if(role == DvdNoRole){
		return item->data(DvdNo);
	}
	if(role == SizeDisplay){
		return item->data(SizeDisplay);
	}
	if(role == FileTypeRole){
		return item->data(FileType);
	}
	if(role == Md5SumRole){
		return item->data(Md5Sum);
	}
	if(role == PartNoRole){
		return item->data(PartNo);
	}
	if(role == SeriesPartIdRole){
		return item->data(SeriesPartId);
	}
	if(role == QualityRole){
		return item->data(Quality);
	}
	if(role == FilesIdRole){
		return item->data(FilesId);
	}
	return QVariant();
}

bool FilesTreeModel::setData(const QModelIndex &index, const QVariant &value, int role){
	if(!index.isValid()){
		return false;
	}
	if(role == Qt::EditRole){
		SmTreeItem *item = static_cast<SmTreeItem*>(index.internalPointer());
		if(index.column() == DvdNo){
			mUpdateDvdQuery->bindValue(":id", index.data(FilesIdRole));
			mUpdateDvdQuery->bindValue(":dvd", value);
			if(mUpdateDvdQuery->exec()){
				item->setData(DvdNo, value);
				return true;
			}
		}
		if(index.column() == Quality){
			if(value.toInt() > 10 || value.toInt() < 0){
				return false;
			}
			mUpdateQualityQuery->bindValue(":id", index.data(FilesIdRole));
			mUpdateQualityQuery->bindValue(":quality", value);
			if(mUpdateQualityQuery->exec()){
				item->setData(Quality, value);
				return true;
			}
		}
	}
	return false;
}

Qt::ItemFlags FilesTreeModel::flags(const QModelIndex &index) const{
	if(!index.isValid()){
		return 0;
	}
	if(index.data(FileTypeRole) == QVariant()){
		return Qt::ItemIsEnabled;
	}
	Qt::ItemFlags retval = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
	if(index.column() == DvdNo || index.column() == Quality){
		return retval | Qt::ItemIsEditable;
	}
	return retval;
}

QHash<QString, QString> FilesTreeModel::filesBySeriesPartId(int seriesPartId){
	mFilesQuery->bindValue(":id", seriesPartId);
	QHash<QString, QString> retval;
	if(mFilesQuery->exec()){
		while(mFilesQuery->next()){
			retval.insert(mFilesQuery->value(0).toString(), mFilesQuery->value(1).toString());
		}
	}
	return retval;
}

bool FilesTreeModel::addFile(const QString &fullPath, int type, int quality, int filePart, int seriesPartId, int dvd){
	QFileInfo fi(fullPath);
	qint64 size = fi.size();
	if(!fi.exists()){
		//should be a dvd
		size = Q_INT64_C(4707319808);
	}

	QString md5Sum = Helper::md5Sum(fullPath);

	//prepare query
	mDb.transaction();
	mInsertFileQuery->bindValue(":seriespartid", seriesPartId);
	mInsertFileQuery->bindValue(":fname", fi.fileName());
	mInsertFileQuery->bindValue(":md5", md5Sum);
	mInsertFileQuery->bindValue(":size", size);
	mInsertFileQuery->bindValue(":dvd", dvd);
	mInsertFileQuery->bindValue(":type", type);
	mInsertFileQuery->bindValue(":fileno", filePart);
	mInsertFileQuery->bindValue(":quality", quality);

	//insert item
	if(mInsertFileQuery->exec()){
		mDb.commit();
		return true;
	}
	mDb.rollback();
	return false;
}

bool FilesTreeModel::deleteFile(const QModelIndex &file){
	QString fullPath = file.data(FullPathRole).toString();
	QFileInfo fi(fullPath);
	if(!fi.exists()){
		return false;
	}
	QVariant fileId = file.data(FilesIdRole);
	mDb.transaction();
	mDeleteFileQuery->bindValue(":id", fileId);
	if(!mDeleteFileQuery->exec()){
		mDb.rollback();
		return false;
	}
	if(!QFile::remove(fullPath)){
		mDb.rollback();
		return false;
	}
	removeRows(file.row(), 1, file.parent());
	mDb.commit();
	return true;
}

bool FilesTreeModel::deleteFiles(const QModelIndexList &files){
	foreach(QModelIndex i, files){
		bool retval = deleteFile(i);
		if(!retval){
			return false;
		}
	}
	return true;
}

void FilesTreeModel::populate(QSqlQuery &filesQuery){
	SmTreeItem *root = new SmTreeItem(11);
	SmTreeItem *files = new SmTreeItem(11, root);
	files->setData(FileName, tr("Movies"));
	root->appendChild(files);
	SmTreeItem *covers = new SmTreeItem(11, root);
	covers->setData(FileName, tr("Covers"));
	root->appendChild(covers);
	QLocale l;
	filesQuery.exec();
	while(filesQuery.next()){
		QList<QVariant> data;
		data << filesQuery.value(1); //filename
		data << filesQuery.value(6); //partno
		data << l.toString(filesQuery.value(3).toLongLong()); //displaysize
		data << filesQuery.value(7); //quality
		data << filesQuery.value(4); //dvdno
		data << Helper::createArchivePath(filesQuery.value(1).toString(), filesQuery.value(2).toString()); //fullpath
		data << filesQuery.value(3); //size
		data << filesQuery.value(5); //filetype
		data << filesQuery.value(2); //md5sum
		data << filesQuery.value(0); //seriesparts_id
		data << filesQuery.value(8); //files_id
		data << filesQuery.value(10); //seriespart
		QString displayName = QString("%1 %2").arg(filesQuery.value(9).toString()).arg(filesQuery.value(10).toString());
		data << displayName;
		switch(filesQuery.value(5).toInt()){
		case Movie:{
				SmTreeItem *item = new SmTreeItem(data, files);
				files->appendChild(item);
				break;
			}
		case FrontCover:
		case BackCover:
		case GeneralCover:{
					SmTreeItem *item = new SmTreeItem(data, covers);
				covers->appendChild(item);
				break;
			}
		default:
			;
		}
	}
	setRoot(root);
}