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 <QGroupBox>
#include <QSettings>
#include <QColor>
#include <QTreeView>

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

SeriesMetadataModel::SeriesMetadataModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mColumns(3), mDataFields(8), mCurrentId(-1){
	//setup database
	mDb = QSqlDatabase::database("treedb");
	mPopulateQuery = new QSqlQuery(mDb);
	mPopulateQuery->prepare("SELECT 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");
	mUpdateAllQuery = new QSqlQuery(mDb);
	mUpdateAllQuery->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
	mDbColumnNames.insert(ReleaseYear, "sireleaseyear");
	mDbColumnNames.insert(SourceMedium, "tsourcemedium");
	mDbColumnNames.insert(Subject, "tsubject");
	mDbColumnNames.insert(ReleaseGroup, "treleasegroup");
	mDbColumnNames.insert(EncoderOpts, "tencoderopts");
	mDbColumnNames.insert(Comment, "tcomment");
	mDbColumnNames.insert(Passes, "sipasses");
	mDbColumnNames.insert(Added, "dadded");

	for(int i = 0; i < mDataFields; ++i){
		mData << QVariant();
	}
	mDisplayColumnNames.insert(ReleaseYear, "Release year");
	mDisplayColumnNames.insert(SourceMedium, "Source medium");
	mDisplayColumnNames.insert(Subject, "Usenet subject");
	mDisplayColumnNames.insert(ReleaseGroup, "Release group");
	mDisplayColumnNames.insert(EncoderOpts, "Encoder options");
	mDisplayColumnNames.insert(Comment, "Comment");
	mDisplayColumnNames.insert(Passes, "Encoding passes");
	mDisplayColumnNames.insert(Added, "Date added");
}

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

QVariant SeriesMetadataModel::data(int column) const {
	if((column < 0 ) || (column >= mDataFields)){
		return QVariant();
	}
	return mData.at(column);
}

const QList<QVariant> SeriesMetadataModel::dataList(const QModelIndex &index) const{
	if(!index.isValid()){
		return QList<QVariant>();
	}
	return mData;
}

const QList<QVariant> SeriesMetadataModel::fieldList(int field, bool distinct) const{
	if(field >= mDataFields){
		return QList<QVariant>();
	}
	QString queryTempl;
	if(distinct){
		queryTempl = QString("SELECT DISTINCT(%1) FROM metadata ORDER BY %1").arg(mDbColumnNames.value(field));
	}else{
		queryTempl = QString("SELECT %1 FROM metadata ORDER BY %1").arg(mDbColumnNames.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;
	}
	if(index.row() >= mDataFields){
		return false;
	}
	if(role != Qt::EditRole){
		return false;
	}
	SmTreeItem *item = static_cast<SmTreeItem*>(index.internalPointer());
	Q_ASSERT(item);
	item->setData(index.column(), value);
	mData[item->data(2).toInt()] = value;
	update();
	return true;
}

void SeriesMetadataModel::setAllData(int seriesId, const QList<QVariant> &data){
	if(data.size() != mDataFields){
		return;
	}
	mCurrentId = seriesId;
	mData = data;
	createTree(mData);
	update();
}

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);
}

Qt::ItemFlags SeriesMetadataModel::flags(const QModelIndex &index) const{
	Qt::ItemFlags retval;
	retval |= Qt::ItemIsEnabled | Qt::ItemIsSelectable;
	if(index.column() == 1){
		retval |= Qt::ItemIsEditable;
	}
	return retval;
}

void SeriesMetadataModel::populate(int seriesPartId){
	mCurrentId = seriesPartId;
	if(hasRecord(seriesPartId)){
		mPopulateQuery->bindValue(":id", seriesPartId);
		if(mPopulateQuery->exec()){
			while(mPopulateQuery->next()){
				for(int i = 0; i < mDataFields; ++i){
					mData[i] = mPopulateQuery->value(i);
				}

			}
		}
	}else{
		for(int i = 0; i < numFields(); ++i){
			mData[i] = QVariant();
		}
	}
	createTree(mData);
}

void SeriesMetadataModel::update(){
	QSqlQuery *query;
	if(hasRecord(mCurrentId)){
		query = mUpdateAllQuery;
	}else{
		query = mInsertQuery;
	}
	query->bindValue(":id", mCurrentId);
	query->bindValue(":year", mData.at(ReleaseYear));
	query->bindValue(":source", mData.at(SourceMedium));
	query->bindValue(":subject", mData.at(Subject));
	query->bindValue(":group", mData.at(ReleaseGroup));
	query->bindValue(":encopts", mData.at(EncoderOpts));
	query->bindValue(":comment", mData.at(Comment));
	query->bindValue(":passes", mData.at(Passes));
	query->bindValue(":added", mData.at(Added));
	query->exec();
}

