254 lines
8.1 KiB
Rust
254 lines
8.1 KiB
Rust
/*
|
|
* 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/>.
|
|
*/
|
|
|
|
use super::*;
|
|
|
|
pub fn datetime_header_value_lint(db: &mut Connection, dry_run: bool) -> Result<()> {
|
|
let mut col = vec![];
|
|
{
|
|
let mut stmt = db.connection.prepare("SELECT * FROM post ORDER BY pk")?;
|
|
let iter = stmt.query_map([], |row| {
|
|
let pk: i64 = row.get("pk")?;
|
|
let date_s: String = row.get("datetime")?;
|
|
match melib::datetime::rfc822_to_timestamp(date_s.trim()) {
|
|
Err(_) | Ok(0) => {
|
|
let mut timestamp: i64 = row.get("timestamp")?;
|
|
let created: i64 = row.get("created")?;
|
|
if timestamp == 0 {
|
|
timestamp = created;
|
|
}
|
|
timestamp = std::cmp::min(timestamp, created);
|
|
let timestamp = if timestamp <= 0 {
|
|
None
|
|
} else {
|
|
// safe because we checked it's not negative or zero above.
|
|
Some(timestamp as u64)
|
|
};
|
|
let message: Vec<u8> = row.get("message")?;
|
|
Ok(Some((pk, date_s, message, timestamp)))
|
|
}
|
|
Ok(_) => Ok(None),
|
|
}
|
|
})?;
|
|
|
|
for entry in iter {
|
|
if let Some(s) = entry? {
|
|
col.push(s);
|
|
}
|
|
}
|
|
}
|
|
let mut failures = 0;
|
|
let tx = if dry_run {
|
|
None
|
|
} else {
|
|
Some(db.connection.transaction()?)
|
|
};
|
|
if col.is_empty() {
|
|
println!("datetime_header_value: ok");
|
|
} else {
|
|
println!("datetime_header_value: found {} entries", col.len());
|
|
println!("pk\tDate value\tshould be");
|
|
for (pk, val, message, timestamp) in col {
|
|
let correct = if let Ok(v) =
|
|
chrono::DateTime::<chrono::FixedOffset>::parse_from_rfc3339(&val)
|
|
{
|
|
v.to_rfc2822()
|
|
} else if let Some(v) = timestamp.map(|t| {
|
|
melib::datetime::timestamp_to_string(t, Some(melib::datetime::RFC822_DATE), true)
|
|
}) {
|
|
v
|
|
} else if let Ok(v) =
|
|
Envelope::from_bytes(&message, None).map(|env| env.date_as_str().to_string())
|
|
{
|
|
v
|
|
} else {
|
|
failures += 1;
|
|
println!("{pk}\t{val}\tCould not find any valid date value in the post metadata!");
|
|
continue;
|
|
};
|
|
println!("{pk}\t{val}\t{correct}");
|
|
if let Some(tx) = tx.as_ref() {
|
|
tx.execute(
|
|
"UPDATE post SET datetime = ? WHERE pk = ?",
|
|
rusqlite::params![&correct, pk],
|
|
)?;
|
|
}
|
|
}
|
|
}
|
|
if let Some(tx) = tx {
|
|
tx.commit()?;
|
|
}
|
|
if failures > 0 {
|
|
println!(
|
|
"datetime_header_value: {failures} failure{}",
|
|
if failures == 1 { "" } else { "s" }
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn remove_empty_accounts_lint(db: &mut Connection, dry_run: bool) -> Result<()> {
|
|
let mut col = vec![];
|
|
{
|
|
let mut stmt = db.connection.prepare(
|
|
"SELECT * FROM account WHERE NOT EXISTS (SELECT 1 FROM subscription AS s WHERE \
|
|
s.address = address) ORDER BY pk",
|
|
)?;
|
|
let iter = stmt.query_map([], |row| {
|
|
let pk = row.get("pk")?;
|
|
Ok(DbVal(
|
|
Account {
|
|
pk,
|
|
name: row.get("name")?,
|
|
address: row.get("address")?,
|
|
public_key: row.get("public_key")?,
|
|
password: row.get("password")?,
|
|
enabled: row.get("enabled")?,
|
|
},
|
|
pk,
|
|
))
|
|
})?;
|
|
|
|
for entry in iter {
|
|
let entry = entry?;
|
|
col.push(entry);
|
|
}
|
|
}
|
|
if col.is_empty() {
|
|
println!("remove_empty_accounts: ok");
|
|
} else {
|
|
let tx = if dry_run {
|
|
None
|
|
} else {
|
|
Some(db.connection.transaction()?)
|
|
};
|
|
println!("remove_empty_accounts: found {} entries", col.len());
|
|
println!("pk\tAddress");
|
|
for DbVal(Account { pk, address, .. }, _) in &col {
|
|
println!("{pk}\t{address}");
|
|
}
|
|
if let Some(tx) = tx {
|
|
for DbVal(_, pk) in col {
|
|
tx.execute("DELETE FROM account WHERE pk = ?", [pk])?;
|
|
}
|
|
tx.commit()?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn remove_accepted_subscription_requests_lint(
|
|
db: &mut Connection,
|
|
dry_run: bool,
|
|
) -> Result<()> {
|
|
let mut col = vec![];
|
|
{
|
|
let mut stmt = db.connection.prepare(
|
|
"SELECT * FROM candidate_subscription WHERE accepted IS NOT NULL ORDER BY pk",
|
|
)?;
|
|
let iter = stmt.query_map([], |row| {
|
|
let pk = row.get("pk")?;
|
|
Ok(DbVal(
|
|
ListSubscription {
|
|
pk,
|
|
list: row.get("list")?,
|
|
address: row.get("address")?,
|
|
account: row.get("account")?,
|
|
name: row.get("name")?,
|
|
digest: row.get("digest")?,
|
|
enabled: row.get("enabled")?,
|
|
verified: row.get("verified")?,
|
|
hide_address: row.get("hide_address")?,
|
|
receive_duplicates: row.get("receive_duplicates")?,
|
|
receive_own_posts: row.get("receive_own_posts")?,
|
|
receive_confirmation: row.get("receive_confirmation")?,
|
|
},
|
|
pk,
|
|
))
|
|
})?;
|
|
|
|
for entry in iter {
|
|
let entry = entry?;
|
|
col.push(entry);
|
|
}
|
|
}
|
|
if col.is_empty() {
|
|
println!("remove_accepted_subscription_requests: ok");
|
|
} else {
|
|
let tx = if dry_run {
|
|
None
|
|
} else {
|
|
Some(db.connection.transaction()?)
|
|
};
|
|
println!(
|
|
"remove_accepted_subscription_requests: found {} entries",
|
|
col.len()
|
|
);
|
|
println!("pk\tAddress");
|
|
for DbVal(ListSubscription { pk, address, .. }, _) in &col {
|
|
println!("{pk}\t{address}");
|
|
}
|
|
if let Some(tx) = tx {
|
|
for DbVal(_, pk) in col {
|
|
tx.execute("DELETE FROM candidate_subscription WHERE pk = ?", [pk])?;
|
|
}
|
|
tx.commit()?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn warn_list_no_owner_lint(db: &mut Connection, _: bool) -> Result<()> {
|
|
let mut stmt = db.connection.prepare(
|
|
"SELECT * FROM list WHERE NOT EXISTS (SELECT 1 FROM owner AS o WHERE o.list = pk) ORDER \
|
|
BY pk",
|
|
)?;
|
|
let iter = stmt.query_map([], |row| {
|
|
let pk = row.get("pk")?;
|
|
Ok(DbVal(
|
|
MailingList {
|
|
pk,
|
|
name: row.get("name")?,
|
|
id: row.get("id")?,
|
|
address: row.get("address")?,
|
|
description: row.get("description")?,
|
|
topics: vec![],
|
|
archive_url: row.get("archive_url")?,
|
|
},
|
|
pk,
|
|
))
|
|
})?;
|
|
|
|
let mut col = vec![];
|
|
for entry in iter {
|
|
let entry = entry?;
|
|
col.push(entry);
|
|
}
|
|
if col.is_empty() {
|
|
println!("warn_list_no_owner: ok");
|
|
} else {
|
|
println!("warn_list_no_owner: found {} entries", col.len());
|
|
println!("pk\tName");
|
|
for DbVal(MailingList { pk, name, .. }, _) in col {
|
|
println!("{pk}\t{name}");
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|