path: root/seriesmetadatamodel.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 <QSqlDatabase>
#include <QSqlQuery>
#include <QSpinBox>
#include <QLineEdit>
#include <QComboBox>
#include <QPlainTextEdit>
#include <QDateEdit>
#include <QFormLayout>
#include <QVBoxLayout>
#include <QLabel>

#include "seriesmetadatamodel.h"
#include "smtreeitem.h"
#include "smglobals.h"
#include "helper.h"

SeriesMetadataModel::SeriesMetadataModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mColumns(9), mDataChanged(false), mCurrentId(-1){
	//setup database
	mDb = QSqlDatabase::database("treedb");
	mPopulateQuery = new QSqlQuery(mDb);
	mPopulateQuery->prepare("SELECT iseriespart_id, sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded FROM metadata WHERE iseriespart_id = :id");
	mPresentQuery = new QSqlQuery(mDb);
	mPresentQuery->prepare("SELECT COUNT(*) FROM metadata WHERE iseriespart_id = :id");
	mUpdateQuery = new QSqlQuery(mDb);
	mUpdateQuery->prepare("UPDATE metadata SET sireleaseyear = :year, tsourcemedium = :source, tsubject = :subject, treleasegroup = :group, tencoderopts = :encopts, tcomment = :comment, sipasses = :passes, dadded = :added WHERE iseriespart_id = :id");
	mInsertQuery = new QSqlQuery(mDb);
	mInsertQuery->prepare("INSERT INTO metadata (iseriespart_id, sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded) VALUES(:id, :year, :source, :subject, :group, :encopts, :comment, :passes, :added)");

	//misc
	mColumnNames.insert(SeriesPartId, "iseriespart_id");
	mColumnNames.insert(ReleaseYear, "sireleaseyear");
	mColumnNames.insert(SourceMedium, "tsourcemedium");
	mColumnNames.insert(Subject, "tsubject");
	mColumnNames.insert(ReleaseGroup, "treleasegroup");
	mColumnNames.insert(EncoderOpts, "tencoderopts");
	mColumnNames.insert(Comment, "tcomment");
	mColumnNames.insert(Passes, "sipasses");
	mColumnNames.insert(Added, "dadded");
}

SeriesMetadataModel::~SeriesMetadataModel(){
	delete mPopulateQuery;
	delete mPresentQuery;
	delete mUpdateQuery;
	delete mInsertQuery;
	mDb = QSqlDatabase();
}

QVariant SeriesMetadataModel::data(const QModelIndex &index, int role) const{
	if(!index.isValid()){
		return QVariant();
	}
	SmTreeItem *item = itemAt(index);
	if(role == SeriesPartIdRole){
		return item->data(SeriesPartId);
	}
	if(role == ReleaseYearRole){
		return item->data(ReleaseYear);
	}
	if(role == SourceMediumRole){
		return item->data(SourceMedium);
	}
	if(role == SubjectRole){
		return item->data(Subject);
	}
	if(role == ReleaseGroupRole){
		return item->data(ReleaseGroup);
	}
	if(role == EncoderOptsRole){
		return item->data(EncoderOpts);
	}
	if(role == CommentRole){
		return item->data(Comment);
	}
	if(role == PassesRole){
		return item->data(Passes);
	}
	if(role == AddedRole){
		return item->data(Added);
	}
	return SmTreeModel::data(index, role);
}

const QList<QVariant> SeriesMetadataModel::dataList(const QModelIndex &index) const{
	if(!index.isValid()){
		return QList<QVariant>();
	}
	QList<QVariant> retval;
	SmTreeItem *item = itemAt(index);
	for(int i = 0; i < mColumns; ++i){
		retval << item->data(i);
	}
	return retval;
}

const QList<QVariant> SeriesMetadataModel::fieldList(int field, bool distinct) const{
	if(field >= mColumns){
		return QList<QVariant>();
	}
	QString queryTempl;
	if(distinct){
		queryTempl = QString("SELECT DISTINCT(%1) FROM metadata ORDER BY %1").arg(mColumnNames.value(field));
	}else{
		queryTempl = QString("SELECT %1 FROM metadata ORDER BY %1").arg(mColumnNames.value(field));
	}
	QList<QVariant> retval;
	QSqlQuery query(queryTempl, mDb);
	while(query.next()){
		retval << query.value(0);
	}
	return retval;
}

bool SeriesMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role){
	if(!index.isValid()){
		return false;
	}
	mDataChanged = true;
	return SmTreeModel::setData(index, value, role);
}

bool SeriesMetadataModel::setData(const QModelIndex &parent, const QVariant &value, int row, int column, int role){
	if(row >= mColumns){
		return false;
	}
	QModelIndex idx = index(row, column, parent);
	return setData(idx, value, role);
}

bool SeriesMetadataModel::hasRecord(int seriesPartId) const{
	int count = -1;
	mPresentQuery->bindValue(":id", seriesPartId);
	if(mPresentQuery->exec()){
		while(mPresentQuery->next()){
			count = mPresentQuery->value(0).toInt();
		}
	}
	return (count > 0);
}

void SeriesMetadataModel::populate(int seriesPartId){
	mDataChanged = false;
	mCurrentId = seriesPartId;
	SmTreeItem *rootItem = new SmTreeItem(mColumns);
	rootItem->setData(SeriesPartId, -1);
	if(hasRecord(seriesPartId)){
		QList<QVariant> items;
		mPopulateQuery->bindValue(":id", seriesPartId);
		mPopulateQuery->exec();
		while(mPopulateQuery->next()){
			for(int i = 0; i < mColumns; ++i){
				items << mPopulateQuery->value(i);
			}
		}
		SmTreeItem *childItem = new SmTreeItem(items, rootItem);
		rootItem->appendChild(childItem);
	}else{
		SmTreeItem *childItem = new SmTreeItem(mColumns, rootItem);
		childItem->setData(0, seriesPartId);
		rootItem->appendChild(childItem);
	}
	setRoot(rootItem);
}

