Lines
77.61 %
Functions
28.33 %
Branches
48.55 %
/*
* This file is part of mailpot
*
* Copyright 2020 - Manos Pitsidianakis
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
* This program 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 Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
//! How each list handles new posts and new subscriptions.
mod post_policy {
use log::trace;
use rusqlite::OptionalExtension;
use crate::{
errors::{ErrorKind::*, *},
models::{DbVal, PostPolicy},
Connection,
};
impl Connection {
/// Fetch the post policy of a mailing list.
pub fn list_post_policy(&self, pk: i64) -> Result<Option<DbVal<PostPolicy>>> {
let mut stmt = self
.connection
.prepare("SELECT * FROM post_policy WHERE list = ?;")?;
let ret = stmt
.query_row([&pk], |row| {
let pk = row.get("pk")?;
Ok(DbVal(
PostPolicy {
pk,
list: row.get("list")?,
announce_only: row.get("announce_only")?,
subscription_only: row.get("subscription_only")?,
approval_needed: row.get("approval_needed")?,
open: row.get("open")?,
custom: row.get("custom")?,
},
))
})
.optional()?;
Ok(ret)
}
/// Remove an existing list policy.
///
/// # Examples
/// ```
/// # use mailpot::{models::*, Configuration, Connection, SendMail};
/// # use tempfile::TempDir;
/// #
/// # let tmp_dir = TempDir::new().unwrap();
/// # let db_path = tmp_dir.path().join("mpot.db");
/// # let config = Configuration {
/// # send_mail: SendMail::ShellCommand("/usr/bin/false".to_string()),
/// # db_path: db_path.clone(),
/// # data_path: tmp_dir.path().to_path_buf(),
/// # administrators: vec![],
/// # };
/// # fn do_test(config: Configuration) {
/// let db = Connection::open_or_create_db(config).unwrap().trusted();
/// # assert!(db.list_post_policy(1).unwrap().is_none());
/// let list = db
/// .create_list(MailingList {
/// pk: 0,
/// name: "foobar chat".into(),
/// id: "foo-chat".into(),
/// address: "foo-chat@example.com".into(),
/// description: None,
/// topics: vec![],
/// archive_url: None,
/// })
/// .unwrap();
/// # assert!(db.list_post_policy(list.pk()).unwrap().is_none());
/// let pol = db
/// .set_list_post_policy(PostPolicy {
/// pk: -1,
/// list: list.pk(),
/// announce_only: false,
/// subscription_only: true,
/// approval_needed: false,
/// open: false,
/// custom: false,
/// # assert_eq!(db.list_post_policy(list.pk()).unwrap().as_ref(), Some(&pol));
/// db.remove_list_post_policy(list.pk(), pol.pk()).unwrap();
/// # }
/// # do_test(config);
/// ```should_panic
/// db.remove_list_post_policy(1, 1).unwrap();
pub fn remove_list_post_policy(&self, list_pk: i64, policy_pk: i64) -> Result<()> {
.prepare("DELETE FROM post_policy WHERE pk = ? AND list = ? RETURNING *;")?;
stmt.query_row(rusqlite::params![&policy_pk, &list_pk,], |_| Ok(()))
.map_err(|err| {
if matches!(err, rusqlite::Error::QueryReturnedNoRows) {
Error::from(err).chain_err(|| NotFound("list or list policy not found!"))
} else {
err.into()
})?;
trace!("remove_list_post_policy {} {}.", list_pk, policy_pk);
Ok(())
/// Set the unique post policy for a list.
pub fn set_list_post_policy(&self, policy: PostPolicy) -> Result<DbVal<PostPolicy>> {
if !(policy.announce_only
|| policy.subscription_only
|| policy.approval_needed
|| policy.open
|| policy.custom)
{
return Err(Error::new_external(
"Cannot add empty policy. Having no policies is probably what you want to do.",
));
let list_pk = policy.list;
let mut stmt = self.connection.prepare(
"INSERT OR REPLACE INTO post_policy(list, announce_only, subscription_only, \
approval_needed, open, custom) VALUES (?, ?, ?, ?, ?, ?) RETURNING *;",
)?;
.query_row(
rusqlite::params![
&list_pk,
&policy.announce_only,
&policy.subscription_only,
&policy.approval_needed,
&policy.open,
&policy.custom,
],
|row| {
)
if matches!(
err,
rusqlite::Error::SqliteFailure(
rusqlite::ffi::Error {
code: rusqlite::ffi::ErrorCode::ConstraintViolation,
extended_code: 787
_
) {
Error::from(err)
.chain_err(|| NotFound("Could not find a list with this pk."))
trace!("set_list_post_policy {:?}.", &ret);
mod subscription_policy {
models::{DbVal, SubscriptionPolicy},
/// Fetch the subscription policy of a mailing list.
pub fn list_subscription_policy(
&self,
pk: i64,
) -> Result<Option<DbVal<SubscriptionPolicy>>> {
.prepare("SELECT * FROM subscription_policy WHERE list = ?;")?;
SubscriptionPolicy {
send_confirmation: row.get("send_confirmation")?,
manual: row.get("manual")?,
request: row.get("request")?,
/// Remove an existing subscription policy.
/// # assert!(db.list_subscription_policy(list.pk()).unwrap().is_none());
/// .set_list_subscription_policy(SubscriptionPolicy {
/// send_confirmation: false,
/// open: true,
/// manual: false,
/// request: false,
/// # assert_eq!(db.list_subscription_policy(list.pk()).unwrap().as_ref(), Some(&pol));
/// db.remove_list_subscription_policy(list.pk(), pol.pk())
pub fn remove_list_subscription_policy(&self, list_pk: i64, policy_pk: i64) -> Result<()> {
"DELETE FROM subscription_policy WHERE pk = ? AND list = ? RETURNING *;",
trace!("remove_list_subscription_policy {} {}.", list_pk, policy_pk);
pub fn set_list_subscription_policy(
policy: SubscriptionPolicy,
) -> Result<DbVal<SubscriptionPolicy>> {
if !(policy.open || policy.manual || policy.request || policy.custom) {
"Cannot add empty policy. Having no policy is probably what you want to do.",
"INSERT OR REPLACE INTO subscription_policy(list, send_confirmation, open, \
manual, request, custom) VALUES (?, ?, ?, ?, ?, ?) RETURNING *;",
&policy.send_confirmation,
&policy.manual,
&policy.request,
trace!("set_list_subscription_policy {:?}.", &ret);