227 lines
8.3 KiB
C++
227 lines
8.3 KiB
C++
/* This file is part of Clementine.
|
|
Copyright 2012-2014, David Sansome <me@davidsansome.com>
|
|
Copyright 2014, John Maguire <john.maguire@gmail.com>
|
|
Copyright 2014, Krzysztof A. Sobiecki <sobkas@gmail.com>
|
|
|
|
Clementine 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.
|
|
|
|
Clementine 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 Clementine. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "podcastepisode.h"
|
|
|
|
#include <QDataStream>
|
|
#include <QDateTime>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
|
|
#include "core/logging.h"
|
|
#include "core/timeconstants.h"
|
|
#include "core/utilities.h"
|
|
#include "podcast.h"
|
|
|
|
const QStringList PodcastEpisode::kColumns = QStringList() << "podcast_id"
|
|
<< "title"
|
|
<< "description"
|
|
<< "author"
|
|
<< "publication_date"
|
|
<< "duration_secs"
|
|
<< "url"
|
|
<< "listened"
|
|
<< "listened_date"
|
|
<< "downloaded"
|
|
<< "local_url"
|
|
<< "extra";
|
|
|
|
const QString PodcastEpisode::kColumnSpec = PodcastEpisode::kColumns.join(", ");
|
|
const QString PodcastEpisode::kJoinSpec =
|
|
Utilities::Prepend("e.", PodcastEpisode::kColumns).join(", ");
|
|
const QString PodcastEpisode::kBindSpec =
|
|
Utilities::Prepend(":", PodcastEpisode::kColumns).join(", ");
|
|
const QString PodcastEpisode::kUpdateSpec =
|
|
Utilities::Updateify(PodcastEpisode::kColumns).join(", ");
|
|
|
|
struct PodcastEpisode::Private : public QSharedData {
|
|
Private();
|
|
|
|
int database_id_;
|
|
int podcast_database_id_;
|
|
|
|
QString title_;
|
|
QString description_;
|
|
QString author_;
|
|
QDateTime publication_date_;
|
|
int duration_secs_;
|
|
QUrl url_;
|
|
|
|
bool listened_;
|
|
QDateTime listened_date_;
|
|
|
|
bool downloaded_;
|
|
QUrl local_url_;
|
|
|
|
QVariantMap extra_;
|
|
};
|
|
|
|
PodcastEpisode::Private::Private()
|
|
: database_id_(-1),
|
|
podcast_database_id_(-1),
|
|
duration_secs_(-1),
|
|
listened_(false),
|
|
downloaded_(false) {}
|
|
|
|
PodcastEpisode::PodcastEpisode() : d(new Private) {}
|
|
|
|
PodcastEpisode::PodcastEpisode(const PodcastEpisode& other) : d(other.d) {}
|
|
|
|
PodcastEpisode::~PodcastEpisode() {}
|
|
|
|
PodcastEpisode& PodcastEpisode::operator=(const PodcastEpisode& other) {
|
|
d = other.d;
|
|
return *this;
|
|
}
|
|
|
|
int PodcastEpisode::database_id() const { return d->database_id_; }
|
|
int PodcastEpisode::podcast_database_id() const {
|
|
return d->podcast_database_id_;
|
|
}
|
|
const QString& PodcastEpisode::title() const { return d->title_; }
|
|
const QString& PodcastEpisode::description() const { return d->description_; }
|
|
const QString& PodcastEpisode::author() const { return d->author_; }
|
|
const QDateTime& PodcastEpisode::publication_date() const {
|
|
return d->publication_date_;
|
|
}
|
|
int PodcastEpisode::duration_secs() const { return d->duration_secs_; }
|
|
const QUrl& PodcastEpisode::url() const { return d->url_; }
|
|
bool PodcastEpisode::listened() const { return d->listened_; }
|
|
const QDateTime& PodcastEpisode::listened_date() const {
|
|
return d->listened_date_;
|
|
}
|
|
bool PodcastEpisode::downloaded() const { return d->downloaded_; }
|
|
const QUrl& PodcastEpisode::local_url() const { return d->local_url_; }
|
|
const QVariantMap& PodcastEpisode::extra() const { return d->extra_; }
|
|
QVariant PodcastEpisode::extra(const QString& key) const {
|
|
return d->extra_[key];
|
|
}
|
|
|
|
void PodcastEpisode::set_database_id(int v) { d->database_id_ = v; }
|
|
void PodcastEpisode::set_podcast_database_id(int v) {
|
|
d->podcast_database_id_ = v;
|
|
}
|
|
void PodcastEpisode::set_title(const QString& v) { d->title_ = v; }
|
|
void PodcastEpisode::set_description(const QString& v) { d->description_ = v; }
|
|
void PodcastEpisode::set_author(const QString& v) { d->author_ = v; }
|
|
void PodcastEpisode::set_publication_date(const QDateTime& v) {
|
|
d->publication_date_ = v;
|
|
}
|
|
void PodcastEpisode::set_duration_secs(int v) { d->duration_secs_ = v; }
|
|
void PodcastEpisode::set_url(const QUrl& v) { d->url_ = v; }
|
|
void PodcastEpisode::set_listened(bool v) { d->listened_ = v; }
|
|
void PodcastEpisode::set_listened_date(const QDateTime& v) {
|
|
d->listened_date_ = v;
|
|
}
|
|
void PodcastEpisode::set_downloaded(bool v) { d->downloaded_ = v; }
|
|
void PodcastEpisode::set_local_url(const QUrl& v) { d->local_url_ = v; }
|
|
void PodcastEpisode::set_extra(const QVariantMap& v) { d->extra_ = v; }
|
|
void PodcastEpisode::set_extra(const QString& key, const QVariant& value) {
|
|
d->extra_[key] = value;
|
|
}
|
|
|
|
void PodcastEpisode::InitFromQuery(const QSqlQuery& query) {
|
|
d->database_id_ = query.value(0).toInt();
|
|
d->podcast_database_id_ = query.value(1).toInt();
|
|
d->title_ = query.value(2).toString();
|
|
d->description_ = query.value(3).toString();
|
|
d->author_ = query.value(4).toString();
|
|
d->publication_date_ = QDateTime::fromTime_t(query.value(5).toUInt());
|
|
d->duration_secs_ = query.value(6).toInt();
|
|
d->url_ = QUrl::fromEncoded(query.value(7).toByteArray());
|
|
d->listened_ = query.value(8).toBool();
|
|
|
|
// After setting QDateTime to invalid state, it's saved into database as
|
|
// time_t, when this number std::numeric_limits<unsigned int>::max()
|
|
// (4294967295) is read back from database, it creates a valid QDateTime. So
|
|
// to make it behave consistently, this change is needed.
|
|
if (query.value(9).toUInt() == std::numeric_limits<unsigned int>::max()) {
|
|
d->listened_date_ = QDateTime();
|
|
} else {
|
|
d->listened_date_ = QDateTime::fromTime_t(query.value(9).toUInt());
|
|
}
|
|
|
|
d->downloaded_ = query.value(10).toBool();
|
|
d->local_url_ = QUrl::fromEncoded(query.value(11).toByteArray());
|
|
|
|
QDataStream extra_stream(query.value(12).toByteArray());
|
|
extra_stream >> d->extra_;
|
|
}
|
|
|
|
void PodcastEpisode::BindToQuery(QSqlQuery* query) const {
|
|
query->bindValue(":podcast_id", d->podcast_database_id_);
|
|
query->bindValue(":title", d->title_);
|
|
query->bindValue(":description", d->description_);
|
|
query->bindValue(":author", d->author_);
|
|
query->bindValue(":publication_date", d->publication_date_.toTime_t());
|
|
query->bindValue(":duration_secs", d->duration_secs_);
|
|
query->bindValue(":url", d->url_.toEncoded());
|
|
query->bindValue(":listened", d->listened_);
|
|
query->bindValue(":listened_date", d->listened_date_.toTime_t());
|
|
query->bindValue(":downloaded", d->downloaded_);
|
|
query->bindValue(":local_url", d->local_url_.toEncoded());
|
|
|
|
QByteArray extra;
|
|
QDataStream extra_stream(&extra, QIODevice::WriteOnly);
|
|
extra_stream << d->extra_;
|
|
|
|
query->bindValue(":extra", extra);
|
|
}
|
|
|
|
Song PodcastEpisode::ToSong(const Podcast& podcast) const {
|
|
Song ret;
|
|
ret.set_valid(true);
|
|
ret.set_title(title().simplified());
|
|
ret.set_artist(author().simplified());
|
|
ret.set_length_nanosec(kNsecPerSec * duration_secs());
|
|
ret.set_year(publication_date().date().year());
|
|
ret.set_comment(description());
|
|
ret.set_id(database_id());
|
|
ret.set_ctime(publication_date().toTime_t());
|
|
ret.set_genre(QString("Podcast"));
|
|
ret.set_genre_id3(186);
|
|
|
|
if (listened() && listened_date().isValid()) {
|
|
ret.set_mtime(listened_date().toTime_t());
|
|
} else {
|
|
ret.set_mtime(publication_date().toTime_t());
|
|
}
|
|
|
|
if (ret.length_nanosec() < 0) {
|
|
ret.set_length_nanosec(-1);
|
|
}
|
|
|
|
if (downloaded() && QFile::exists(local_url().toLocalFile())) {
|
|
ret.set_url(local_url());
|
|
} else {
|
|
ret.set_url(url());
|
|
}
|
|
|
|
ret.set_basefilename(QFileInfo(ret.url().path()).fileName());
|
|
|
|
// Use information from the podcast if it's set
|
|
if (podcast.is_valid()) {
|
|
ret.set_album(podcast.title().simplified());
|
|
ret.set_art_automatic(podcast.ImageUrlLarge().toString());
|
|
|
|
if (author().isEmpty()) ret.set_artist(podcast.title().simplified());
|
|
}
|
|
return ret;
|
|
}
|