void SeriesMetadataModel::update(){
	QSqlQuery *query;
	if(hasRecord(mCurrentId)){
		query = mUpdateQuery;
	}else{
		query = mInsertQuery;
	}
	QModelIndex curIdx = find(mCurrentId, SeriesPartId);
	if(!curIdx.isValid()){
		return;
	}
	SmTreeItem *item = itemAt(curIdx);
	query->bindValue(":id", mCurrentId);
	query->bindValue(":year", item->data(ReleaseYear));
	query->bindValue(":source", item->data(SourceMedium));
	query->bindValue(":subject", item->data(Subject));
	query->bindValue(":group", item->data(ReleaseGroup));
	query->bindValue(":encopts", item->data(EncoderOpts));
	query->bindValue(":comment", item->data(Comment));
	query->bindValue(":passes", item->data(Passes));
	query->bindValue(":added", item->data(Added));
	query->exec();
}

MetadataWidget::MetadataWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f){
	//model
	mModel = static_cast<SeriesMetadataModel*>(SmGlobals::instance()->model("SeriesMetadata"));

	//layout
	QFormLayout *rowLayout = new QFormLayout;
	mReleaseYear = new QSpinBox;
	mReleaseYear->setMaximum(3000);
	mReleaseYear->setMinimum(1900);
	rowLayout->addRow(tr("Release year"), mReleaseYear);
	mReleaseGroup = new QComboBox;
	mPasses = new QSpinBox;
	rowLayout->addRow(tr("Encoding passes"), mPasses);
	mReleaseGroup->setEditable(true);
	rowLayout->addRow(tr("Release group"), mReleaseGroup);
	mSourceMedium = new QComboBox;
	mSourceMedium->setEditable(true);
	rowLayout->addRow(tr("Source medium"), mSourceMedium);
	mSubject = new QLineEdit;
	rowLayout->addRow(tr("Usenet subject"), mSubject);
	mEncoderOpts = new QLineEdit;
	rowLayout->addRow(tr("Encoder options"), mEncoderOpts);
	mAdded = new QDateEdit(QDate::currentDate());
	rowLayout->addRow(tr("Date added"), mAdded);
	QVBoxLayout *commentLayout = new QVBoxLayout;
	QLabel *commentLabel = new QLabel(tr("Comment"));
	commentLayout->addWidget(commentLabel);
	mComment = new QPlainTextEdit;
	commentLayout->addWidget(mComment);
	QVBoxLayout *mainLayout = new QVBoxLayout;
	mainLayout->addLayout(rowLayout);
	mainLayout->addLayout(commentLayout);
	setLayout(mainLayout);

	//init widgets
	QStringList relGroups = Helper::toStringList(mModel->fieldList(SeriesMetadataModel::ReleaseGroup));
	mReleaseGroup->addItems(relGroups);
	QStringList sources = Helper::toStringList(mModel->fieldList(SeriesMetadataModel::SourceMedium));
	mSourceMedium->addItems(sources);
}

void MetadataWidget::setSeriesPartId(int id){
	if(!mModel->hasRecord(id)){
		return;
	}
	mModel->populate(id);
	QModelIndex idx = mModel->find(id, SeriesMetadataModel::SeriesPartId);
	if(idx.isValid()){
		mReleaseYear->setValue(idx.data(SeriesMetadataModel::ReleaseYearRole).toInt());
		mPasses->setValue(idx.data(SeriesMetadataModel::PassesRole).toInt());
		int relGroupIdx = mReleaseGroup->findText(idx.data(SeriesMetadataModel::ReleaseGroupRole).toString());
		if(relGroupIdx != -1){
			mReleaseGroup->setCurrentIndex(relGroupIdx);
		}
		int sourceMedIdx = mSourceMedium->findData(idx.data(SeriesMetadataModel::PassesRole));
		if(sourceMedIdx != -1){
			mSourceMedium->setCurrentIndex(sourceMedIdx);
		}
		mSubject->setText(idx.data(SeriesMetadataModel::SubjectRole).toString());
		mEncoderOpts->setText(idx.data(SeriesMetadataModel::EncoderOptsRole).toString());
		mAdded->setDate(idx.data(SeriesMetadataModel::AddedRole).toDate());
		mComment->setPlainText(idx.data(SeriesMetadataModel::CommentRole).toString());
	}
}

void MetadataWidget::accept(){
	QModelIndex curIdx = mModel->find(mModel->currentId(), SeriesMetadataModel::SeriesPartId);
	QModelIndex parent = curIdx.parent();
	int row = curIdx.row();
	mModel->setData(parent, mReleaseYear->value(), row, SeriesMetadataModel::ReleaseYear);
	mModel->setData(parent, mPasses->value(), row, SeriesMetadataModel::Passes);
	mModel->setData(parent, mReleaseGroup->currentText(), row, SeriesMetadataModel::ReleaseGroup);
	mModel->setData(parent, mSourceMedium->currentText(), row, SeriesMetadataModel::SourceMedium);
	mModel->setData(parent, mSubject->text(), row, SeriesMetadataModel::Subject);
	mModel->setData(parent, mEncoderOpts->text(), row, SeriesMetadataModel::EncoderOpts);
	mModel->setData(parent, mAdded->date(), row, SeriesMetadataModel::Added);
	mModel->setData(parent, mComment->toPlainText(), row, SeriesMetadataModel::Comment);
	mModel->update();
}