void SeriesMetadataModel::createTree(const QList<QVariant> &data){
	SmTreeItem *rootItem = new SmTreeItem(mColumns);
	for(int i = 0; i < mDataFields; ++i){
		QList<QVariant> itemData;
		itemData << mDisplayColumnNames.value(i) << data.at(i) << i;
		SmTreeItem *item = new SmTreeItem(itemData, rootItem);
		rootItem->appendChild(item);
	}
	setRoot(rootItem);
}

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(mModel->columnName(SeriesMetadataModel::ReleaseYear), mReleaseYear);
	mReleaseGroup = new QComboBox;
	mPasses = new QSpinBox;
	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::Passes), mPasses);
	mReleaseGroup->setEditable(true);
	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::ReleaseGroup), mReleaseGroup);
	mSourceMedium = new QComboBox;
	mSourceMedium->setEditable(true);
	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::SourceMedium), mSourceMedium);
	mSubject = new QLineEdit;
	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::Subject), mSubject);
	mEncoderOpts = new QLineEdit;
	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::EncoderOpts), mEncoderOpts);
	mAdded = new QDateEdit(QDate::currentDate());
	rowLayout->addRow(mModel->columnName(SeriesMetadataModel::Added), mAdded);
	QVBoxLayout *commentLayout = new QVBoxLayout;
	QLabel *commentLabel = new QLabel(mModel->columnName(SeriesMetadataModel::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);
	mReleaseYear->setValue(mModel->data(SeriesMetadataModel::ReleaseYear).toInt());
	mPasses->setValue(mModel->data(SeriesMetadataModel::Passes).toInt());
	mSubject->setText(mModel->data(SeriesMetadataModel::Subject).toString());
	mEncoderOpts->setText(mModel->data(SeriesMetadataModel::EncoderOpts).toString());
	mAdded->setDate(mModel->data(SeriesMetadataModel::Added).toDate());
	int relGroupIdx = mReleaseGroup->findText(mModel->data(SeriesMetadataModel::ReleaseGroup).toString());
	if(relGroupIdx != -1){
		mReleaseGroup->setCurrentIndex(relGroupIdx);
	}
	int sourceMediumIdx = mSourceMedium->findData(mModel->data(SeriesMetadataModel::SourceMedium).toString());
	if(sourceMediumIdx != -1){
		mSourceMedium->setCurrentIndex(sourceMediumIdx);
	}
}

void MetadataWidget::accept(){
	QList<QVariant> metaData;
	for(int i = 0; i < mModel->numFields(); ++i){
		metaData << QVariant();
	}

	metaData[SeriesMetadataModel::ReleaseYear] = mReleaseYear->value();
	metaData[SeriesMetadataModel::Subject] = mSubject->text();
	metaData[SeriesMetadataModel::EncoderOpts] = mEncoderOpts->text();
	metaData[SeriesMetadataModel::Passes] = mPasses->value();
	metaData[SeriesMetadataModel::SourceMedium] = mSourceMedium->currentText();
	metaData[SeriesMetadataModel::ReleaseGroup] = mReleaseGroup->currentText();
	metaData[SeriesMetadataModel::Added] = mAdded->date();
	mModel->setAllData(mModel->currentId(), metaData);
}

MetadataDisplay::MetadataDisplay(QWidget *parent) : QWidget(parent){
	//model
	mModel = static_cast<SeriesMetadataModel*>(SmGlobals::instance()->model("SeriesMetadata"));

	//display
	QGroupBox *gb = new QGroupBox(tr("Metadata"));
	QHBoxLayout *gbLayout = new QHBoxLayout;
	mDisplay = new QTreeView;
	mDisplay->setModel(mModel);
	mDisplay->setSelectionBehavior(QAbstractItemView::SelectRows);
	mDisplay->setAlternatingRowColors(true);
	mDisplay->setHeaderHidden(true);
	gbLayout->addWidget(mDisplay);
	gb->setLayout(gbLayout);

	//laoyut
	QVBoxLayout *mainLayout = new QVBoxLayout;
	mainLayout->addWidget(gb);
	setLayout(mainLayout);
}

void MetadataDisplay::setSeriesPartId(int seriesPartId){
	mModel->populate(seriesPartId);
	mDisplay->setColumnHidden(2, true);
	mDisplay->resizeColumnToContents(0);
	mDisplay->resizeColumnToContents(1);
}