340 lines
11 KiB
C++
340 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2018 Emeric Poupon
|
|
*
|
|
* This file is part of LMS.
|
|
*
|
|
* LMS 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.
|
|
*
|
|
* LMS 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 LMS. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "SettingsView.hpp"
|
|
|
|
#include <Wt/WCheckBox.h>
|
|
#include <Wt/WComboBox.h>
|
|
#include <Wt/WFormModel.h>
|
|
#include <Wt/WLineEdit.h>
|
|
#include <Wt/WPushButton.h>
|
|
#include <Wt/WString.h>
|
|
#include <Wt/WTemplateFormView.h>
|
|
|
|
#include "common/Validators.hpp"
|
|
#include "common/ValueStringModel.hpp"
|
|
|
|
#include "auth/PasswordService.hpp"
|
|
#include "utils/Logger.hpp"
|
|
#include "utils/Service.hpp"
|
|
|
|
#include "LmsApplication.hpp"
|
|
|
|
namespace UserInterface {
|
|
|
|
using namespace Database;
|
|
|
|
class SettingsModel : public Wt::WFormModel
|
|
{
|
|
public:
|
|
// Associate each field with a unique string literal.
|
|
static const Field TranscodeEnableField;
|
|
static const Field TranscodeFormatField;
|
|
static const Field TranscodeBitrateField;
|
|
static const Field PasswordOldField;
|
|
static const Field PasswordField;
|
|
static const Field PasswordConfirmField;
|
|
|
|
SettingsModel(bool withOldPassword)
|
|
: _withOldPassword {withOldPassword}
|
|
{
|
|
initializeModels();
|
|
|
|
addField(TranscodeEnableField);
|
|
addField(TranscodeBitrateField);
|
|
addField(TranscodeFormatField);
|
|
|
|
if (_withOldPassword)
|
|
addField(PasswordOldField);
|
|
|
|
addField(PasswordField);
|
|
addField(PasswordConfirmField);
|
|
|
|
setValidator(TranscodeBitrateField, createMandatoryValidator());
|
|
setValidator(TranscodeFormatField, createMandatoryValidator());
|
|
|
|
loadData();
|
|
}
|
|
|
|
std::shared_ptr<Wt::WAbstractItemModel> transcodeBitrateModel() { return _transcodeBitrateModel; }
|
|
std::shared_ptr<Wt::WAbstractItemModel> transcodeFormatModel() { return _transcodeFormatModel; }
|
|
|
|
void saveData()
|
|
{
|
|
Database::User::PasswordHash passwordHash;
|
|
|
|
if (!valueText(PasswordField).empty())
|
|
passwordHash = getService<::Auth::PasswordService>()->hashPassword(valueText(PasswordField).toUTF8());
|
|
|
|
auto transaction {LmsApp->getDbSession().createUniqueTransaction()};
|
|
|
|
Database::User::pointer user {LmsApp->getUser()};
|
|
|
|
user.modify()->setAudioTranscodeEnable(Wt::asNumber(value(TranscodeEnableField)));
|
|
|
|
auto transcodeBitrateRow {_transcodeBitrateModel->getRowFromString(valueText(TranscodeBitrateField))};
|
|
if (transcodeBitrateRow)
|
|
user.modify()->setAudioTranscodeBitrate(_transcodeBitrateModel->getValue(*transcodeBitrateRow));
|
|
|
|
auto transcodeFormatRow {_transcodeFormatModel->getRowFromString(valueText(TranscodeFormatField))};
|
|
if (transcodeFormatRow)
|
|
user.modify()->setAudioTranscodeFormat(_transcodeFormatModel->getValue(*transcodeFormatRow));
|
|
|
|
if (!valueText(PasswordField).empty())
|
|
{
|
|
user.modify()->setPasswordHash(passwordHash);
|
|
user.modify()->clearAuthTokens();
|
|
}
|
|
}
|
|
|
|
void loadData()
|
|
{
|
|
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
|
|
|
|
setValue(TranscodeEnableField, LmsApp->getUser()->getAudioTranscodeEnable());
|
|
if (!LmsApp->getUser()->getAudioTranscodeEnable())
|
|
{
|
|
setReadOnly(TranscodeFormatField, true);
|
|
setReadOnly(TranscodeBitrateField, true);
|
|
}
|
|
|
|
auto transcodeBitrateRow {_transcodeBitrateModel->getRowFromValue(LmsApp->getUser()->getAudioTranscodeBitrate())};
|
|
if (transcodeBitrateRow)
|
|
setValue(TranscodeBitrateField, _transcodeBitrateModel->getString(*transcodeBitrateRow));
|
|
|
|
auto transcodeFormatRow {_transcodeFormatModel->getRowFromValue(LmsApp->getUser()->getAudioTranscodeFormat())};
|
|
if (transcodeFormatRow)
|
|
setValue(TranscodeFormatField, _transcodeFormatModel->getString(*transcodeFormatRow));
|
|
}
|
|
|
|
private:
|
|
|
|
bool validateField(Field field)
|
|
{
|
|
Wt::WString error;
|
|
|
|
if (field == PasswordOldField)
|
|
{
|
|
if (!valueText(PasswordOldField).empty())
|
|
{
|
|
switch (getService<::Auth::PasswordService>()->checkUserPassword(
|
|
LmsApp->getDbSession(),
|
|
boost::asio::ip::address::from_string(LmsApp->environment().clientAddress()),
|
|
LmsApp->getUserLoginName(),
|
|
valueText(PasswordOldField).toUTF8()))
|
|
{
|
|
case ::Auth::PasswordService::PasswordCheckResult::Match:
|
|
break;
|
|
case ::Auth::PasswordService::PasswordCheckResult::Mismatch:
|
|
error = Wt::WString::tr("Lms.Settings.password-bad");
|
|
break;
|
|
case ::Auth::PasswordService::PasswordCheckResult::Throttled:
|
|
error = Wt::WString::tr("Lms.password-client-throttled");
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!valueText(PasswordField).empty())
|
|
error = Wt::WString::tr("Lms.Settings.password-must-fill-old-password");
|
|
else
|
|
return Wt::WFormModel::validateField(field);
|
|
}
|
|
}
|
|
else if (field == PasswordField)
|
|
{
|
|
if (!valueText(PasswordField).empty())
|
|
{
|
|
if (!getService<::Auth::PasswordService>()->evaluatePasswordStrength(LmsApp->getUserLoginName(), valueText(PasswordField).toUTF8()))
|
|
error = Wt::WString::tr("Lms.password-too-weak");
|
|
}
|
|
else
|
|
{
|
|
if (!valueText(PasswordOldField).empty())
|
|
error = Wt::WString::tr("Wt.WValidator.Invalid");
|
|
else
|
|
return Wt::WFormModel::validateField(field);
|
|
}
|
|
}
|
|
else if (field == PasswordConfirmField)
|
|
{
|
|
if (validation(PasswordField).state() == Wt::ValidationState::Valid)
|
|
{
|
|
if (valueText(PasswordField) != valueText(PasswordConfirmField))
|
|
error = Wt::WString::tr("Lms.passwords-dont-match");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Wt::WFormModel::validateField(field);
|
|
}
|
|
|
|
setValidation(field, Wt::WValidator::Result( error.empty() ? Wt::ValidationState::Valid : Wt::ValidationState::Invalid, error));
|
|
|
|
return (validation(field).state() == Wt::ValidationState::Valid);
|
|
}
|
|
|
|
private:
|
|
|
|
void initializeModels()
|
|
{
|
|
Bitrate maxAudioBitrate;
|
|
{
|
|
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
|
|
maxAudioBitrate = LmsApp->getUser()->getMaxAudioTranscodeBitrate();
|
|
}
|
|
|
|
_transcodeBitrateModel = std::make_shared<ValueStringModel<Bitrate>>();
|
|
for (const Bitrate bitrate : User::audioTranscodeAllowedBitrates)
|
|
{
|
|
if (bitrate > maxAudioBitrate)
|
|
break;
|
|
|
|
_transcodeBitrateModel->add(Wt::WString::fromUTF8(std::to_string(bitrate / 1000)), bitrate);
|
|
}
|
|
|
|
_transcodeFormatModel = std::make_shared<ValueStringModel<AudioFormat>>();
|
|
_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcoding.mp3"), AudioFormat::MP3);
|
|
_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcoding.ogg_opus"), AudioFormat::OGG_OPUS);
|
|
_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcoding.matroska_opus"), AudioFormat::MATROSKA_OPUS);
|
|
_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcoding.ogg_vorbis"), AudioFormat::OGG_VORBIS);
|
|
_transcodeFormatModel->add(Wt::WString::tr("Lms.Settings.transcoding.webm_vorbis"), AudioFormat::WEBM_VORBIS);
|
|
}
|
|
|
|
bool _withOldPassword {};
|
|
|
|
std::shared_ptr<ValueStringModel<Bitrate>> _transcodeBitrateModel;
|
|
std::shared_ptr<ValueStringModel<AudioFormat>> _transcodeFormatModel;
|
|
};
|
|
|
|
const Wt::WFormModel::Field SettingsModel::TranscodeEnableField = "transcoding-enable";
|
|
const Wt::WFormModel::Field SettingsModel::TranscodeBitrateField = "transcoding-bitrate";
|
|
const Wt::WFormModel::Field SettingsModel::TranscodeFormatField = "transcoding-format";
|
|
const Wt::WFormModel::Field SettingsModel::PasswordOldField = "password-old";
|
|
const Wt::WFormModel::Field SettingsModel::PasswordField = "password";
|
|
const Wt::WFormModel::Field SettingsModel::PasswordConfirmField = "password-confirm";
|
|
|
|
SettingsView::SettingsView()
|
|
{
|
|
wApp->internalPathChanged().connect(std::bind([=]
|
|
{
|
|
refreshView();
|
|
}));
|
|
|
|
refreshView();
|
|
}
|
|
|
|
void
|
|
SettingsView::refreshView()
|
|
{
|
|
if (!wApp->internalPathMatches("/settings"))
|
|
return;
|
|
|
|
clear();
|
|
|
|
auto t {addNew<Wt::WTemplateFormView>(Wt::WString::tr("Lms.Settings.template"))};
|
|
|
|
auto model {std::make_shared<SettingsModel>(!LmsApp->isUserAuthStrong())};
|
|
|
|
// Old password
|
|
if (!LmsApp->isUserAuthStrong())
|
|
{
|
|
t->setCondition("if-has-old-password", true);
|
|
auto oldPassword {std::make_unique<Wt::WLineEdit>()};
|
|
oldPassword->setEchoMode(Wt::EchoMode::Password);
|
|
t->setFormWidget(SettingsModel::PasswordOldField, std::move(oldPassword));
|
|
}
|
|
|
|
// Password
|
|
auto password {std::make_unique<Wt::WLineEdit>()};
|
|
password->setEchoMode(Wt::EchoMode::Password);
|
|
t->setFormWidget(SettingsModel::PasswordField, std::move(password));
|
|
|
|
// Password confirm
|
|
auto passwordConfirm {std::make_unique<Wt::WLineEdit>()};
|
|
passwordConfirm->setEchoMode(Wt::EchoMode::Password);
|
|
t->setFormWidget(SettingsModel::PasswordConfirmField, std::move(passwordConfirm));
|
|
|
|
// Transcoding
|
|
auto transcode {std::make_unique<Wt::WCheckBox>()};
|
|
auto* transcodeRaw {transcode.get()};
|
|
t->setFormWidget(SettingsModel::TranscodeEnableField, std::move(transcode));
|
|
|
|
// Format
|
|
auto transcodeFormat {std::make_unique<Wt::WComboBox>()};
|
|
transcodeFormat->setModel(model->transcodeFormatModel());
|
|
t->setFormWidget(SettingsModel::TranscodeFormatField, std::move(transcodeFormat));
|
|
|
|
// Bitrate
|
|
auto transcodeBitrate {std::make_unique<Wt::WComboBox>()};
|
|
transcodeBitrate->setModel(model->transcodeBitrateModel());
|
|
t->setFormWidget(SettingsModel::TranscodeBitrateField, std::move(transcodeBitrate));
|
|
|
|
transcodeRaw->changed().connect([=]()
|
|
{
|
|
bool enable {transcodeRaw->checkState() == Wt::CheckState::Checked};
|
|
model->setReadOnly(SettingsModel::TranscodeFormatField, !enable);
|
|
model->setReadOnly(SettingsModel::TranscodeBitrateField, !enable);
|
|
t->updateModel(model.get());
|
|
t->updateView(model.get());
|
|
});
|
|
|
|
// Buttons
|
|
Wt::WPushButton *saveBtn {t->bindWidget("apply-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.apply")))};
|
|
Wt::WPushButton *discardBtn {t->bindWidget("discard-btn", std::make_unique<Wt::WPushButton>(Wt::WString::tr("Lms.discard")))};
|
|
|
|
saveBtn->clicked().connect(std::bind([=] ()
|
|
{
|
|
|
|
{
|
|
auto transaction {LmsApp->getDbSession().createSharedTransaction()};
|
|
|
|
if (LmsApp->getUser()->isDemo())
|
|
{
|
|
LmsApp->notifyMsg(MsgType::Warning, Wt::WString::tr("Lms.Settings.demo-cannot-save"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
t->updateModel(model.get());
|
|
|
|
if (model->validate())
|
|
{
|
|
model->saveData();
|
|
LmsApp->notifyMsg(MsgType::Success, Wt::WString::tr("Lms.Settings.settings-saved"));
|
|
}
|
|
|
|
// Udate the view: Delete any validation message in the view, etc.
|
|
t->updateView(model.get());
|
|
}));
|
|
|
|
discardBtn->clicked().connect(std::bind([=] ()
|
|
{
|
|
model->loadData();
|
|
model->validate();
|
|
t->updateView(model.get());
|
|
}));
|
|
|
|
t->updateView(model.get());
|
|
}
|
|
|
|
} // namespace UserInterface
|
|
|
|
|